
	Conheça a iniciativa da Biblioteca dos Desenvolvedores


	Índice da Biblioteca


	Área dos Usuários


	Fórum de Discussão

Rotinas do Teclado

O Allegro provê controles tanto para entrada de dados através do teclado quando para o status do teclado. Note que não é possível fazer todas as combinações de teclas possíveis devido o projeto do teclado.

Até duas ou três teclas pressionadas ao mesmo tempo trabalharão bem, mais que isso é provável que as próximas teclas serão ignoradas.
No DOS o allegro requer que o usuário especifique o idioma do teclado porque é impossível obter essa informação do sistema operacional.

Se não for especificado o allegro irá adotar o idioma padrão US.

Primeiramente, assim como todo o dispositivo que o allegro disponibiliza é necessário fazer a instalação. A função responsável pela a instalação do dispositivo teclado é o int install_keyboard().

install_keyboard()

Instala as interrupções allegro para o teclado.

Você deve chamar essa função antes que utilizar ou controlar qualquer entrar pelo teclado. Uma vez instalado você já pode usar as funções de controle do teclado.

Atenção: Em algumas plataformas o teclado não irá responder a menos que vc ajuste a modalidade de gráfico, mesmo se esta função retornar um valor se sucesso antes de chamar o set_gfx_mode. Isso pode ocorrer em ambientes gráficos WINDOWED.

Exemplo:

#include <allegro.h>

int main()
{
   allegro_init();
   set_color_depth(32);
   install_keyboard();

   // Nessa parte ainda está 100% garantida a leitura do teclado.
   if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0)
      allegro_message("Problema com a configuração de video.");
   // Agora a leitura do teclado esta 100% garantida.

   readkey();

   allegro_exit();
   return 0;
}
END_OF_MAIN();

void remove_keyboard();

Resumidamente o manual do Allegro diz que só devemos usar essa função no caso de utilizarmos uma biblioteca de interrupções do teclado feito por terceiros ou pelo próprio fabricante do teclado.

No caso de utilizarmos o teclado padrão do allegro essa função já está inclusa no allegro_exit(). Portanto, a declaração dessa rotina para quem usa o teclado padrão do allegro torna-se desnecessário.

void set_config_string(const char *section, const char *name, const char *val);

A função acima tem várias funcionalidades para configurações do sistema. Uma delas é a alteração do idioma do teclado.

Exemplos:

//(Teclado Espanhol)
set_config_string("system", "keyboard", "es");

//(Teclado Internacional)

set_config_string("system", "keyboard", "us");

extern volatile char key[KEY_MAX];

Array que armazena e identifica as teclas apenas para leitura. Mais adiante segue uma tabela para identificação das teclas disponíveis nesse array.

Exemplos:

if (key[KEY_SPACE])
      allegro_message("Tecla ESPACE Pressionada.");
if (key[KEY_F1])
      allegro_message("Tecla F1 Pressionada.");
if (key[KEY_A])

allegro_message("Tecla A Pressionada.");

Teclas disponíveis no Allegro

KEY_A ... KEY_Z,
KEY_0 ... KEY_9,
KEY_0_PAD ... KEY_9_PAD,
KEY_F1 ... KEY_F12,

KEY_ESC, KEY_TILDE, KEY_MINUS, KEY_EQUALS,
KEY_BACKSPACE, KEY_TAB, KEY_OPENBRACE, KEY_CLOSEBRACE,
KEY_ENTER, KEY_COLON, KEY_QUOTE, KEY_BACKSLASH,
KEY_BACKSLASH2, KEY_COMMA, KEY_STOP, KEY_SLASH,
KEY_SPACE,

KEY_INSERT, KEY_DEL, KEY_HOME, KEY_END, KEY_PGUP,
KEY_PGDN, KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN,

KEY_SLASH_PAD, KEY_ASTERISK, KEY_MINUS_PAD,
KEY_PLUS_PAD, KEY_DEL_PAD, KEY_ENTER_PAD,

KEY_PRTSCR, KEY_PAUSE,

KEY_ABNT_C1, KEY_YEN, KEY_KANA, KEY_CONVERT, KEY_NOCONVERT,
KEY_AT, KEY_CIRCUMFLEX, KEY_COLON2, KEY_KANJI,

KEY_LSHIFT, KEY_RSHIFT,
KEY_LCONTROL, KEY_RCONTROL,
KEY_ALT, KEY_ALTGR,
KEY_LWIN, KEY_RWIN, KEY_MENU,
KEY_SCRLOCK, KEY_NUMLOCK, KEY_CAPSLOCK

KEY_EQUALS_PAD, KEY_BACKQUOTE, KEY_SEMICOLON, KEY_COMMAND

int readkey();

Essa função retorna o valor do caractere seguido de um buffer de teclado no format ASCII.

Se o buffer estiver vazio espera até que alguma tecla seja pressionada.
Você pode verificar se alguma tecla foi pressionada com a função keypressed().

Exemplos:

Declare a rotina abaixo e siga os exemplos.

int val=0;

val = readkey();

Identifica a tecla pressionada:

if ((val & 0xff) == 'A')
allegro_message("Voce pressionou a tecla 'A'.\n");

if ((val & 0xff) == 'B')
allegro_message("Voce pressionou a tecla 'B'.\n");
...

Verifica se você pressionou algum scanmode.

if ((val >> 8) == KEY_SPACE)
allegro_message("Você pressionou a tecla ESPACO.\n");

if ((val >> 8) == KEY_ENTER)
allegro_message("Você pressionou a tecla ENTER.\n");
...

Verifica se a sequencia Ctrl+C foi pressionada.

if ((val & 0xff) == 3)
allegro_message("Você pressionou a sequencia Control+C.\n");

Verifica se você pressionou ALT+Tecla.

if (val == (KEY_A << 8))
allegro_message("Voce pressionou ALT+A.\n");
if (val == (KEY_B << 8))
allegro_message("Voce pressionou ALT+B.\n");
...

int keypressed();

Retorna verdadeiro se alguma tecla for pressionada.

Exemplo:

if (keypressed())

allegro_message("Tecla Pessionada.");

extern volatile int key_shifts;

Bitmask que contem o estado atual do shift/ctrl/alt, das chaves especiais de Windows e dos caracteres do escape e com acentos. Podemos usar essa função para identificar se a tecla pressionada é maiúscula ou minúscula apenas combinando o shift com alguma outra tecla.

Exemplo:

if (key[KEY_W]) // Tecla Pressionada
{
      // Verifica se o shift foi pressionado ao mesmo tempo
      if (key_shifts & KB_SHIFT_FLAG)
            allegro_message("W - Maiusculo");
      else
            allegro_message("w - Minusculo");

}

Tabela de FLAGs

Abaixo segue uma tabela para identificação dos flags que poderão ser utilizados com a Bitmask key_shifts.
Conforme mostrados acima no exemplo com o flag KB_SHIFT_FLAG.

KB_SHIFT_FLAG
KB_CTRL_FLAG
KB_ALT_FLAG
KB_LWIN_FLAG
KB_RWIN_FLAG
KB_MENU_FLAG
KB_COMMAND_FLAG
KB_SCROLOCK_FLAG

KB_NUMLOCK_FLAG
KB_CAPSLOCK_FLAG
KB_INALTSEQ_FLAG
KB_ACCENT1_FLAG
KB_ACCENT2_FLAG
KB_ACCENT3_FLAG

KB_ACCENT4_FLAG

void simulate_keypress(int key);

A função acima simula um tecla sendo pressionada. No exemplo abaixo vamo simular a seqüência ALT+ESPAÇO, em seguida vamos verificar se foi mesmo pressionada com a função readkey().

Exemplo:

Como simular uma seqüência de teclas?

simulate_keypress(KEY_SPACE << 8);

if (readkey() == (KEY_SPACE << 8))
allegro_message("Voce simulou Alt+Space\n");

Como simular apenas uma tecla?

simulate_keypress(KEY_A);

if (readkey() == (KEY_A))

allegro_message("Voce simulou a tecla A\n");

void clear_keybuf();

Esvazia o buffer do teclado. Quando você quiser se certificar que não exista nada armazenado na variável readkey() antes de uma tecla ser pressionada use essa função.

Exemplo:

int val=0;

clear_keybuf();

val = readkey();

O programa abaixo mostra os valores das variáveis x e y.
O valor muda conforme os comandos abaixo.

Seta para cima: Diminui -1 na variável y;
Seta para baixo: Aumenta +1 na variável y;
Seta para esquerda: Diminui -1 na variável x;
Seta para direita: Aumenta +1 na variável x;

CÓDIGO...

#include <allegro.h>

int main()
{
   allegro_init();
   set_color_depth(32);
   install_keyboard();
   set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

   int x=0;
   int y=0;

   BITMAP *Buffer=NULL;
   Buffer = create_bitmap(SCREEN_W,SCREEN_H);

   while (!key[KEY_ESC])
   {
      clear_bitmap(Buffer);

      if (key[KEY_UP]) y--;
      if (key[KEY_DOWN]) y++;
      if (key[KEY_RIGHT]) x++;
      if (key[KEY_LEFT]) x--;

      textprintf_ex(Buffer, font, 10, 10, makecol(255, 100, 200),-1, "x = %d", x);
      textprintf_ex(Buffer, font, 10, 20, makecol(255, 100, 200),-1, "y = %d", y);
      blit(Buffer,screen,0,0,0,0,SCREEN_W,SCREEN_H);
   }

   destroy_bitmap(Buffer);
   delete Buffer;
   allegro_exit();
   return 0;
}
END_OF_MAIN();

FIM DE CÓDIGO

Note que ao teclar qualquer tecla os valores dos contadores x e y crescem ou diminuem em velocidade de processamento, muito rápido. Para contornar esse problema eu criei uma variável chamada buffer_teclado que vai me ajudar a controlar melhor os contadores. Existem outras formas de solucionar esse problema, essa é apenas uma das soluções.

CÓDIGO...

#include <allegro.h>

int main()
{
   allegro_init();
   set_color_depth(32);
   install_keyboard();
   set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

   int x=0;
   int y=0;

   const int iCiclo = 50;
   int buffer_teclado=0;

   BITMAP *Buffer=NULL;
   Buffer = create_bitmap(SCREEN_W,SCREEN_H);

   while (!key[KEY_ESC])
   {
      clear_bitmap(Buffer);

      if(buffer_teclado == 0)
      {
         if (key[KEY_UP]) y--;
         if (key[KEY_DOWN]) y++;
         if (key[KEY_RIGHT]) x++;
         if (key[KEY_LEFT]) x--;
         buffer_teclado = iCiclo;
      } else buffer_teclado--;

   textprintf_ex(Buffer, font, 10, 10, makecol(255, 100, 200),-1, "x = %d", x);
   textprintf_ex(Buffer, font, 10, 20, makecol(255, 100, 200),-1, "y = %d", y);
   blit(Buffer,screen,0,0,0,0,SCREEN_W,SCREEN_H);
}

destroy_bitmap(Buffer);
delete Buffer;
allegro_exit();
return 0;
}
END_OF_MAIN();

FIM DE CÓDIGO

No exemplo acima controlamos a entrada pelo teclado pela variável buffer_teclado e Ciclo.
Dessa forma o allegro só vai conseguir ler as informações do telcado a cada 50 ciclos de CPU.

Caso você queira aumentar a velocidade dos valores diminua o valor do ciclo.

Caro leitor chegamos ao fim do entendimento das rotinas do teclado.
Se houver alguma dúvida ou dificuldade favor entrar em contato com os membros pelo Forum.

Abraço
BDJogos

Contribuidor
Bruno A. Rovela
15/08/2007

Voltar

01/06/2007 (C) Copyright. Todos os Direitos Reservados. Leia a política de privacidade do portal. É proibida a cópia de conteúdo deste site de acordo com a Lei Brasileira de Direitos Autorais.