Android – Jogos – AndEngine

Jogos para Android – Apresentação/Tutorial

Game Engine

Game Engine é uma estrutura completa para suportar jogos, incluindo as APIs (bibliotecas).
É responsável por gerenciar o ciclo de jogo e os recursos, dando bastante flexibilidade ao desenvolvedor de jogos.
Alguns dos Game Engines para o Android

  • AndEngine – OpenSource, comunidade bastante ativa
  • Cactus2d – OpenSource, nacional, estágio inicial
  • Cocos2d – OpenSource, baseado no Cocos2d, usado no Iphone
  • JMonkey3D – openSource Java, possui porte para Android

libgdx – Biblioteca de Funções OpenGL ES – é usada na maior parte das engines e é responsável pelo acesso aos recursos OpenGL

Antes de Começar

Planejar – como qualquer desenvolvimento de software, sempre é muito vantajoso planejar o que será feito, pois elimina vários problemas óbvios e reescritas desnecessárias.
Selecionar mídias – criar a pasta “assets” e sua estrutura de arquivos já com os arquivos de imagens e sons (fácil, caso já tenha planejado o que fazer).
Adicionar as libs – criar a pasta “lib”, incluir os arquivos “andengine.jar” e “*.so”, alem de configurar o “ClassPathBuild”.

Pastas assets, lib e libs do projeto

Incluir no Java Build Path (nas configurações do projeto)

  • usando “add Jar” – andengine.jar
  • usando “add Class Folder” – a pasta libs
Inclusão das bibliotecas no projeto

Incluir no Order and Export os mesmos itens acima, para que estes façam parte do arquivo “.jar” final, pois sem eles o projeto não funciona.

Inclusão das bibliotecas no produto final

Conceitos do AndEngine

BaseGameActivity – a Classe Principal
Engine – gerencia o ciclo de jogo
Camera – define área de visão
Resources

  • Texture – imagens carregadas na memória de vídeo
  • TextureRegion – lê, configura e monta as imagens
  • TiledMap – imagem montada por pedaços
  • Font – tipo de letra
  • Sound / Music – sons do jogo

Scene

  • Camada / Texto / Entidade
  • Shape/Sprite/AnimatedSprite
  • Modificadores / definição de Eventos

Estrutura da BaseGameActvity

public class BaseJogo extends BaseGameActivity{
    @Override public Engine onLoadEngine() {
        return [Engine];
    }
    @Override public void onLoadResources() {
    }
    @Override public Scene onLoadScene() {
        return [Scene];
    }
    @Override public void onLoadComplete() {
    }
}

EngineOptions e Câmera – Conceito

Define forma de funcionamento da Engine

  • Formato de tela, habilita Sons e sensores
  • Região a ser visualizada na tela
  • Quanto maior a área, mais coisas cabem e menores elas ficam
Definições de Câmeras

De acordo com sua definição pode-se ter vários resultados diferentes na tela do aparelho.

EngineOptions e Camera – exemplo de código

public Engine onLoadEngine(){
    camera = new BoundCamera(0,0,larg,alt);
    EngineOptions engopt = new EngineOptions( true,
                 ScreenOrientation.LANDSCAPE,
                 new RatioResolutionPolicy(larg, alt), camera);
    engopt.setNeedsMusic(true);
    engopt.setNeedsSound(true);
    return new Engine(engopt);
}

Texturas – Conceito

São blocos de imagens montadas na memória de vídeo para otimizar renderização
São montadas a partir de Regiões de Textura

Exemplo de Textura

Imagem construída internamente na memória de vídeo para agilizar manipulações.

Textures – exemplo de código

mapao = new BitmapTextureAtlas(
                      512, 512, TextureOptions.BILINEAR);
mario = BitmapTextureAtlasTextureRegionFactory.
                       createTiledFromAsset(this.mapao, this,
                          "gfx/mario.png", 0, 0, 4,4); //128x160
explosao =BitmapTextureAtlasTextureRegionFactory.
                      createTiledFromAsset(this.mapao,this,
                      "gfx/explosao.png",129,0, 8,1);//256x32
caixa =BitmapTextureAtlasTextureRegionFactory.
                              CreateFromAsset(this.mapao, this,
                                "gfx/caixa.png", 129, 33); //32x32
getTextureManager().loadTexture(mapao);

Carregando Fonte, Som e Musica

É importante manter todos os recursos em memória para execução imediata quando necessário.

fonte = FontFactory.createFromAsset(
     fonteTextura, getApplicationContext(), "font/Plok.ttf",
                                          tamFonte, true, Color.WHITE);
                                                           // antialiasing
mEngine.getFontManager().loadFont(fonte);
som = SoundFactory.createSoundFromAsset(
            getSoundManager(), this, "mfx/explosion.ogg");
musica= MusicFactory.createMusicFromAsset(
              getMusicManager(), this, "mfx/oxygene.mid");

TiledMap – Conceito

Mapa de Imagens

Representa uma imagens construída a partir de diversas partes menores (assim como um é telhado feito de telhas, alias, daí o nome TiledMap).

Pode ser utilizado no Andengine um formato padrão: o TMX, que é um mapa de imagem definido em XML, que usa compressão gzip internamente e cria um mapa a partir de um conjunto de pequenas imagens.

Existem programas que te ajudam a criá-lo, como o MapEditor.

TileMap – exemplo de código

try {
    TMXLoader tmx = new TMXLoader(
              getApplicationContext(), getTextureManager());
    mapa = tmx.loadFromAsset(
              getApplicationContext(),"tmx/desert.tmx");
} catch (final TMXLoadException e) {
    Debug.e(e);
}
    :
    :
TMXLayer camada = mapa.getTMXLayers().get(0);
cena.attachChild(camada);

Modificadores

Permitem variação automática de características dos objetos/shapes

  • Mudanças de tamanho, rotação, transparência etc.
  • Podem ser agrupadas, sequenciais ou paralelas
modificador = new LoopEntityModifier(
                         new ParallelEntityModifier(
                                new RotationModifier(6, 0, 360),
                                new SequenceEntityModifier(
                                       new ScaleModifier(3, 1, 1.5f),
                                       new ScaleModifier(3, 1.5f, 1))));

shape.registerEntityModifier(modificador);

Shape / Sprite / AnimatedSprite

Representam um Objeto do jogo

  • Shape – um primitivo – Line, Rectangle, Circle etc.
  • Sprite – representa uma imagem de uma matriz
  • AnimatedSprite – representa uma animação

 

retangulo = new Rectangle(x, y, larg, alt);

sCaixa = new Sprite (x,y,caixaTextura);
sCaixa.setCurrentTileIndex(2);

sExplosao = new AnimatedSprite(x,y, explosaoTextura);
sExplosao.animate(100,false);  //sem repetição

HUD (Head-Up Display) – fixar algo na câmera

Usado para placares, indicadores e controles fixos
Deve ser anexado a câmera, não a cena

private HUD hud = new HUD();
    :
    :
    texto = new ChangeableText(0, 0, fonte, "Pontos: 0");
    hud.attachChild(texto);
    camera.setHUD(hud);
        :
        texto.setText("Pontos: "+ (++pontos));

Eventos e Colisões

São declarados nos objetos e executados quando ocorrer o evento específico.

cena.registerUpdateHandler(new IUpdateHandler() {
    @Override  public void reset() { }
    @Override  public void onUpdate(float seg) {
        if(retangulo.collidesWith(sMario)) {
            som.play();
        }
    }
});

cena.registerUpdateHandler(new TimerHandler(.....{
        :
}

Softwares

Programas que utilizo para trabalhar os arquivo que uso nos jogos

e sites interessantes

Exemplo de programa feito com a Andengine, com TileMap, Sprites animados, colisões, joystick na tela, placar, som e musica:  AulaAndEngine7

Leave a Reply

Your email address will not be published. Required fields are marked *