Allegro 5

Voici la liste des fonctions dont nous disposons.

La fonction al_resize_display :

bool al_resize_display(ALLEGRO_DISPLAY *display, int width,int height)

Cette fonction sert à redimensionner la fenêtre. Elle prend en paramètre la fenêtre (pointeur display ) concernée, la nouvelle largeur width , la nouvelle hauteur height . Elle retourne vrai si succès.

La fonction al_get_display_width :

int al_get_display_width(ALLEGRO_DISPLAY *display)

Retourne la largeur de la fenêtre. Elle prend en paramètre la fenêtre display .

La fonction al_get_display_height :

int al_get_display_height(ALLEGRO_DISPLAY *display)

Retourne la hauteur de la fenêtre. Elle prend en paramètre la fenêtre display .

La fonction al_set_window_position :

void al_set_window_position(ALLEGRO_DISPLAY *display, int x, int y)

Permet de positionner la fenêtre n'importe où dans l'écran. Elle prend la fenêtre en paramètre ainsi que la position horizontale x et la position verticale y souhaitées.

La fonction al_get_window_position :

void al_get_window_position(ALLEGRO_DISPLAY *display,int*x,int *y)

Récupère la position à l'écran de la fenêtre display via deux variables passées par référence aux pointeurs x pour l'horizontale et y pour la verticale.

Dans le test suivant, nous expérimentons ces fonctions. Dans une boucle sont répétées dix fois de suite dans l'ordre les opérations suivantes :

• Déterminer une taille aléatoire pour la fenêtre.

Si cette taille est acceptable elle est assignée à la fenêtre et :

• La fenêtre est déplacée à une position aléatoire dans l'écran.
• Sa couleur est changée.
• Elle est affichée (bascule al_flip_display du double buffer à l'écran).
• Une fenêtre de dialogue donne ses valeurs de taille et de position.

#include <stdio.h>
#include <time.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d=al_is_system_installed()?al_get_current_display():NULL;
    al_show_native_message_box(d,"ERREUR",txt,NULL,NULL,0);
    exit(EXIT_FAILURE);
}

// une fonction avec chaîne formatée et liste variable de
// paramètres comme printf
void message(const char*format,...)
{
    ALLEGRO_DISPLAY*display;
    char txt[1024];
    va_list args;

    // création liste de param
    va_start(args,format);
    // compose la chaîne selon les paramètres et la récupère
    // dans le tableau de char txt
    vsnprintf(txt,sizeof(txt),format,args);

    // supprime la liste créée
    va_end(args);

    // récupère le diplay s'il existe
    display = al_is_system_installed() ? al_get_current_display() : NULL;
    //affiche une fenêtre de dialogue avec la chaîne
    al_show_native_message_box(display,"Message","",txt,NULL,0);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    int i,res,w,h,x,y;
    srand(time(NULL));

    if(!al_init())
        erreur("al_init()");

    // fenêtre au départ
    display=al_create_display(800,600);
    if(!display)
        erreur("create_display");

    // 10 fois
    for (i=0; i<10; i++){
        // nouvelle taille aléatoire
        res = al_resize_display(display,// fenêtre courante
                                1+rand()%1920, // largeur
                                1+rand()%1080);// hauteur

        // récupérer les nouvelles largeur et hauteur
        w = al_get_display_width(display);
        h = al_get_display_height(display);

        // si ok
        if(res){
            // changer la position de la fenêtre
            al_set_window_position(display,
                                    rand()%(1920-w), // pos x
                                    rand()%(1080-h));// pos y

            // récupérer la position de la fenêtre
            al_get_window_position(display, &x, &y);
            // changer sa couleur
            al_clear_to_color(al_map_rgb(rand()%256,// rouge
                                rand()%256,// vert
                                rand()%256));// bleu
            al_flip_display();

            // afficher sa taille et sa position
            message("%4d par %4d\npos : (%d,%d)",w,h,x,y);
        }
        else{
            message("%4d par %4d : echoue\n",w,h);
            exit(EXIT_FAILURE);
        }
    }

    al_destroy_display(display);
    return 0;
}

À noter dans ce programme l'utilisation d'une fonction avec une liste variable d'arguments, c'est la fonction message qui permet à la fenêtre de dialogue d'avoir un affichage avec une chaîne formatée comme dans un printf() .

La liste d'arguments associés à la chaîne de caractères formatée est transformée en une chaîne ordinaire grâce à la fonction standard vsnprintf() :

vsnprintf(char*, int, const char*, va_list);

Cette fonction stocke la chaîne finale au paramètre p1 avec une taille maximum donnée au paramètre p2 à partir de la chaîne formatée donnée au paramètre p3 et de la liste standard d'arguments passée au paramètre p4.

vsnprintf_s(char*, int, const char*, va_list);

A priori tout ce qui change à l'utilisation est le suffixe _s à ajouter à la fin.

#define _CRT_SECURE_NO_WARNINGS

Toutes les fenêtres que nous avons vues jusqu'à maintenant ont une taille fixe décidée avec al_create_display() . Cette taille est éventuellement modifiable dans le code. Mais l'utilisateur ne peut pas la changer en tirant sur un bord ou un coin, ni en double cliquant dans la barre de titre. Pour que le redimensionnement de la fenêtre par l'utilisateur soit possible, il faut le spécifier avant la création de la fenêtre avec la fonction :

void al_set_new_display_flags(int flags)

Cette fonction permet d'activer différentes fonctionnalités choisies parmi celles qui sont proposées. Le paramètre flags est un tableau de bits. Chacun des bits de l'entier flags correspond à une fonctionnalité. S'il est à 1, la fonctionnalité est activée ; s'il est à 0, elle ne l'est pas. La mise à 1 d'une fonctionnalité est obtenue à l'aide d'une macro constante #define spécifique qui définit le bit voulu à 1. Les macros constantes qui nous intéressent ici sont :

• ALLEGRO_WINDOWED pour spécifier un mode fenêtré.
• ALLEGRO_RESIZABLE pour indiquer une fenêtre redimensionnable (nous verrons d'autres fonctionnalités plus tard).

La réunion de ces deux propriétés s'obtient avec l'opérateur bit à bit de mise à 1 de la façon suivante :

ALLEGRO_WINDOWED | ALLEGRO_RESIZABLE

Ainsi l'appel :

al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_RESIZABLE);

signifie que le bit pour mode fenêtré et le bit pour redimensionnement sont mis à 1. Ces deux propriétés sont ainsi activées lors de la création de la fenêtre qui suit. Le programme suivant permet de le constater :

#include <stdio.h>
#include <time.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d=al_is_system_installed()?al_get_current_display():NULL;
    al_show_native_message_box(d,"ERREUR",txt,NULL,NULL,0);
    exit(EXIT_FAILURE);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_KEYBOARD_STATE key; // clavier simple
    int fin=0;

    srand(time(NULL));

    if(!al_init())
        erreur("al_init()");

    // paramétrage fonctionnalités fenêtre avant sa création
    al_set_new_display_flags(ALLEGRO_WINDOWED |
                             ALLEGRO_RESIZABLE);
    display=al_create_display(800,600);
    if(!display)
        erreur("create_display(800,600)");

    // pour utiliser le clavier
    if(!al_install_keyboard())
        erreur("al_install_keyboard()");

    // boucle qui laisse le temps à l'utilisateur de manipuler
    // la fenêtre
    while(!fin){

        // récupération de l'état du clavier
        al_get_keyboard_state(&key);

        // si touche [Echap] appuyée fin boucle et quitter
        if(al_key_down(&key,ALLEGRO_KEY_ESCAPE))
            fin=1;

        al_flip_display();
    }
    al_destroy_display(display);
    return 0;
}

Le mode fenêtré plein écran est en principe donné par :

ALLEGRO_FULLSCREEN_WINDOWE

En effet d'après la documentation l'appel de :

al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);

suivi de :

display=al_create_display(800,600);

ne tient pas compte des 800x600 demandés. Il donne une fenêtre qui couvre tout l'écran selon la résolution courante, faisant disparaître et la barre de titre dans le haut de la fenêtre et la barre des tâches du bureau exactement comme si vous étiez en en mode plein écran.

Mais en réalité ce n'est pas ce qui se passe actuellement du fait semble-t-il d'une erreur pas encore corrigée. Vous obtiendrez une fenêtre sans barre de titre en haut de 800 par 600 pixels.

Le programme suivant permet de le vérifier :

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <time.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d=al_is_system_installed()?al_get_current_display():NULL;
    al_show_native_message_box(d,"ERREUR",txt,NULL,NULL,0);
    exit(EXIT_FAILURE);
}

void message(const char*format,...)
{
    ALLEGRO_DISPLAY*display;
    char txt[1024];
    va_list args;

    va_start(args,format);
    vsnprintf(txt,sizeof(txt),format,args);
    va_end(args);

    display = al_is_system_installed() ?
                            al_get_current_display() : NULL;
    al_show_native_message_box(display,"Message",txt,txt,NULL,0);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    int w,h;

    srand(time(NULL));
    if(!al_init())
        erreur("al_init()");

    al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
    // ensuite en dépit des 800x600 demandés prend automatiquement
    // la résolution courante de l'écran
    display=al_create_display(800,600);
    if(!display)
        erreur("create_display");

    // changer sa couleur
    al_clear_to_color(al_map_rgb(rand()%256,rand()%256,
                                rand()%256));
    al_flip_display();

    // pour récupérer la largeur et la hauteur
    w = al_get_display_width(display);
    h = al_get_display_height(display);
    message("resolution : %d par %d\n",w,h);
    al_rest(3.0);

    al_destroy_display(display);
    return 0;
}

Cependant, lorsque cette erreur sera corrigée, avec ce même code vous devriez obtenir un mode plein écran. Actuellement pour obtenir une fenêtre plein écran, il faut récupérer soi-même la résolution maximale de l'écran et créer une fenêtre de cette taille :

ALLEGRO_DISPLAY_MODE rec;
al_get_display_mode(al_get_num_display_modes() - 1, &rec);
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
display = al_create_display(rec.width, rec.height);

Il reste que la barre des tâches n'est pas masquée par la fenêtre. Elle demeure par dessus.

Par ailleurs, cette technique de récupération des résolutions possibles de la carte graphique et de l'écran et par conséquent la possibilité de trouver la résolution la plus grande sont détaillées plus loin.

Le mode plein écran sans fenêtre est donné par :

ALLEGRO_FULLSCREEN

et l'appel de al_set_new_display_flags() avant la création de la fenêtre :

al_set_new_display_flags(ALLEGRO_FULLSCREEN);

III-F-2-a. Expérimentation▲

#include <stdio.h>
#include <time.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    int w, h;

    srand(time(NULL));
    if (!al_init())
        erreur("al_init()");

    al_set_new_display_flags(ALLEGRO_FULLSCREEN);
    display = al_create_display(320, 200);
    if (!display)
        erreur("create_display");

    // changer sa couleur
    al_clear_to_color(al_map_rgb(rand() % 256, rand() % 256,
        rand() % 256));
    al_flip_display();

    // pour récupérer la largeur et la hauteur
    w = al_get_display_width(display);
    h = al_get_display_height(display);

    // affiche la résolution dans la console
    printf("resolution : %d par %d\n", w, h);
    al_rest(3.0);

    al_destroy_display(display);

    // pour retenir la console avant fermeture
    system("PAUSE");
    return 0;
}

Allegro fournit une structure :

ALLEGRO_DISPLAY_MODE

qui permet de connaître quels sont les paramètres plein écran que supporte l'ordinateur et sa carte graphique.

Cette structure est composée comme suit :

typedef struct ALLEGRO_DISPLAY_MODE {
    int width; // largeur de l'écran (résolution)
    int height; // hauteur de l'écran
    int format; // format de pixel du mode
    int refresh_rate; // fréquence de rafraîchissement du mode
} ALLEGRO_DISPLAY_MODE;

Les champs width et height donnent une résolution possible, format correspond à une profondeur de couleur (8, 16, 24, 32 bits).

Le nombre total des résolutions plein écran possibles sur l'ordinateur s'obtient avec la fonction :

int al_get_num_display_modes(void)

Ensuite les caractéristiques de chaque mode sont récupérables avec la fonction :

ALLEGRO_DISPLAY_MODE *al_get_display_mode(int n, ALLEGRO_DISPLAY_MODE *mode)

Cette fonction retourne dans la structure mode passée par référence en paramètre p2 les caractéristiques du mode numéro n donné en paramètre p1. En cas d'échec la fonction retourne NULL .

Le programme suivant commence par afficher dans la fenêtre console tous les modes plein écran possibles. Ensuite l'utilisateur peut sélectionner un mode afin d'obtenir le plein écran correspondant. Une fois installé, le plein écran reste trois secondes puis le plein écran display disparaît et nous retournons à la fenêtre console. Pour quitter, il suffit d'entrer une valeur impossible (-1 par exemple).

#include <stdio.h>
#include <time.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d=al_is_system_installed()?al_get_current_display():NULL;
    al_show_native_message_box(d,"ERREUR",txt,NULL,NULL,0);
    exit(EXIT_FAILURE);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_DISPLAY_MODE mode;
    int i,nbmode;
    srand(time(NULL));

    if(!al_init())
        erreur("al_init()");

    // récupère le nombre de résolutions possibles
    nbmode = al_get_num_display_modes();
    printf("il y a %d résolution possibles :\n",nbmode);
    
    for (i = 0; i < nbmode; i++){
        // récupère les informations pour chaque mode
        al_get_display_mode(i, &mode);

        // affiche la résolution du mode courant
        // dans la console
        printf("mode %2d resolution %4d x %4d "
                "%2d bits et %2d \n",
                i, mode.width, mode.height,
                al_get_pixel_format_bits(mode.format),
                mode.refresh_rate);
    }

    // tester les résolutions
    do{
        printf("entrer le numéro du mode souhaite :\n");
        scanf_s("%d", &i);
        rewind(stdin);

        if (i >= 0 && i < nbmode){
            // crée un display plein écran
            // dans le mode courant
            al_get_display_mode(i, &mode);
            al_set_new_display_refresh_rate(mode.refresh_rate);
            al_set_new_display_flags(ALLEGRO_FULLSCREEN);
            display = al_create_display(mode.width,
                                        mode.height);

            // change la couleur de la fenêtre
            al_clear_to_color(al_map_rgb(rand() % 256,
                                rand() % 256,
                                rand() % 256));
            // affiche et reste trois seconde
            al_flip_display();
            al_rest(3.0);

            // détruit le display courant, passe au suivant
            al_destroy_display(display);
        }
    }while(i >= 0 && i < nbmode);

    return 0;
}

La fonction al_set_new_display_refresh_rate :

void al_set_new_display_refresh_rate(int refresh_rate)

Cette fonction sert à spécifier la fréquence de rafraîchissement dans cette situation où l'on recrée une fenêtre display à partir de celle existante et selon un nouveau mode. Il faut veiller à ce que mode et fréquence de rafraîchissement soient compatibles. Selon le mode souhaité, la fonction permet d'activer la fréquence correspondante qui doit lui être passée en paramètre.

III-F-3-a. Obtenir la plus grande résolution ▲

al_get_num_display_modes()-1

#include <stdio.h>
#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*************************************************************
*************************************************************/
int main()
{
    ALLEGRO_DISPLAY_MODE mode;
    int nbmode = 0;
    if (!al_init())
        erreur("al_init()");


    // récupère les informations du dernier mode
    nbmode = al_get_num_display_modes();
    al_get_display_mode(nbmode - 1, &mode);

    // affiche la résolution du mode courant dans la console
    printf("mode %d resolution %4d x %4d\n", nbmode,
        mode.width, mode.height);

    // presser une touche pour continuer
    system("PAUSE");

    return 0;
}

ALLEGRO_DISPLAY* display;
display = al_create_display(mode.width,mode.height);

Voici une proposition de départ utile pour des projets Allegro simples. Vous serez peut-être amené ultérieurement à faire d'autres modèles de projet pour des projets plus complexes intégrant notamment la gestion des événements, des possibilités de dessin et des affichages d'images.

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>


void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*****************************************************************
*****************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_KEYBOARD_STATE key;

    if (!al_init())
        erreur("al_init()");

    if (!al_install_keyboard())
        erreur("al_install_keyboard()");

    display = al_create_display(800, 600);
    if (!display)
        erreur("al_create_display()");

    do{
        al_get_keyboard_state(&key);



    } while (!al_key_down(&key, ALLEGRO_KEY_ESCAPE));

    al_destroy_display(display);
    return 0;
}
/*****************************************************************
*****************************************************************/

Dernier point important, avant de passer à la sauvegarde du projet en tant que modèle, compilez le projet en mode debug et en mode release et vérifiez qu'il n'y pas de bogue.

Une fois ces trois opérations terminées (projet, configuration, tests), il faut sauvegarder le projet sous forme de modèle. Nous détaillons ci­dessous cette sauvegarde pour Code::Blocks, puis pour Visual Studio.

Sous Code::Blocks, allez dans le menu File et sélectionnez Save project as template :

Dans la fenêtre entrez un nom pour le modèle et cliquez sur OK. Le modèle est sauvegardé.

Il se retrouve ensuite dans la fenêtre de sélection de modèles lors de la création d'un projet dans la rubrique User templates sur le côté gauche de la fenêtre :

Cliquez sur User templates.

La fenêtre suivante s'affiche :

Dans cette fenêtre, il suffit de sélectionner son modèle. Il est évidemment possible de faire toutes sortes de modèles, par exemple plusieurs types de projets Allegro pour des styles d'applications différentes qui nécessitent des initialisations différentes dans le code au départ.

Pour sauvegarder un projet en tant que modèle de projet (template) sous Visual Studio :

Dans le menu Fichier sélectionnez Exporter le modèle.

La fenêtre Assistant Exportation de modèle s'ouvre :

Un choix est proposé : faire un modèle de projet ou un modèle d'élément (par exemple une page de code). Sélectionnez Modèle de projet.

La liste tout en bas permet de sélectionner dans la solution le projet qui va servir de modèle (rappelons qu'une solution peut contenir plusieurs projets). Pour nous, le projet se nomme « modèle de projet ». Ensuite, cliquez sur Suivant.

Une fenêtre d'options pour le modèle apparaît :

Le premier champ sert à nommer son modèle. Nous avons nommé le nôtre « Allegro 5.0.10-base jeu » (quoiqu'ici ce ne soit pas encore vraiment complet).

Le second champ permet d'entrer une description du modèle, description qui sera retrouvée ensuite sur la gauche dans la fenêtre de création de projets. C'est pratique pour se rappeler de certaines spécifications propres au projet.

Le troisième champ offre la possibilité d'adjoindre une icône pour le projet. Nous avons choisi une petite icône qui se trouve dans un dossier images sur la partition D de notre disque dur.

Le quatrième champ permet d'associer une image à la description du projet. L'image choisie se trouvera centrée en dessous du texte d'explication dans le volet gauche de la fenêtre de création de projets.

L'emplacement de sortie correspond à l'emplacement sur le disque où est sauvegardé le modèle. Mais le modèle qui est utilisé pour un nouveau projet par Visual Studio en est une copie et se trouve dans le dossier Template. Si au besoin vous devez supprimer un modèle de projet et ne plus le voir apparaître dans la fenêtre de création de projets, il faut le supprimer dans le dossier Template.

Si vous cochez Importer automatiquement le modèle dans Visual Studio, celui-ci sera intégré et visible dans la fenêtre nouveau projet.

Si vous cochez Afficher une fenêtre d'explorateur pour le dossier des fichiers de sorties, une telle fenêtre s'ouvre lorsque vous cliquez sur Terminer, ce qui permet de voir où est stocké le modèle et sous quelle forme sur le disque.

Une fois toutes ces informations entrées, cliquez sur Terminer.

Ouvrez la fenêtre Nouveau projet, votre modèle y apparaît.

Sous Windows la fenêtre console est fournie par défaut lorsque l'on débute un projet à partir de « projet vide ». Pour supprimer cette console, sous Code::Blocks comme sous Visual Studio, il faut commencer un projet en sélectionnant un modèle du type application Win32.

III-H-1-a. Création d'un projet sans fenêtre console▲

Sous Code::Blocks, vous devez commencer par choisir un projet Win32 et simplement remplacer tout le code fourni automatiquement avec le modèle par celui de l'application Allegro. Ensuite, si vous partez souvent avec ce type de projet, il peut être utile de réaliser un nouveau modèle.

Pour Visual Studio il y a la possibilité de commencer un projet Win32, de spécifier qu'on le veut vide afin de le compléter pour Allegro ensuite. La démarche est la suivante :

Sélectionnez Nouveau projet, la fenêtre Nouveau projet s'ouvre :

Dans le volet gauche, sélectionnez Win32 et au centre Projet Win32, donnez un nom pour le projet et la solution, positionnez sur le disque l'endroit de la sauvegarde puis cliquez sur OK.

La fenêtre Assistant Application Win32 s'ouvre :

Sur la gauche, cliquez sur Paramètres de l'application. La fenêtre correspondante s'ouvre :

Décochez Vérifications SDL (…) et cochez Projet vide ce qui donne :

Cliquez sur Terminer.

Un nouveau projet sans page de code est ouvert que vous retrouvez dans l'explorateur de solutions. Il reste à lui ajouter une page de code et à établir les liens pour l'utilisation de la bibliothèque Allegro.

Ce projet ne contiendra pas de fenêtre console.

III-H-1-b. Alternative à la fenêtre console sous Allegro▲

ALLEGRO_TEXTLOG *console;

ALLEGRO_TEXTLOG *al_open_native_text_log(char const *title, int flags)

ALLEGRO_TEXTLOG *console;
console = al_open_native_text_log("Ma console", 0);

void al_append_native_text_log(ALLEGRO_TEXTLOG *textlog, char const *format, ...)

al_append_native_text_log(console, "position souris : %d, %d\n", mouse.x, mouse.y);

void al_close_native_text_log(ALLEGRO_TEXTLOG *textlog)

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*****************************************************************
*****************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_KEYBOARD_STATE key;
    ALLEGRO_MOUSE_STATE mouse;

    ALLEGRO_TEXTLOG *console; // une console

    if (!al_init())
        erreur("al_init()");

    if (!al_install_keyboard())
        erreur("al_install_keyboard()");

    if (!al_install_mouse())
        erreur("al_install_mouse()");

    display = al_create_display(800, 600);
    if (!display)
        erreur("al_create_display()");

    // création et ouverture
    console = al_open_native_text_log("Ma console", 0);
    if (!console)
        erreur("al_open_native_text_log(\"Ma console\", 0)");

    int mx = 0;
    int my = 0;
    do{
        al_get_keyboard_state(&key);
        al_get_mouse_state(&mouse);

        // écrire dans la console
        if (console != NULL && (mx!=mouse.x || my!= mouse.y)){
            mx = mouse.x;
            my = mouse.y;
            al_append_native_text_log(console,
                 "position souris : %d, %d\n", mx, my);
        }

        //fermer la console
        if (al_key_down(&key, ALLEGRO_KEY_ENTER)){
            al_close_native_text_log(console);
            console = NULL;
        }

        
    } while (!al_key_down(&key, ALLEGRO_KEY_ESCAPE));

    al_destroy_display(display);
    return 0;
}
/*****************************************************************
*****************************************************************/

La capture du clavier que nous utilisons pour l'instant est pratique et rapide à mettre en place. La même méthode existe pour la souris mais aussi pour le joystick. Certes les performances sont plus limitées qu'avec une file d'événements (pas de minuteur notamment) mais elle est suffisante dans certaines situations. Nous allons l'utiliser pour tester les fonctions de dessin ainsi que les fonctions d'affichage des images dans les deux chapitres qui suivent.

III-H-2-a. Problème des répétitions du clavier▲

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>
#include <stdio.h>

// contrôle d'erreur
void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
}
/*******************************************
********************************************/
int main()
{
    ALLEGRO_DISPLAY *display;
    ALLEGRO_KEYBOARD_STATE key; // stocke l'état du clavier
    int fin = 0, cmpt = 0;

    if (!al_init())
        erreur("al_init()");

    //Pour avoir le clavier
    if (!al_install_keyboard())
        erreur("al_install_keyboard()");

    display = al_create_display(800, 600);
    if (!display)
        erreur("al_create_display()");
    al_set_window_title(display, "Clavier simple");

    while (!fin){
        // récupérer l'état du clavier
        al_get_keyboard_state(&key);

        if (al_key_down(&key, ALLEGRO_KEY_ESCAPE))
            fin = 1;

        // incrémentation de la variable
        if (al_key_down(&key, ALLEGRO_KEY_ENTER))
            cmpt++;

        // affichage
        if (al_key_down(&key, ALLEGRO_KEY_SPACE))
            printf("%d\n", cmpt);

        al_flip_display();

    }
    al_destroy_display(display);

    return 0;
}
/*******************************************
********************************************/

III-H-2-b. Compter les répétitions clavier▲

int press[ALLEGRO_KEY_MAX] ;

if(al_key_down(&key,matouche))
    press[matouche]++ ;

if(al_key_down(&key,matouche)){
    press[matouche]++ ;
    // faire les instructions associées à la touche
}
else if(!al_key_down(&key,matouche) // si relevée remise à 0
    press[matouche]=0 ;

if(al_key_down(&key,matouche) && press[matouche] < 5){
    press[matouche]++ ;
    // faire les instructions associées à la touche
}
else if(!al_key_down(&key,matouche)
    press[matouche]=0 ;

int is_key_pressed( ALLEGRO_KEYBOARD_STATE*key,int touche, int repeat)
{
    //le tableau conserve ses valeurs d'un appel à l'autre (static)
    static int press[ALLEGRO_KEY_MAX]={0};
    int res=0;
    if (al_key_down(key,touche)&& press[touche] < repeat ){
        press[touche]++;
        res=1;
    }
    else if( ! al_key_down(key,touche))
        press[touche]=0;
    return res;
}

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>


void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "Erreur", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*****************************************************************
*****************************************************************/
int is_key_pressed(ALLEGRO_KEYBOARD_STATE*key, int touche, int repeat)
{
    //le tableau conserve ses valeurs d'un appel à l'autre (static)
    static int press[ALLEGRO_KEY_MAX] = { 0 };
    int res = 0;

    if (al_key_down(key, touche) && press[touche] < repeat){
        press[touche]++;
        res = 1;
    }
    else if (!al_key_down(key, touche))
        press[touche] = 0;
    return res;

}
/*****************************************************************
*****************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_KEYBOARD_STATE k, *key = &k;
    ALLEGRO_TEXTLOG * textlog;

    if (!al_init())
        erreur("al_init()");

    if (!al_install_keyboard())
        erreur("install keyboard");

    display = al_create_display(800, 600);
    if (!display)
        erreur("display");

    // fenêtre console native allegro
    textlog = al_open_native_text_log("test clavier",
        ALLEGRO_TEXTLOG_MONOSPACE);

    al_append_native_text_log(textlog,
        "Test fleches pressee, ESCAPE pour quitter :\n");
    do{
        al_get_keyboard_state(key);

        if (is_key_pressed(key, ALLEGRO_KEY_UP, 1))
            al_append_native_text_log(textlog,
            "touche UP pressee\n");

        if (is_key_pressed(key, ALLEGRO_KEY_RIGHT, 2))
            al_append_native_text_log(textlog,
            "touche RIGHT pressee\n");

        if (is_key_pressed(key, ALLEGRO_KEY_DOWN, 3))
            al_append_native_text_log(textlog,
            "touche DOWN pressee\n");

        if (is_key_pressed(key, ALLEGRO_KEY_LEFT, 10))
            al_append_native_text_log(textlog,
            "touche LEFT pressee\n");

    } while (!is_key_pressed(key, ALLEGRO_KEY_ESCAPE, 1));



    al_destroy_display(display);
    return 0;

}
/*****************************************************************
*****************************************************************/

La capture des clics de la souris avec la méthode que nous utilisons pour l'instant présente les mêmes avantages et inconvénients que la capture du clavier : pratique et rapide à mettre en place, mais le contrôle des clics doit être renforcé.

III-H-3-a. Problème des répétitions de clics▲

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>
#include <stdio.h>

int SCREENX = 640;
int SCREENY = 480;

/*****************************************************************
*****************************************************************/
void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*****************************************************************
*****************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_KEYBOARD_STATE key;
    ALLEGRO_MOUSE_STATE mouse;
    int gauche = 0, droite = 0;

    if (!al_init())
        erreur("al_init()");

    if (!al_install_keyboard())
        erreur("al_install_mouse()");

    if (!al_install_mouse())
        erreur("al_install_mouse()");

    display = al_create_display(SCREENX, SCREENY);
    if (!display)
        erreur("al_create_display()");


    do{
        al_get_keyboard_state(&key);
        
        al_get_mouse_state(&mouse);

        if ( al_mouse_button_down(&mouse, 1)){
            gauche++;
            printf("gauche : %d\n", gauche);
        }

        if (al_mouse_button_down(&mouse, 2)){
            droite++;
            printf("droite : %d\n", droite);
        }

        if (al_key_down(&key, ALLEGRO_KEY_ENTER))
            gauche = droite = 0;

    } while (!al_key_down(&key, ALLEGRO_KEY_ESCAPE));

    al_destroy_display(display);
    return 0;
}
/*****************************************************************
*****************************************************************/

III-H-3-b. Compter les clics sur chaque bouton de la souris▲

static int*PRESS = NULL;

int nbbtn= al_get_num_mouse_button() ;

int nbbtn = al_get_mouse_num_buttons();
if (PRESS == NULL){
    PRESS = (int*)calloc(nbbtn+1, sizeof(int));
    memset(PRESS, 0, sizeof(int)*(nbbtn + 1));
}

int is_mouse_pressed(ALLEGRO_MOUSE_STATE*mouse, int btn, int repeat)
{
    int res = 0;
    int nbbtn = al_get_mouse_num_buttons();
    // initialisation du tableau de contrôle
    if (PRESS == NULL){
        PRESS = (int*)calloc(nbbtn+1, sizeof(int));
        memset(PRESS, 0, sizeof(int)*(nbbtn + 1));
    }
    if (btn > nbbtn)
        btn = nbbtn;
    if (al_mouse_button_down(mouse, btn) && PRESS[btn] < repeat){
        PRESS[btn]++;
        res = 1;
    }
    else if (!al_mouse_button_down(mouse, btn))
        PRESS[btn] = 0;
    return res;
}

for (i=1; i<=nbbtn; i++)
    if (is_mouse_pressed(&mouse,i,2))
        al_append_native_text_log(textlog,"boutons %d presse\n",i);

#include <allegro5/allegro.h>
#include <allegro5/allegro_native_dialog.h>

static int*PRESS = NULL;

void erreur(const char*txt)
{
    ALLEGRO_DISPLAY*d;
    d = al_is_system_installed() ? al_get_current_display() : NULL;
    al_show_native_message_box(d, "Erreur", txt, NULL, NULL, 0);
    exit(EXIT_FAILURE);
}
/*****************************************************************
*****************************************************************/
int is_mouse_pressed(ALLEGRO_MOUSE_STATE*mouse, int btn, int repeat)
{
    int res = 0;
    int nbbtn = al_get_mouse_num_buttons();
    
    // initialisation du tableau de contrôle
    if (PRESS == NULL){
        PRESS = (int*)calloc(nbbtn+1, sizeof(int));
        memset(PRESS, 0, sizeof(int)*(nbbtn + 1));
    }

    if (btn > nbbtn)
        btn = nbbtn;

    if (al_mouse_button_down(mouse, btn) && PRESS[btn] < repeat){
        PRESS[btn]++;
        res = 1;
    }
    else if (!al_mouse_button_down(mouse, btn))
        PRESS[btn] = 0;

    return res;
}
/*****************************************************************
*****************************************************************/
int main()
{
    ALLEGRO_DISPLAY*display;
    ALLEGRO_MOUSE_STATE mouse;
    ALLEGRO_KEYBOARD_STATE key;
    ALLEGRO_TEXTLOG * textlog;
    int i,nbbtn;

    if (!al_init())
        erreur("allegro init");

    if (!al_install_mouse())
        erreur("install mouse");

    if (!al_install_keyboard())
        erreur("install clavier");

    display = al_create_display(800, 600);
    if (!display)
        erreur("display");

    // pour avoir une fenêtre console même sans débug
    textlog = al_open_native_text_log("test souris",
        ALLEGRO_TEXTLOG_MONOSPACE);
    al_append_native_text_log(textlog,
        "SOURIS TEST 2 / ESCAPE pour quitter :\n");

    nbbtn = al_get_mouse_num_buttons();
    do{

        // action souris
        al_get_mouse_state(&mouse);

        // état des boutons
        
        for (i = 1; i <= nbbtn; i++){
            if (is_mouse_pressed(&mouse, i, 2))
                al_append_native_text_log(textlog,
                "boutons %d presse\n", i);

        }

        // recup état du clavier
        al_get_keyboard_state(&key);

    } while (!al_key_down(&key, ALLEGRO_KEY_ESCAPE));

    al_destroy_display(display);
    free(PRESS);
    return 0;
}
/*****************************************************************
*****************************************************************/