Tutorial SDL – parte 3 – Eventos, uma pequena introdução

O que são eventos? Evento é tudo o que acontece (tá e daí?), ou seja, qualquer tecla que seja apertada, qualquer movimento do mouse, quando minimiza a janela, muda de tamanho ou arrasta, quando fecha a janela.

Nesse tutorial mostrarei apenas uma introdução aos eventos, pois precisaremos de mais conhecimentos em relação às carregamento de imagens para brincarmos com eventos e imagens, como, por exemplo, movimentar um personagem.

PLAIN TEXT
C++:
  1. //O Cabeçalho
  2. #include "SDL/SDL.h"
  3. #include "SDL/SDL_image.h"
  4. #include
  5. //Atributos da Tela
  6. const int SCREEN_WIDTH = 640;
  7. const int SCREEN_HEIGHT = 480;
  8. const int SCREEN_BPP = 32;
  9. //As superfícies
  10. SDL_Surface *imagem = NULL;
  11. SDL_Surface *tela = NULL;

Esse cabeçalho acima não é novidade nenhuma né? Agora vem o novo...

PLAIN TEXT
C++:
  1. //A estrutura que usaremos para capturarmos os eventos
  2. SDL_Event evento;
  3.  
  4. SDL_Surface *carregaImagem( std::string imagem )
  5. {
  6. //Superfície que armazena temporariamente a imagem
  7. SDL_Surface* imagemCarregada = NULL;
  8. //Superfície que retorna a imagem otimizada
  9. SDL_Surface* imagemOtimizada = NULL;
  10. //Carrega a imagem
  11. imagemCarregada = IMG_Load( imagem.c_str() );
  12. //Verifica se tudo deu certinho
  13. if( imagemCarregada != NULL )
  14. {
  15. //Cria a imagem otimizada
  16. imagemOtimizada = SDL_DisplayFormat( imagemCarregada);
  17. //Libera a imagem carregada
  18. SDL_FreeSurface( imagemCarregada );
  19. }
  20. //Retorna a imagem otimizada
  21. return imagemOtimizada;
  22. }
  23.  
  24. void aplicaSuperficie( int x, int y, SDL_Surface* fonte, SDL_Surface* destino )
  25. {
  26. //Cria um retangulo para a superficie
  27. SDL_Rect retangulo;
  28. //Dá as coordenadas para o retangulo
  29. retangulo.x = x;
  30. retangulo.y = y;
  31. //encaixa a "fonte" dentro do "destino" através do retangulo
  32. SDL_BlitSurface( fonte, NULL, destino, &retangulo );
  33. }

As funções de carregar e aplicar as imagens como já foi mostrada nos tutoriais anteriores

PLAIN TEXT
C++:
  1. bool inicia()
  2. {
  3. //Inicia os subsistemas da SDL
  4. if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
  5. {
  6. return false;
  7. }
  8. //Setando a tela
  9. tela = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
  10. //Verifica se existe algum erro na tela
  11. if( tela == NULL )
  12. {
  13. return false;
  14. }
  15. //Setando o caption da janela
  16. SDL_WM_SetCaption( "Tutorial SDL - Eventos", NULL );
  17. //Se tudo deu certo
  18. return true;
  19. }

Função para iniciar a aplicação, seta a SDL, o caption e retorna true se der tudo certo.

PLAIN TEXT
C++:
  1. bool carrega_arquivos()
  2. {
  3. //Carrega a imagem
  4. imagem = carregaImagem( "x.jpg" );
  5. //Verifica se existe algum erro no carregamento da imagem
  6. if( imagem == NULL )
  7. {
  8. return false;
  9. }
  10. //se tudo der certo
  11. return true;
  12. }

Essa função carrega os arquivos (imagens) que queremos no nosso jogo.

PLAIN TEXT
C++:
  1. void limpa()
  2. {
  3. //Libera a imagem
  4. SDL_FreeSurface( imagem );
  5. //Fecha a SDL
  6. SDL_Quit();
  7. }

Funcção usada para liberar a imagem e fechar a SDL. Agora vamos à função main:

PLAIN TEXT
C++:
  1. int main( int argc, char* args[] )
  2. {
  3. //Variável necessária para saber se o usuário fechou a janela
  4. bool quit = false;

Essa variável é usada para verificar se o usuário fechou a janela.

PLAIN TEXT
C++:
  1. //Inicia
  2. if( inicia() == false )
  3. {
  4. return 1;
  5. }
  6. //Carrega os arquivos
  7. if( carrega_arquivos() == false )
  8. {
  9. return 1;
  10. }

Chamando a inicialização e a função de carregamento de imagens.

PLAIN TEXT
C++:
  1. //Aplicando as superfícies na tela
  2. aplicaSuperficie( 0, 0, imagem, tela );
  3. //Atualiza a tela
  4. if( SDL_Flip( tela ) == -1 )
  5. {
  6. return 1;
  7. }

Mostra a imgem na tela.

PLAIN TEXT
C++:
  1. //Enquanto o usuário não fechar o programa
  2. while( quit == false )
  3. {

Começando o loop principal da aplicação.

PLAIN TEXT
C++:
  1. //Quando ocorrer um evento
  2. while( SDL_PollEvent( &evento ) )
  3. {

Aqui usamos a função SDL_PollEvent. Ela espera por qualquer tipo de evento (clique e movimentação de mouse, quando alguma tecla do teclado é pressionada, etc), vou implementar quando o X da janela é apertado e assim, fecharemos o programa.

PLAIN TEXT
C++:
  1. //se o usuário apertou o X da janela
  2. if( evento.type == SDL_QUIT )
  3. {
  4. //Fecha o programa
  5. quit = true;
  6. }
  7. }
  8. }

Comparamos o tipo do evento (evento.type) e implementamos uma ação para quando esse evento ocorrer. Outros tipos de eventos disponíveis são: SDL_KEYDOWN, SDL_MOUSEMOTION, SDL_MOUSEBUTTONDOWN. Veja um exemplo aqui Com outros tipos de eventos (explicarei aqui em breve).

PLAIN TEXT
C++:
  1. //Libera a superficie e fecha a SDL
  2. limpa();
  3. return 0;
  4. }

Finalmente Fechamos o programa

Para mostrar esse tutorial, criei um arquivo jpg para carregar uma imagem na tela.

Para baixar o fonte clique aqui.

Algum tio de Dúvida? romulo@cubagames.com.br ou comentário no site!