Le matériel VGA utilise seulement 6 bits pour chaque composante de couleur, ce qui signifie que les valeurs de rouge, vert et bleu dans la palette vont de 0 à 63 et pas jusqu'à 255. Cela vous donne un accès théorique à 2^18 = 262 144 couleurs différentes ou 64 niveaux de gris. Si vous en voulez plus, vous pouvez essayer d'utiliser la fonction VESA 0x4F08 pour sélectionner un DAC de 8 bits, mais Allegro ne le supporte pas directement et je ne sais pas à quel point c'est fiable sur différents matériels.

Quand vous êtes dans un mode 256 couleurs, la carte VGA affiche la couleur #0 autour de la bordure de la zone d'affichage (dans les modes truecolor ça affiche du noir). Votre couleur bizarre disparaîtra si vous modifiez la palette pour que la couleur #0 soit le noir.

Avec beaucoup de difficultés.

Il n'y a pas d'astuce aussi simple que de juste modifier la palette, donc vous devrez redessiner l'image plusieurs fois sous une forme plus claire ou plus foncée. Vous pourriez dessiner des rectangles noirs translucides par-dessus l'écran pour l'assombrir ou utiliser draw_lit_sprite() pour teinter un bitmap pendant que vous le copiez vers l'écran, mais sachez que ces opérations sont lourdes et nécessitent un PC rapide !

Vous pouvez aussi regarder sur http://www.allegro.cc/ pour des paquets additionnels (notamment FBlend v0.5) permettant d'effectuer cette opération aussi vite que possible.

fade_in() et fade_out() ne fonctionnent que dans les modes 8 bits avec palette.

La couleur de transparence utilisée est le magenta.

Dans votre programme de dessin favori, modifiez la couleur en mode RVB en faisant en sorte que les valeurs pour le rouge et le bleu soient au maximum (généralement 255, mais ça dépend des unités utilisées par votre logiciel) et que la valeur du vert soit à zéro. Le résultat est une teinte spéciale de rose clair, qu'on appelle aussi magenta.

Cela dépend de ce que vous faites exactement. Si vos images sont complètement opaques, il n'y a aucun avantage à utiliser des sprites RLE et ce sera probablement plus rapide d'utiliser des bitmap classiques avec la fonction blit(). Si vos graphiques contiennent des zones masquées, un sprite RLE sera presque toujours plus petit et plus rapide que la fonction draw_sprite(). Les sprites compilés sont en général plus rapides que les deux autres pour les images masquées et un peu plus rapides pour les images opaques, mais c'est beaucoup plus variable. Ils sont plus efficaces avec des petits sprites, sur des machines plus anciennes et en mode-X et peuvent être plus lents que blit() quand vous utilisez les modes SVGA sur un Pentium (la grande taille des sprites compilés est très mauvaise pour la performance du cache).

Vous devez vous assurer que la logique du jeu est mise à jour à un rythme régulier, mais sauter le rafraîchissement écran de temps en temps si l'ordinateur est trop lent pour suivre. Cela peut être fait en installant un compteur de temps qui va incrémenter une variable globale à la vitesse de la logique de votre jeu, c'est-à-dire :

volatile int speed_counter = 0;

void increment_speed_counter() {
   speed_counter++;
}

END_OF_FUNCTION(increment_speed_counter);

void play_the_game() {
   LOCK_VARIABLE(speed_counter);
   LOCK_FUNCTION(increment_speed_counter);

   install_int_ex(increment_speed_counter, BPS_TO_TIMER(60));

   while (!game_over) {
      while (speed_counter > 0) {
         update_game_logic();
         speed_counter--;
      }

      update_display();
   }
}

Ajoutez un appel à save_bitmap() quelque part dans votre code. Lisez la documentation de save_bitmap() pour une discussion sur un piège classique dans ce type d'utilisation et exemple de code.

Appelez srand(time(NULL)) au début de votre programme et utilisez ensuite rand()%limite pour obtenir un nombre pseudoaléatoire entre 0 and limite-1