Provavelmente todo jogador pensou em como criar um jogo no Android. Este sistema operacional oferece grandes oportunidades para criadores de jogos. Mas por onde um iniciante deve começar para criar seu próprio jogo e como os jogos Android são criados sem conhecimentos especiais de programação?
Apesar da popularidade do Android, não existem tantos programas de design para ele quanto gostaríamos. A maioria deles é paga e exige uma compensação bastante grande pelo direito de vender os jogos criados com a ajuda deles. Mas se houver vontade, haverá um caminho. Se o desejo for grande, você pode encontrar um software gratuito com seu próprio mecanismo. É verdade que você ainda precisa gastar algum tempo tentando descobrir.
Você pode fazer um jogo no Android usando o seguinte programas gratuitos(selecionou o mais popular):
Vamos dar uma olhada em cada um deles.
Esta estrutura, publicada pela primeira vez em 2005, foi projetada para criar jogos 2D e 3D para Android. Você também pode criar programas regulares para os sistemas operacionais Android e Windows. Você vê imediatamente seu produto final, para o qual DirectX e OpenGl ES são usados. Uma grande vantagem do programa é a disponibilidade de todas as ferramentas necessárias. Os scripts são criados usando JavaScript.
Este mecanismo de jogo possui bom desempenho gráfico. Todas as sombras e reflexos dos objetos são bem desenhados nele, é possível adicionar uma variedade de efeitos de iluminação e shaders. Todos os arquivos de designer editáveis podem ser salvos nos populares formatos 3Ds MaX, DirectX e AutoCAD.
A física é usada a partir do eminente mecanismo NVIDIA PhysX, que torna o movimento de todos os objetos no espaço muito orgânico. De forma bastante simples e confortável para o usuário, mapas de níveis e paisagens são editados, para cada item do mapa você pode especificar o material do qual deve ser feito. Juntamente com o som surround, esses recursos permitem criar bons jogos atmosféricos.
A notória equipe YoYo Games respondeu à questão de como fazer um jogo no Android. Juntamente com a MIPS Technologies, eles introduziram um programa de design para escrever jogos. O ambiente foi chamado simplesmente de GameMaker. Não requer conhecimento de nenhuma linguagem de programação para criar um produto, pode ser usado mesmo sem saber o básico de JavaScript. O ambiente possui uma linguagem de programação própria. Graças a isso, o tempo para criar um jogo de qualidade é reduzido significativamente. Além disso, o designer já conta com gráficos animados, alguns acompanhamentos musicais e efeitos sonoros simples. A equipe de desenvolvimento do GameMaker não impõe nenhuma restrição aos jogos criados com seu construtor. Por uma pequena taxa, você pode abrir recursos adicionais do programa, mas mesmo sem eles, o designer é mais do que funcional.
Instrução
Selecione a plataforma para a qual seu jogo será. Já que o mercado de sistemas operacionais móveis é muito diversificado, e cada sistema possui seus próprios recursos para a criação de aplicativos. Os mais populares agora são os seguintes sistemas iOs, Android, Symbian OS e Telefone do Windows 7. O melhor lugar para começar é na sala de cirurgia. Sistema Windows Telefone 7. Possui um ambiente de desenvolvimento conveniente que suporta várias tecnologias, como XNA e Silverlight.
Aprenda uma linguagem de programação. isto palco principal ao criar qualquer programa. E quanto mais habilidades de programação, mais oportunidades para implementar ideias. Uma das linguagens de programação poderosas e fáceis de aprender é o C#. Projetado pela Microsoft como alternativa à linguagem Java, esta linguagem tem um grande potencial.
Crie sua ideia para um jogo. Anote em um pedaço de papel ou em um documento separado tudo o que você deseja implementar em seu jogo. Mas considere suas opções. Não há necessidade de fazer planos difíceis de implementar. Pense em todos os pontos e destaque entre eles aqueles que você não consegue realizar com base no seu conhecimento. Para soluções tarefas difíceis Registre-se nos fóruns de desenvolvedores. Lá você sempre pode fazer uma pergunta para programadores mais experientes.
Instale o ambiente de desenvolvimento. Para criar jogos para o Windows Phone 7, você precisará do Visual Studio 2010 e do Windows Phone Developer Tools. Ambos os produtos são totalmente gratuitos.
Comece a desenvolver seu jogo. Decida o tipo de projeto, tecnologias adicionais e aulas. Determine imediatamente o tipo de controle do jogo. Talvez sejam prensas simples que envolvam uma ou ambas as mãos. Ou talvez vários sensores de posição e uma câmera estejam envolvidos. Pense na lógica do jogo e sua implementação.
Entre no design de jogos. Parte do conteúdo do aplicativo como: texturas, imagens, fontes e sons podem ser encontrados na Internet. Você pode desenhar o resto sozinho ou perguntar a outra pessoa.
Comece a testar o jogo. Esta é a última etapa do desenvolvimento do aplicativo. Crie testes para a lógica do aplicativo e rastreie os erros que ocorrem. Tente manter o número deles no mínimo.
Se o jogo estiver pronto, publique-o. Coloque-o em acesso gratuito ou registre-se na loja de aplicativos e tente ganhar dinheiro com isso. Não abandone sua ideia, mas tente apoiá-la melhorando e introduzindo algo novo.
Vídeos relacionados
Fontes:
Os jogos para celulares são criados pelo desenvolvedor, que geralmente é representado pela empresa. Mas também há casos em que uma pessoa está envolvida em tal processo.
Instrução
Decida o sistema operacional móvel para o qual o jogo será projetado. O fato é que hoje no mundo não existe uma única plataforma móvel que oprima com sua maioria quantitativa (por exemplo, como computadores, onde o Windows está sem dúvida na liderança). Cada fabricante promove algo diferente e, como resultado, o mercado possui cerca de dez sistemas operacionais. Os sistemas operacionais mais usados são Android, Symbian OS, iOs e Windows Phone 7.
Logo no início você terá que desenvolver o jogo para uma dessas plataformas, e só depois terá que refazer (portar) o jogo para outras. Tal processo não é trivial e requer uma abordagem ousada, porque às vezes a diferença entre as plataformas é bastante significativa.
Aprenda uma linguagem de programação. A programação é a parte mais importante na criação de qualquer programa de computador, e o programador é seu principal criador, e o nível de seu profissionalismo é diretamente proporcional ao sucesso do futuro jogo.
A opção ideal para desenvolvimento para dispositivos móveis, servirá a linguagem Java. Será difícil para iniciantes compreender seus fundamentos. Será mais correto e mais fácil começar com o básico da programação, primeiro tendo dominado currículo escolar informática.
Forme uma ideia para um jogo futuro. Crie um documento especial onde descreva tudo relacionado ao projeto, mas sem fanatismo. Você não precisa fazer planos grandiosos, mas ainda precisa transformá-los em realidade aplicando suas habilidades de programação. Pensando no conceito, lembre-se da literatura sobre programação, pense em tudo de um ponto de vista lógico.
Este tutorial inicia uma série de artigos sobre como escrever jogos de arcade para Android. O ciclo foi tomado como base, que ele escreveu e publicou em seu blog Tamas Jano. O material é destinado principalmente a programadores novatos que desejam experimentar a criação de jogos para Android. Eu me propus a criar em nosso site o livro didático mais compreensível e acessível para um público jovem de língua russa, então espero muito por suas críticas, perguntas e comentários. O material publicado neste ciclo será constantemente revisado levando em consideração suas dúvidas, desejos e comentários. Espero que juntos possamos realizar com sucesso esta pequena experiência.
Alexandre Ledkov
Antes de passar diretamente para a programação, vamos definir nossas tarefas e descrever em termos gerais nossa jogo futuro. A ideia é simples: o personagem principal luta contra hordas de robôs que querem destruí-lo. Ele tem três vidas e uma arma laser. Os robôs não podem atirar. Tudo o que eles podem fazer é pegar nosso herói e arrancar sua cabeça... bem, ou outra coisa. O personagem é controlado por dois "joysticks de toque". Você provavelmente os conheceu em jogos semelhantes. Um joystick será colocado no canto inferior esquerdo, responsável por mover o herói. No canto inferior direito - para a arma.
Vamos simular uma situação de jogo. Nosso personagem está no centro da tela. Os robôs estão se aproximando dele a cada 1/10 de segundo. a cada décimo de segundo, também verificamos se a tela foi tocada. Se aconteceu, movemos nosso personagem na direção desejada ou damos um tiro. se o tiro for disparado, a cada tick (1/10 de segundo) verificamos se a bala atinge os inimigos. Se a bala atingir o robô, o robô e a bala explodem, caso contrário, os robôs e a bala se movem para novas posições (o robô se move 5 pixels por carrapato e a bala se move 50 pixels). Também verificamos se o robô pegou nosso herói. Se for pego, o jogo termina.
No caso mais simples, a arquitetura do jogo pode ser representada pelos seguintes módulos, chamados ciclicamente:
Vamos dar uma olhada em nossos módulos.
Em nosso jogo, as mensagens são geradas quando o usuário toca em duas áreas da tela. O programa escuta eventos onTouch e registra as coordenadas de cada toque. Se as coordenadas estiverem dentro da área de controle, enviamos o comando correspondente ao mecanismo do jogo. Por exemplo, se houve um toque na lateral do círculo, devemos mover nosso personagem na direção apropriada. Se houve um toque do círculo que controla a arma, enviamos um comando ao motor para processar o evento de disparo.
O módulo de lógica do jogo é responsável por alterar os estados de todos os personagens do jogo, ou seja, cada objeto que possui um estado (Nosso herói, robôs, tiros de laser). 
Vejamos a interação entre o módulo de controle e o mecanismo de jogo. A figura acima mostra um controlador de círculo. O ponto verde claro simboliza a área de toque. O módulo de controle informa ao mecanismo do jogo as coordenadas do toque (dx e dy são distâncias em pixels do centro do círculo). Com base nessas coordenadas, o mecanismo do jogo calcula a direção e a velocidade do movimento de nosso herói. Por exemplo, se dx>0, nosso personagem se move para a direita, se dy>0 - para cima.
Este módulo controla a reprodução do som dependendo da situação do jogo. Os sons podem ser gerados por diferentes objetos do jogo, mas como o número de canais de som é limitado (o número de canais de som corresponde ao número de arquivos de som que podem ser reproduzidos ao mesmo tempo), o módulo de áudio deve decidir quais sons tocar e quais não. Por exemplo, um robô representa um grande perigo para o nosso herói, por isso precisamos chamar a atenção do jogador para sua aparência, por exemplo, ligar o som de uma sirene e, claro, simplesmente temos que dar voz a todos os tiros de nosso personagem.
Este módulo é responsável por exibir a situação do jogo na tela do celular. No Android, existem várias maneiras de renderizar uma imagem na tela. Você pode desenhar diretamente na tela recebida do View, ou usar um buffer gráfico separado e você, e então passá-lo para o View, ou você pode usar os recursos da biblioteca OpenGL. É útil ao desenvolver um jogo medir constantemente o FPS - o número de quadros por segundo que seu mecanismo gráfico produz. Um valor de 30 FPS significa que em um segundo nosso programa consegue atualizar a tela 30 vezes. Olhando para o futuro, direi que, para um dispositivo móvel, 30 FPS é mais do que um indicador decente.
Não vou descrever em detalhes o processo de instalação do Android SDK e Eclipse aqui, vou deixar as etapas elementares para criar um projeto Android fora do escopo da história. Há um grande número de tutoriais e artigos sobre esse tópico na Internet.
Crio novo projeto. No campo Nome do projeto, insira Droidz. Selecione Android 2.2 ou superior como a plataforma de destino. Em Nome do Pacote - " en.mobilab.gamesample". Não se esqueça de marcar a caixa ao lado de Criar atividade. Para o nome da atividade principal, digite DroidzActivity.
Abra o arquivo src/ru.mobilab.gamesample/DroidzActivity.java
importar android.app.Activity;
importar android.os.Bundle;
classe pública DroidzActivity estende Activity(
/** Chamado quando a atividade é criada pela primeira vez. */
@Sobrepor
public void onCreate(Pacote salvadoInstanceState) (
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
O método onCreate é chamado quando uma atividade é criada durante a inicialização do aplicativo. Este método pode ser considerado como um ponto de entrada no programa. A classe R.java é gerada automaticamente pelo Eclipse e contém referências a recursos. Toda vez que você altera os recursos no Eclipse, a classe R é reconstruída.
Qualquer jogo deve ter um loop que irá capturar os comandos do usuário, processá-los, alterar o estado dos objetos do jogo de acordo, exibir um novo quadro na tela e reproduzir som. Já criamos um projeto Android simples. Vamos agora criar a implementação do loop do jogo.
Como você deve se lembrar, no Android tudo acontece dentro de uma Activity. Activity cria uma View - um objeto onde toda a diversão acontece. É através dele que podemos obter informações sobre toques na tela, aqui você também pode exibir uma imagem na tela.
Vamos abrir o arquivo DroidzActivity.java. No construtor da classe, você verá a linha
SetContentView(R.layout.main);
esta linha seleciona o objeto View atual para a atividade. Vamos criar um novo objeto View. A maioria de forma simples obtendo uma visualização - crie sua própria classe baseada em SurfaceView. Em nossa classe, implementamos a interface SurfaceHolder.Callback para acelerar o acesso às alterações de superfície, como quando a superfície é destruída quando a orientação do dispositivo é alterada.
MainGamePanel.java
pacote en.mobilab.gamesample;
SurfaceHolder.Callback(
super(contexto);
// Adiciona esta classe como contendo uma função reversa
// chamada para interagir com eventos
// torna o GamePanel focalizável para que ele possa processar mensagens
setFocusable(verdadeiro);
}
@Sobrepor
}
@Sobrepor
}
@Sobrepor
}
@Sobrepor
}
@Sobrepor
}
}
A listagem acima mostra o modelo de classe que precisamos implementar. Vamos dar uma olhada mais de perto no conteúdo do construtor. Linha
GetHolder().addCallback(this);
Define a classe atual (MainGamePanel) como o manipulador de eventos de superfície.
SetFocusable(verdadeiro);
Essa linha torna nossa classe focalizável. Isso significa que ele pode receber foco e, portanto, eventos.
Vamos criar um thread dentro do qual nosso loop de jogo será realmente implementado. Dividir um jogo em várias threads rodando em paralelo é uma prática comum no desenvolvimento de jogos modernos. Vamos criar uma classe MainThread.java para nossa thread
Pacote en.mobilab.gamesample;
classe pública MainThread estende Thread(
//flag indicando que o jogo está rodando.
execução booleana privada;
public void setRunning(boolean running) (
this.running = em execução;
}
@Sobrepor
public void run() (
enquanto correndo) (
// atualiza o estado dos objetos do jogo
// exibe gráficos na tela
}
}
}
Como você pode ver, esta classe é muito mais simples que a anterior. Internamente, substituímos o método run(). A thread está rodando enquanto esse método estiver rodando, então organizamos um loop infinito dentro dela. Adicionamos uma variável booleana chamada running para servir como um indicador de saída do loop. Agora, para encerrar o thread, basta alterar o valor dessa variável para false em algum lugar.
Depois de criarmos a classe thread, precisamos executá-la. Vamos executá-lo no carregamento da tela. Altere a classe MainGamePanel
Pacote en.mobilab.gamesample;
importar android.content.Context;
importar android.graphics.Canvas;
importar android.view.MotionEvent;
importar android.view.SurfaceHolder;
importar android.view.SurfaceView;
classe pública MainGamePanel estende implementos SurfaceView
SurfaceHolder.Callback(
Encadeamento Privado MainThread;
MainGamePanel público (contexto de contexto) (
super(contexto);
getHolder().addCallback(this);
// cria uma thread para o loop do jogo
thread = new MainThread();
SetFocusable(verdadeiro);
}
@Sobrepor
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) (
}
@Sobrepor
public void surfaceCreated(SurfaceHolder holder) (
thread.setRunning(true);
thread.start();
}
@Sobrepor
public void surfaceDestroyed(SurfaceHolder holder) (
//envia o comando para fechar a thread e espera,
//até que o stream seja fechado.
repetição booleana = verdadeiro;
enquanto (repetir) (
tentar(
thread.join();
repetir=falso;
) catch (InterruptedException e) (
// tenta parar o thread novamente
}
}
}
@Sobrepor
public boolean onTouchEvent(MotionEvent event) (
return super.onTouchEvent(evento);
}
@Sobrepor
void protegido onDraw (tela da tela) (
}
}
Nós declaramos o objeto thread
Encadeamento Privado MainThread;
e criei no construtor
Tópico = new Tópico Principal();
no método surfaceCreated, definimos o sinalizador running como true e iniciamos o thread. A essa altura, o objeto thread já foi criado com sucesso e podemos executá-lo com segurança.
O método surfaceDestroyed é chamado antes que a superfície seja fechada. Não é suficiente simplesmente remover o sinalizador de execução aqui. Precisamos ter certeza de que o fluxo realmente foi fechado. Nós apenas bloqueamos o thread e esperamos até que ele morra.
Vamos escrever um pequeno exemplo para mostrar como lidar com toques no Android. Sairemos do programa quando o usuário tocar na parte inferior da tela. Se o toque aconteceu em algum lugar mais alto, simplesmente enviaremos as coordenadas correspondentes para o log. Adicione as seguintes linhas à classe MainThread:
Private SurfaceHolder SurfaceHolder;
private MainGamePanel gamePanel;
public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) (
super();
this.surfaceHolder = surfaceHolder;
this.gamePanel = gamePanel;
}
assim, definimos as variáveis gamePanel e surfaceHolder, pegando os valores apropriados dos parâmetros do construtor. Precisamos lembrar desses valores para que posteriormente possamos bloquear a superfície durante o desenho, e isso só pode ser feito através do surfaceHolder.
Altere a linha na classe MainGamePanel para adicionar os parâmetros recém-declarados ao construtor
Thread = new MainThread(getHolder(), this);
Passamos o manipulador atual e o painel para o novo construtor. Isso nos permitirá acessá-lo a partir do stream. No gamePanel, vamos criar um método de atualização e vamos trocá-lo do thread, mas por enquanto vamos deixar tudo como está.
A seguir, escreveremos um código auxiliar que executa o registro - escrevendo linhas de depuração especiais com texto que refletem o estado do nosso programa em um arquivo especial, que pode ser visualizado e tentar entender o que aconteceu no programa. Vamos adicionar a constante TAG à classe MainThread. Cada classe terá sua própria constante chamada TAG, que conterá o nome da classe correspondente. Usaremos o framework de log do Android para logar, dentro dessa biblioteca, cada log deve ter dois parâmetros. O primeiro parâmetro especifica o local de onde o log é gravado. É para esses propósitos que criamos a constante TAG. O segundo parâmetro é a mensagem real que queremos gravar no log. Usar nomes de classe como primeiro parâmetro é uma prática bastante comum entre os programadores java.
Para visualizar os logs registrados durante a execução do programa, selecione o menu
Janelas -> Mostrar Visualização -> Outros…
e, em seguida, na caixa de diálogo aberta
Android -> Logcat
Na janela que se abre, você pode não apenas visualizar os logs, mas também filtrar e pesquisar.
Vamos voltar ao nosso código. Vamos fazer alterações em MainThread.java
Pacote en. mobilab. amostra de jogo; importar android. util. Registro ; importar android. Visão. SurfaceHolder; public class MainThreadextends Thread( private static final String TAG= MainThread. class . getSimpleName() ; private SurfaceHolder surfaceHolder; private MainGamePanel gamePanel; private boolean running; public void setRunning(boolean running) ( this. running= running; ) public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) ( super() ; this. surfaceHolder= surfaceHolder; this. gamePanel= gamePanel; ) @ Substituir public void run() ( long tickCount= 0L; Log . d(TAG, "Iniciando o loop do jogo" ); while (executando) ( tickCount++; // o estado do jogo será atualizado aqui // e forma um quadro para exibição) Registro . d(TAG, "Jogo executado" + tickCount+ "vezes" ); ) )
Como você pode ver, definimos um TAG e chamamos o comando Log dentro do método run, que faz a entrada correspondente no arquivo de log. Enviamos o valor da variável tickCount para o log, que na verdade é um contador de loop de jogo e mostra quantas vezes o loop de jogo foi executado durante a operação do programa.
Vamos para o arquivo MainGamePanel.java e encontrar o método onTouchEvent, que é o manipulador de toque da tela.
public boolean onTouchEvent(MotionEvent event) ( if (event. getAction() == MotionEvent. ACTION_DOWN) ( if (event. getY() > getHeight() - 50 ) ( thread. setRunning(false ) ; ((Activity) getContext( ) ) .finish() ; ) else ( Log .d(TAG, "Coords: x=" + event.getX() + ",y=" + event.getY() ) ; ) ) return super.onTouchEvent(event ) ; )Primeiro, verificamos se ocorreu um evento de toque na tela (MotionEvent.ACTION_DOWN). Nesse caso, verificamos a coordenada y e se estiver na parte inferior da tela (50 pixels a partir da parte inferior), enviamos ao thread um comando para terminar (configurando a variável em execução como false) e, em seguida, chamamos o final () na Activity principal, que fecha todo o nosso programa.
Comente. A origem do sistema de coordenadas da tela está no canto superior esquerdo. O eixo y está para baixo, o eixo x está para a direita. A largura e altura da tela podem ser obtidas através dos métodos getWidth() e getHeight(), respectivamente.
Modifique DroidzActivity.java adicionando comandos de registro
Pacote en. mobilab. amostra de jogo; importar android. aplicativo. atividade; importar android. os. pacote; importar android. util. Registro ; importar android. Visão. Janela; importar android. Visão. gerenciador de janelas; classe pública DroidzActivityextendsActivity( /** Chamado quando a atividade é criada. */ private static final String TAG= DroidzActivity. classe. getSimpleName() ; @Override public void onCreate(Bundle saveInstanceState) ( super. onCreate(savedInstanceState) ; // solicitação para desabilitar a barra de título requestWindowFeature(Window.FEATURE_NO_TITLE) ; // coloca o aplicativo em modo de tela cheia getWindow() . setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN) ; // define MainGamePanel como View setContentView(new MainGamePanel(this) ); registro. d(TAG, "Visualização adicionada" ); ) @ Substituir void protegido onDestroy() ( Log . d(TAG, "Destruindo..." ); super. onDestroy() ; ) @ Substituir void protegido onStop() ( Log . d(TAG, "Parando..." ) ; super.onStop() ; ) )
Vamos executar o aplicativo. Depois de iniciar, você deve ver uma tela preta. Clique algumas vezes na parte superior da tela e depois na parte inferior. o programa será fechado. É hora de verificar o registro.
Olhando o log, você terá uma ideia clara da ordem em que os métodos são executados. Você também pode ver quantas vezes o loop do jogo foi executado durante a execução do programa. Esta figura não significa nada, da próxima vez vamos registrar mais informação útil: FPS e UPS (atualizações por segundo).
Resumir. Nós criamos um aplicativo de tela cheia. Escrevemos uma classe que é executada em um thread separado e conterá o mecanismo do jogo. Escreveu método mais simples tela de processamento toca e fecha o aplicativo com competência.
Da próxima vez, vamos passar para o desenho. O código-fonte deste tutorial pode ser baixado.
Tradução e adaptação: Alexandre Ledkov
Denis Zaritsky
Desenvolvedor Programas. Ele gosta de desenvolver jogos no Unreal Engine, também se interessa por: JavaScript, HTML5, Node.js, User Experience, educação online, inteligência artificial e marketing na internet. Gosta de participar de startups e projetos interessantes.
Muitos sonham em criar seu próprio jogo. Mas antes de começar a desenvolvê-lo, você precisa decidir sobre o motor do jogo, que é uma grande variedade.
O que é um motor de jogo? Em suma, trata-se de um conjunto de sistemas que simplificam as funções mais utilizadas do jogo. Você pode, é claro, escrever o mecanismo do zero, mas isso levará um tempo excessivamente longo. Neste artigo, veremos mecanismos de jogos populares para o desenvolvimento de jogos para dispositivos móveis. Ao comparar seus recursos, você pode escolher aquele que melhor se adapta a você e criar seu próximo grande sucesso.
Vamos dar uma olhada na lista!
É um mecanismo de plataforma cruzada para criar jogos para iOS e Android. A API permite que você crie jogos 2D e também o ajudará a criar funções complexas usando a API baseada em Lua. Além disso, você pode monetizar Corona SDK com Corona Ads. Desenvolver com Corona é bastante fácil graças aos testes em tempo real.
Corona inclui recursos interessantes como Corona Editor, plug-in Sublime Text e muitos outros. A GUI do Composer, disponível no OS X, fornecerá um ambiente gráfico onde você pode criar níveis de jogo e ver como os objetos interagem uns com os outros usando o mecanismo de física do Corona.
Esta é uma estrutura para desenvolver jogos HTML5 para desktop e dispositivos móveis com base na biblioteca PIXI.js. Suporta renderização Canvas e WebGL, sprites animados, partículas, áudio, múltiplas entradas e física de objetos. Phaser é distribuído de código aberto sob a licença MIT. Isso significa que você pode usar o código sem restrições, mas manter os avisos de direitos autorais nas cópias do software, ou seja, você precisará adicionar um aviso de direitos autorais a esse framework no texto de sua licença. É bem apoiado por Richard Davy e pela comunidade que surgiu ao seu redor.
Introduzido em 2010, é um projeto de código aberto distribuído sob a licença MIT. O desenvolvimento de jogos no Cocos2d-x é baseado no uso de sprites. Esses contêineres são usados para criar todos os tipos de cenas, como localizações de jogos ou menus. Sprites são controlados usando animação ou código de programa em C++, JavaScript ou Lua. Graças a uma interface visual moderna, os sprites podem ser facilmente modificados, movidos, dimensionados e outras manipulações são realizadas com eles.
É uma estrutura de plataforma cruzada escrita em Java e funciona com OpenGL. Oferece suporte para múltiplas plataformas para publicação de jogos. Ingress (o antecessor do Pokémon GO) foi desenvolvido usando libGDX. O suporte da comunidade também é ótimo, então você pode obter uma ótima documentação para trabalhar.
Neste artigo, examinamos vários frameworks e mecanismos para desenvolvimento de jogos. Agora você deve ter uma ideia de quais serão as soluções a melhor maneira atender às suas próximas necessidades de desenvolvimento de jogos para dispositivos móveis. Obrigado pela sua atenção. Espero que o artigo tenha sido útil para você.
Este tutorial destina-se principalmente a iniciantes no desenvolvimento Android, mas pode ser útil para desenvolvedores mais experientes. Aqui está como criar um jogo 2D simples no Android sem usar nenhum mecanismo de jogo. Usei o Android Studio para isso, mas qualquer outro ambiente de desenvolvimento configurado adequadamente pode ser usado.
Etapa 1. Tenha uma ideia para um jogo
Por exemplo, vamos pegar uma ideia bastante simples:
Parte inferior da tela - nave espacial. Ele pode se mover para a esquerda e para a direita pressionando os botões correspondentes. Os asteróides se movem verticalmente para baixo de cima. Eles aparecem em toda a largura da tela e se movem com velocidade diferente. A nave deve evitar meteoritos pelo maior tempo possível. Se um meteorito o atingir, o jogo termina.
Passo 2. Crie um projeto
No Android Studio, selecione Arquivo → Novo → Novo projeto no menu superior.
Aqui inserimos o nome do aplicativo, domínio e caminho. Clique em Avançar.
Aqui você pode inserir a versão do Android. Você também pode escolher um relógio Android e uma TV. Mas não tenho certeza se nosso aplicativo funcionará em tudo isso. Portanto, é melhor inserir tudo como na captura de tela. Clique em Avançar.
Aqui, certifique-se de selecionar Atividade vazia. E clique em Avançar.
Deixe tudo como está e clique em Concluir. Então o projeto é criado. Vamos para a terceira etapa.
Etapa 3: adicionar imagens
Etapa 5: editando a classe MainActivity
Em primeiro lugar, adicione os implementos View.OnTouchListener à definição de classe. A definição da classe ficará assim:
Classe pública MainActivity estende AppCompatActivity implementa View.OnTouchListener (
Vamos adicionar as variáveis estáticas que precisamos (variáveis de classe) à classe:
public static boolean isLeftPressed = false; // botão esquerdo pressionado public static boolean isRightPressed = false; //botão direito pressionado
Para o procedimento protegido void onCreate(Bundle saveInstanceState) (
adicionar linhas:
GameView gameView = new GameView(this); // cria gameView LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // encontra gameLayout gameLayout.addView(gameView); // e adicione GameView Button a ele leftButton = (Button) findViewById(R.id.leftButton); // encontrar botões Button rightButton = (Button) findViewById(R.id.rightButton); botãoesquerdo.setOnTouchListener(este); // e adicione esta classe como um ouvinte (quando pressionado, onTouch funcionará) rightButton.setOnTouchListener(this);
Classes LinearLayout, Button, etc. estão destacados em vermelho porque ainda não foram adicionados à Importação.
Para adicionar ao Import e remover o destaque vermelho, você precisa pressionar Alt + Enter para cada um.
O GameView ficará destacado em vermelho porque a classe ainda não existe. Nós o criaremos mais tarde.
Agora adicione um procedimento:
Public boolean onTouch(View button, MotionEvent motion) ( switch(button.getId()) ( // determina qual botão está pressionado caso R.id.leftButton: switch (motion.getAction()) ( // determina se está pressionado ou liberado case MotionEvent. ACTION_DOWN: isLeftPressed = true; break; case MotionEvent.ACTION_UP: isLeftPressed = false; break; ) break; case R.id.rightButton: switch (motion.getAction()) ( // determina se está pressionado ou liberado case MotionEvent.ACTION_DOWN: isRightPressed = true; break; case MotionEvent.ACTION_UP: isRightPressed = false; break; ) break; ) return true; )
Se alguém estiver confuso, é assim que a classe MainActivity deve ficar como resultado:
Pacote com.spaceavoider.spaceavoider; importar android.support.v7.app.AppCompatActivity; importar android.os.Bundle; importar android.view.MotionEvent; importar android.view.View; importar android.widget.Button; importar android.widget.LinearLayout; public class MainActivity estende AppCompatActivity implementa View.OnTouchListener ( public static boolean isLeftPressed = false; // botão esquerdo pressionado public static boolean isRightPressed = false; // botão direito pressionado @Override protected void onCreate(Bundle saveInstanceState) ( super.onCreate(savedInstanceState) ; setContentView(R.layout.activity_main); GameView gameView = new GameView(this); // cria gameView LinearLayout gameLayout = (LinearLayout) findViewById(R.id.gameLayout); // encontra gameLayout gameLayout.addView(gameView); / / e adiciona botão gameView leftButton = (Button) findViewById(R.id.leftButton); // encontra botões Button rightButton = (Button) findViewById(R.id.rightButton); leftButton.setOnTouchListener(this); // e adiciona isto class como um ouvinte (quando clicado, onTouch será acionado) rightButton.setOnTouchListener(this); ) public boolean onTouch(botão View, MotionEvent motion) ( switch(button.getId()) ( // determina qual caixa de botão R .id.leftButton: switch (motion.getAction()) ( // determina se é pressionado ou liberado case MotionEvent.ACTION_DOWN: isLeftPressed = true; parar; caso MotionEvent.ACTION_UP: isLeftPressed = false; parar; ) parar; case R.id.rightButton: switch (motion.getAction()) ( // determina se está pressionado ou solto case MotionEvent.ACTION_DOWN: isRightPressed = true; break; case MotionEvent.ACTION_UP: isRightPressed = false; break; ) break; ) retorna verdadeiro; ) )
Então, a classe MainActivity está pronta! Nela, é iniciada a classe GameView, que ainda não foi criada. E quando o botão esquerdo é pressionado, a variável estática éLeftPressed = true, e quando o botão direito é pressionado, éRightPressed = true. Isso é basicamente tudo o que ele faz.
Para começar, vamos fazer a nave aparecer na tela e movê-la pressionando os botões de controle. Vamos deixar os asteróides para mais tarde.
Etapa 6 Crie a classe GameView
Agora vamos finalmente criar a classe GameView ausente. Então vamos começar. Add estende implementos SurfaceView Runnable para a definição de classe. Dispositivos móveis Eu tenho diferentes resoluções de tela. Pode ser um telefone pequeno antigo com resolução de 480x800 ou um tablet grande de 1800x2560. Para que o jogo fique igual em todos os aparelhos, dividi a tela em 20 partes na horizontal e 28 na vertical. Chamei a unidade de medida resultante de unidade. Você pode escolher outros números também. O principal é que a relação entre eles seja aproximadamente preservada, caso contrário a imagem será alongada ou comprimida.
public static int maxX = 20; // tamanho horizontal public static int maxY = 28; // tamanho vertical public static float unitW = 0; // pixels horizontais em uma unidade public static float unitH = 0; // pixels por unidade verticalmente
unitW e unitW que calcularemos mais tarde. Também precisaremos de outras variáveis:
Privado booleano firstTime = true; private boolean gameRunning = true; navio privado; Thread privado gameThread = null; tinta pintura privada; tela Canvas privada; private SurfaceHolder SurfaceHolder;
O construtor ficará assim:
Public GameView(Context context) ( super(context); //inicializar objetos de desenho surfaceHolder = getHolder(); paint = new Paint(); //inicializar thread gameThread = new Thread(this); gameThread.start(); )
O método run() conterá um loop infinito. No início do loop, o método update() é executado.
que calculará as novas coordenadas do navio. O método draw() então desenha o navio na tela. E no final, o método control() fará uma pausa de 17 milissegundos. Após 17 milissegundos, run() será executado novamente. E assim por diante até a variável gameRunning == true. Aqui estão os métodos:
@Override public void run() ( while (gameRunning) ( update(); draw(); control(); ) ) private void update() ( if(!firstTime) ( ship.update(); ) private void draw () ( if (surfaceHolder.getSurface().isValid()) ( //verifica se a superfície é válida if(firstTime)( // inicialização na primeira execução firstTime = false; unitW = surfaceHolder.getSurfaceFrame().width() /maxX ; // calcula o número de pixels na unidade unitH = surfaceHolder.getSurfaceFrame().height()/maxY; ship = new Ship(getContext()); // adiciona o ship ) canvas = surfaceHolder.lockCanvas() ; // fecha a tela canvas .drawColor(Color.BLACK); // preenche o fundo com preto ship.drow(paint, canvas); // desenha a superfície do navioHolder.unlockCanvasAndPost(canvas); // abre a tela ) ) private void control () ( // pausa por 17 milissegundos try ( gameThread.sleep(17); ) catch (InterruptedException e) ( e.printStackTrace(); ) )
Preste atenção à inicialização na primeira execução. Lá calculamos o número de pixels na unidade e adicionamos o navio. Ainda não criamos um navio. Mas primeiro, criaremos sua classe pai.
Etapa 7: criar a classe SpaceBody
Será o pai da classe Ship (nave espacial) e Asteroid (asteroide). Ele conterá todas as variáveis e métodos comuns a essas duas classes. Adicionando variáveis:
flutuador protegido x; // coordenadas protegidas float y; tamanho do flutuador protegido; // velocidade de flutuação protegida por tamanho; // velocidade protegida int bitmapId; // id da imagem protegida Bitmap bitmap; // foto
e métodos
Void init(Context context) ( // comprime a imagem no tamanho desejado Bitmap cBitmap = BitmapFactory.decodeResource(context.getResources(), bitmapId); bitmap = Bitmap.createScaledBitmap(cBitmap, (int)(size * GameView.unitW) , ( int)(size * GameView.unitH), false); cBitmap.recycle(); ) void update()( // novas coordenadas serão calculadas aqui ) void drow(Paint paint, Canvas canvas)( // desenha uma imagem canvas.drawBitmap (bitmap, x*GameView.unitW, y*GameView.unitH, pintura); )
Etapa 8: criar a classe de navio
Agora vamos criar a classe Ship (nave espacial). Ele herda a classe SpaceBody, então vamos adicionar extends SpaceBody à definição de classe.
Vamos escrever um construtor:
Public Ship(Context context) ( bitmapId = R.drawable.ship; // define os parâmetros iniciais size = 5; x=7; y=GameView.maxY - size - 1; speed = (float) 0.2; init(context); // inicializa a nave )
e sobrescrever o método update()
@Override public void update() ( // move a nave com base no botão pressionado if(MainActivity.isLeftPressed && x >= 0)( x -= speed; ) if(MainActivity.isRightPressed && x<= GameView.maxX - 5){
x += speed;
}
}
Nesta nave espacial está pronto! Nós compilamos e executamos tudo. Uma nave espacial deve aparecer na tela. Quando você pressiona os botões, ele deve se mover para a direita e para a esquerda. Agora adicione os asteróides caindo de cima. Quando você atinge um navio, o jogo termina.
Passo 9 Crie a Classe Asteroide
Vamos adicionar a classe Asteroid (asteroide). Ele também herda a classe SpaceBody, então vamos adicionar extends SpaceBody à definição de classe.
Vamos adicionar as variáveis que precisamos:
raio int privado = 2; // raio private float minSpeed = (float) 0.1; // velocidade mínima private float maxSpeed = (float) 0.5; // velocidade máxima
O asteróide deve aparecer em um ponto aleatório na parte superior da tela e voar para baixo em uma velocidade aleatória. Para fazer isso, x e velocidade são definidos usando um gerador de números aleatórios em seu construtor.
Public Asteroid(Context context) ( Random random = new Random(); bitmapId = R.drawable.asteroid; y=0; x = random.nextInt(GameView.maxX) - radius; size = radius*2; speed = minSpeed + (maxSpeed - minSpeed) * random.nextFloat(); init(contexto); )
O asteróide deve se mover verticalmente para baixo a uma certa velocidade. Portanto, no método update(), adicionamos velocidade à coordenada x.
@Override public void update() ( y += velocidade; )
Também precisaremos de um método para determinar se o asteroide colidiu com a nave.
Public boolean isCollision(float shipX, float shipY, float shipSize) ( return !(((x+size)< shipX)||(x >(shipX+shipSize))||((y+size)< shipY)||(y >(shipY+shipSize))); )
Vamos considerá-lo com mais detalhes. Para simplificar, consideramos a nave e o asteroide como quadrados. Aqui eu fui do oposto. Ou seja, eu determino quando os quadrados NÃO se cruzam.
((x+tamanho)< shipX) - корабль слева от астероида.
(x > (shipX+shipSize)) - nave à direita do asteróide.
((y+tamanho)< shipY) - корабль сверху астероида.
(y > (shipY+shipSize)) - a nave abaixo do asteroide.
Entre essas quatro expressões está || (ou). Ou seja, se pelo menos uma expressão for verdadeira (o que significa que os quadrados NÃO se cruzam) - as resultantes também são verdadeiras.
Eu inverto toda essa expressão com o sinal !. Como resultado, o método retorna true quando os quadrados se cruzam. O que precisamos.
Você pode ler sobre como determinar a interseção de formas mais complexas.
Etapa 10 Adicionando asteroides ao GameView
Adicione variáveis ao GameView:
ArrayList privado
adicione também 2 métodos:
Private void checkCollision()( // percorre todos os asteroides e verifica se um deles toca a nave para (Asteroid asteroid: asteroids) ( if(asteroid.isCollision(ship.x, ship.y, ship.size))( // jogador perdeu gameRunning = false; // para o jogo // TODO adiciona animação de explosão ) ) ) private void checkIfNewAsteroid()( // adiciona novo asteroide a cada 50 iterações if(currentTime >= ASTEROID_INTERVAL)( Asteroid asteroid = new Asteroid(getContext () ); asteroids.add(asteroid); currentTime = 0; )else( currentTime ++; ) )
E no método run(), adicionamos chamadas a esses métodos antes de chamar control().
@Override public void run() ( while (gameRunning) ( update(); draw(); checkCollision(); checkIfNewAsteroid(); control(); ) )
Em seguida, no método update(), adicionamos um loop que itera por todos os asteroides e chama o método update() neles.
Private void update() ( if(!firstTime) ( ship.update(); for (Asteroid asteroid: asteroids) ( asteroid.update(); ) ) )
Adicionamos o mesmo loop ao método draw().
Private void draw() ( if (surfaceHolder.getSurface().isValid()) ( //verifica se a superfície é válida if(firstTime)( // inicialização na primeira execução firstTime = false; unitW = surfaceHolder.getSurfaceFrame(). width( )/maxX; // calcula o número de pixels em uma unidade unitH = surfaceHolder.getSurfaceFrame().height()/maxY; ship = new Ship(getContext()); // adiciona um ship ) canvas = surfaceHolder. lockCanvas(); // fecha a tela canvas.drawColor(Color.BLACK); // preenche o fundo com navio preto.drow(paint, canvas); // desenha a nave for(Asteroid asteroid: asteroids)( // desenha os asteroides asteroid.drow(paint, canvas); ) surfaceHolder.unlockCanvasAndPost(canvas); // abre a tela ) )
Isso é tudo! O jogo 2D mais simples está pronto. Compile, execute e veja o que acontece!
Se alguém estiver confuso ou algo não funcionar, você pode baixar a fonte.
O jogo é, obviamente, primitivo. Mas pode ser melhorado adicionando novos recursos. Em primeiro lugar, é necessário implementar a remoção de asteróides que saíram da tela. Você pode tornar a nave capaz de atirar em asteróides, para que o jogo acelere gradualmente, adicione um cronômetro, uma tabela de recordes e muito mais. Se isso for do seu interesse, escreverei uma continuação, onde descreverei tudo isso.
Isso é tudo. Escreva comentários, perguntas, tópicos de seu interesse para continuar.
Tag:
Adicionar tags
