Conheça a iniciativa da Biblioteca dos Desenvolvedores
Índice da Biblioteca
Área dos Usuários
Fórum de Discussão
FUNÇÕES DE TEXTO NO ALLEGRO
Nesse artigo iremos aprender a usar as funções de texto que o allegro disponibiliza para ilustrar os
Jogos.
Como sabemos, todos os jogos possuem textos, sejam eles em formato de histórias ou conversas.
Segue abaixo algumas telas para ilustração de alguns textos.
Donkey Kong
Mario World
Mario 64
Megaman 7
Zelda
Tetris
Castlevania 1
Castlevania Dawn od Sorrow
Como podemos observar acima todos os jogos possuem um texto na tela. Independente de ser jogo antigo
ou novo, 2d ou 3d cada caso é um caso.
Jogos de RPG, por exemplo, usam bastante texto para contar a
história durante o jogo. Principalmente na conversa com os NPS (Personagens controlados pelo computador
através de inteligência artificial ou não). Outros jogos mostram apenas pontuação, vida ou informações
especiais referente ao personagem.
Antes de manipular as funções você deve prestar atenção para os seguintes itens:
- Em todas as funções no argumento que pede o tipo de fonte sempre vamos utilizar a fonte padrão do
allegro. Portanto, iremos sempre responder que o tipo de fonte utiliza é font.
- Em toda função texto precisamos especificar onde iremos escrever. Nesse caso iremos direcionar o
nosso texto para variável global screen, ou seja, direto para a tela do usuário.
- A configuração da tela que iremos usar é de 640x480. Portanto as variáveis globais do allegro SCREEN_W guarda a largura máxima da tela 640 e SCREEN_H guarda a altura máxima da tela 480.
Feito e entendido essas considerações o resultado de todos esses exemplos serão o mesmo para todos.
Em outros artigos iremos aprender a utilizar uma fonte personalizada e a desvantagem de utilizar
diretamente a variável screen.
Abaixo segue algumas funções mais importantes que são utilizadas para trabalhar com textos no allegro:
IMPORTANTE: Sempre que você escrever um texto na tela a coordenada x,y inicial, ou seja, x=0 e y=0 de
cada texto está localizado no canto superior esquerdo do texto conforme a figura abaixo:
Nesse caso o texto seria escrito da esquerda para a direita a partir da posição informada.
Ao estudar as funções de alinhamento você vai perceber que a posição inicial de cada texto pode ser
alterada.
Dessa forma a posição inicial varia de acordo com o objetivo da função.
FUNÇÕES REFERENTE AO TAMANHO DO TEXTO
int text_length(const FONT *f, const char *str);
Essa função retorna um valor inteiro com a largura do texto em pixel.
Ela recebe como argumentos:
-Tipo da fonte: font
-Texto: "Allegro 4.2.1"
A largura em pixels aumenta ou diminui conforme o tamanho do texto informado.
Exemplo:
int iLargura=0;
iLargura = text_length(font, "Allegro 4.2.1");
No exemplo acima a variável iLargura recebe a largura do texto “Allegro 4.2.1” em pixels.
int text_height(const FONT *f)
Essa função retorna um valor inteiro com o comprimento do texto em pixel.
Em outras palavras retorna a altura da fonte. Ela recebe como argumentos:
- Tipo da fonte: font
Como vimos no inicio desse artigo sempre iremos usar o tipo de fonte padrão
do allegro. Com base no retorno dessa função você pode monitorar os espaçamento
entre os textos na vertical da maneira que quiser.
Exemplo:
int iAltura_Fonte = 0;
iAltura_Fonte = text_height(font);
No exemplo acima a variável iAltura_Fonte recebe a altura máxima da fonte que
utilizamos para escrever um determinado texto. Se você estiver usando a fonte
padrão do allegro o retorno deverá ser 8 pixels.
FUNÇÕES REFERENTES AO ALINHAMENTO DO TEXTO
void textout_ex(BITMAP *bmp, const FONT *f, const char *s, int x, int y, int color, int bg);
Essa função é bem simples e a mais usada por ser responsável em escrever o texto na tela da esquerda
para a direita. Dessa forma ela não precisa alterar a coordenada inicial do texto, permanece no
canto superior esquerdo. Essa função recebe como argumentos:
- Destino do texto: screen
- Tipo da fonte: font
- Texto: “Allegro 4.2.1”
- Posição x e posição y: 10,10
- Cor do texto: makecol(0, 0, 255) - (Azul)
- Cor de fundo do texto: -1 - (Transparente)
O exempo acima mostra o texto "Allegro 4.2.1" em azul com fundo transparente.”
void textout_right_ex(BITMAP *bmp, const FONT *f, const char *s, int x, int y, int color, int bg);
Essa função é responsável por alinhar o texto a direita. Essa função recebe como argumentos:
- Destino do texto: screen
- Tipo da fonte: font
- Texto: “Texto alinhado a direita”
- Posição x: SCREEN_W = 640
- Posição y: 0
- Cor do texto: makecol(255,255,0) – Amarelo
- Cor do fundo do texto: -1 - Transparente
Exemplo:
textout_right_ex(screen, font, "Texto alinhado a direita",SCREEN_W, 0, makecol(255,255,0), -1);
O exemplo acima deve mostrar o texto alinhado no canto superior direito da tela. É importante lembrar
que a variável SCREEN_W guarda o tamanho total da largura da tela. Nesse caso ela guarda o valor 640.
Note que essa função altera a coordenada inicial do texto para o canto superior direito do texto conforme
a figura abaixo:
Dessa forma x = 640 e o texto vai ser alinhado até o final da tela independente do seu tamanho. Se você
usar a função textout_ex irá perceber que não vai ser impresso nenhum texto na tela porque o texto
será impresso a partir da posição 640 que está fora dos limites da tela. Se você fizer SCREEN_W –10
irá ver o começo do texto.
void textout_centre_ex(BITMAP *bmp, const FONT *f, const char *s, int x, y, int color, int bg);
Essa função é responsável por centralizar o texto a partir da posição x,y que você informar
alterando a coordenada inicial da função para o centro do texto. Essa função recebe
como argumentos:
- Destino do texto: screen
- Tipo de fonte: font
- Texto: “Game Over”
- Posição x e y da fonte na tela: x = Metade da largura máxima da tela (320) e y = Metade da altura máxima da tela (240).
- Cor do texto: makecol(255, 0, 0) - Vermelho
- Cor do fundo do texto: makecol(0, 255, 0) - Verde
O exemplo deve mostrar o texto “Game Over” no centro da tela com a cor do fundo verde e texto em vermelho.
Essa função se encarrega de centralizar o texto independente do tamanho a partir da posição x,y informada.
Note que essa função é do tipo que altera a coordenada inicial x,y do texto. Nesse caso a coordenada inicial
de cada texto é no centro conforme a figura abaixo:
void textout_justify_ex(BITMAP *bmp, const FONT *f, const char *s, int x1, int x2, int y, int diff, int color, int bg);
Essa função é responsável por justificar o texto. O resultado é o mesmo quando justificamos os texto
no Microsoft Office Word. Essa função recebe como argumentos:
- Destino do texto: screen
- O tipo de fonte: font
- Texto: sLinhas[i] – 4 linhas com um array iniciando de 0 a 3.
sLinhas[0] - "Desenha o texto justificado"
sLinhas[1] - "conforme foi especificado"
sLinhas[2] - "no tamanho informado de"
sLinhas[3] - "cada campo, como no word"
- Posição x inicial de onde você quer justificar o texto: 0
- Posição y final de onde você quer justificar o texto: 200 pixels
- Espaço entre as linhas: 8 pixels – usamos a função text_height para tornar a rotina genérica para outros tipos de textos.
- Diferença entre os espaços das palavras: 80 pixels. Esses 80 pixels é dividido entre as palavras que compõem a linha. Dessa
forma o texto fica a linhado de ponta a ponta.
- Cor do texto: makecol(255, 255, 0)
- Cor do fundo do texto: -1 - Transparente
Exemplo:
CÓDIGO...int y=0;
int i=0;
char *cLinhas[] = {"Desenha o texto justificado",
"conforme foi especificado",
"no tamanho informado de",
"cada campo, como no word", NULL};
for (i = 0;i<4;i++) // de 0 a 3 faça
{ textout_justify_ex(screen, font, cLinhas[i], 0, 200,i*text_height(font), 80, makecol(255, 255, 0),-1);
}
readkey(); FIM DE CÓDIGO
No exemplo acima criamos um array de caracteres para podermos montar algumas frases.
Nesse array temos
4 linha de textos. Para o compilador cada linha representa uma posição no array.
Dessa forma temos a
posição 0,1,2 e 3.
A função vline é responsável por traçar uma linha vertical na tela.
Nesse exemplo
foi usada apenas para melhorar a visualização do texto justificado.
Veremos essa função em detalhes
em outro tópico.
Para podermos justificar todas as linhas devemos fazer um contador de 0 a 3.
A função text_height pega a altura de cada linha em pixels e multiplica pela posição da linha.
Dessa
forma cada linha terá a distância de 8 pixels que é a altura da fonte padrão do allegro.
(i*text_height(font))
FUNÇÕES REFERENTES AO ALINHAMENTO DO TEXTO COM IMPRESSÃO DE VARIÁVEIS
VOCÊ PRECISA
SABER...
Se você for utilizar textos muito longos o manual do Allegro não aconselha a utilizar as funções
abaixo.
Caso seja necessário utilizar você deverá intercalar essas funções com uma função auxiliar
chamada uszprintf que é responsável por reservar o espaço necessário para alocar o texto inteiro.
Como o objetivo do artigo é ser o mais fácil, rápido e prático não iremos abordar exemplos com
textos longos.
Você vai perceber que no final da sintaxe de cada função existe “...” (Três pontinhos). Esses pontos indicam
que você pode informar mais algum argumento. Esses argumentos não são obrigatórios, ou seja, você usa se quiser.
Nos exemplos abaixo vamos exemplificar um resultado da pontuação de um jogador.
Dessa forma, sempre que você
compilar o programa você vai ver quanto o jogador fez de pontuação.
Como as funções abaixo se tratam de funções de alinhamento a regra para mudanças de coordenadas independentes
da função é a mesma que as anteriores.
void textprintf_ex(BITMAP *bmp, const FONT *f, int x, int y, int color, int bg, const char *fmt, ...);
Essa função é responsável por escrever o texto na tela da esquerda para a direita. Dessa forma ela
não precisa alterar a coordenada inicial do texto, permanece no canto superior esquerdo.
Essa função recebe como argumentos:
- Destino do texto: screen
- Tipo da fonte: font
- Posição x e posição y: 0,0
- Cor do texto: makecol(0, 0, 255) - (Azul)
- Cor de fundo do texto: -1 - (Transparente)
- Texto: “Pontuacao.: %d”
- Continuação dos argumentos: iPontos
O exempo acima mostra o texto "Pontuacao.: %d" em azul com fundo transparente.”
void textprintf_right_ex(BITMAP *bmp, const FONT *f, int x, y, color, bg, const char *fmt, ...);
Essa função é responsável por alinhar o texto a direita. Essa função recebe como argumentos:
- Destino do texto: screen
- Tipo da fonte: font
- Posição x: SCREEN_W = 640
- Posição y: 0
- Cor do texto: makecol(255,255,0) – Amarelo
- Cor do fundo do texto: -1 - Transparente
- Texto: “Pontuacao.: %d”
- Continuação dos argumentos: iPontos
O exemplo acima deve mostrar o texto “Pontuacao.: 1100” alinhado no canto superior direito da tela.
void textprintf_centre_ex(BITMAP *bmp, const FONT *f, int x, int y, int color, int bg, const char *fmt, ...);
Essa função é responsável por centralizar o texto a partir da posição x,y que você informar
alterando a coordenada inicial da função para o centro do texto. Essa função recebe
como argumentos:
- Destino do texto: screen
- Tipo de fonte: font
- Posição x e y da fonte na tela: x = Metade da largura máxima da tela (320) e y = Metade da altura máxima da tela (240).
- Cor do texto: makecol(255, 0, 0) - Vermelho
- Cor do fundo do texto: makecol(0, 255, 0) - Verde
- Texto: “Pontuacao.: %d”
- Continuação dos argumentos: iPontos
O exemplo acima deve mostrar o texto “Pontuacao.: 1100” no centro da tela com a cor do fundo verde e o
texto em vermelho. A própria função se encarrega de centralizar o texto independente do tamanho a partir
da posição x,y informada.
void textprintf_justify_ex(BITMAP *bmp, const FONT *f, int x1, x2, y, diff, color, bg, const char *fmt, ...);
Essa função é responsável por justificar o texto. O resultado é o mesmo quando justificamos os texto
no Microsoft Office Word. Essa função recebe como argumentos:
- Destino do texto: screen
- O tipo de fonte: font
- Posição x inicial de onde você quer justificar o texto: 0
- Posição y final de onde você quer justificar o texto: 200 pixels
- Espaço entre as linhas: 8 pixels – usamos a função text_height para tornar a rotina genérica para outros tipos de textos.
- Diferença entre os espaços das palavras: 80 pixels. Esses 80 pixels é dividido entre as palavras que compõem a linha. Dessa
forma o texto fica a linhado de ponta a ponta.
- Cor do texto: makecol(255, 255, 0)
- Cor do fundo do texto: -1 - Transparente
- Texto: sLinhas[i] – 4 linhas com um array iniciando de 0 a 3.
sLinhas[0] - "Desenha o texto justificado"
sLinhas[1] - "conforme foi especificado"
sLinhas[2] - "o total de pontos que o"
sLinhas[3] - "jogador fez foi %d pontos"
- Continuação dos argumentos: iPontos
Exemplo:
CÓDIGO...int y=0;
int i=0;
int iPontos=10;
char *cLinhas[] = {"Desenha o texto justificado",
"conforme foi especificado",
"o total de pontos que o",
"jogador fez foi %d pontos", NULL};
for (i = 0;i<4;i++) // de 0 a 3 faça
{ textprintf_justify_ex(screen, font, 0, 200,i*text_height(font), 80, makecol(255, 255, 0),-1,cLinhas[i],iPontos);
}
readkey(); FIM DE CÓDIGO
No exemplo acima criamos um array de caracteres para podermos montar algumas frases.
Nesse array temos
4 linha de textos. Para o compilador cada linha representa uma posição no array.
Dessa forma temos a
posição 0,1,2 e 3.
A função vline é responsável por traçar uma linha vertical na tela.
Nesse exemplo
foi usada apenas para melhorar a visualização do texto justificado.
Veremos essa função em detalhes
em outro tópico.
Para podermos justificar todas as linhas devemos fazer um contador de 0 a 3.
A função text_height pega a altura de cada linha em pixels e multiplica pela posição da linha.
Dessa
forma cada linha terá a distância de 8 pixels que é a altura da fonte padrão do allegro.
(i*text_height(font))
void set_uformat(int type);
Essa função define a codificação atual do texto que você quer utilizar. Isso vai afetar todas as partes do Allegro no seu jogo. Recebe como argumento apenas o tipo de codificação. Os tipos suportados estão abaixo:
U_ASCII - Caracteres da tabela ASCII. Permite utilizar caracteres com acentos. U_ASCII_CP – Página de código alternativo de 8 bits. U_UNICODE – Caracteres no formato Unicode U_UTF8 - Caracteres no formato UTF-8. Não permite acentuação.
Por padrão, se você não definir a codificação o allegro vai utilizar o U_UTF8. Caso você queira usar textos com acentuação siga o exemplo abaixo.
Exemplo:
set_uformat( U_ASCII );
Obs: Impreterivelmente você deve utilizar essa função antes da função que inicia o allegro. Conforme abaixo.
set_uformat( U_ASCII );
allegro_init();
int get_uformat(void);
Essa função é responsável por retornar o tipo de codificação de texto que você está utilizando no momento. Ela só é útil se você estiver escrevendo um jogo para lidar com vários tipos de codificação de texto, um addon, por exemplo.
Exemplo:
switch( get_uformat() )
{
case U_ASCII:
allegro_message("Você está usando a codificação U_ASCII");
break;
case U_UTF8:
allegro_message("Você está usando a codificação U_UTF8");
break;
}
Caro leitor chegamos ao fim do entendimento do funcionamento das funções de texto do allegro.
Não
necessariamente um jogo deve utilizar essas funções.
Com prática você poderá desenvolver sua própria
tabela de fontes através de imagens interativas e personalizadas.
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.
VOCÊ PRECISA
SABER...