Création de la pluie de code dans le terminal avec C et Ncurses

Introduction

Dans ce projet, vous allez apprendre à créer une pluie de caractères simple en utilisant la bibliothèque ncurses en langage C. Ncurses est une bibliothèque qui facilite l'utilisation d'interfaces utilisateur basées sur le texte dans le terminal. Ce projet vous guidera tout au long du montage du projet, de l'initialisation des composants nécessaires et de la mise en œuvre de la pluie de caractères.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment installer la bibliothèque ncurses
• Comment définir des constantes et des structures pour les gouttes de pluie
• Comment initialiser les couleurs pour l'animation
• Comment créer une boucle d'animation pour afficher les gouttes de pluie tombant
• Comment lire l'entrée de l'utilisateur pour quitter l'animation

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Utiliser la bibliothèque ncurses en C
• Implémenter des structures en C
• Créer des animations dans le terminal

Créer les fichiers du projet

Tout d'abord, assurez-vous d'avoir la bibliothèque ncurses installée sur votre système. Si ce n'est pas le cas, vous pouvez utiliser la commande suivante pour l'installer :

sudo apt update
sudo apt-get install libncurses5-dev

Ensuite, créez un nouveau fichier nommé code_rain.c et ouvrez-le dans votre éditeur de code préféré.

cd ~/project
touch code_rain.c

Définir les constantes

Maintenant, créez les fichiers d'en-tête nécessaires, y compris Ncurses, la bibliothèque standard et le temps. Définissez le nombre maximum de gouttes de pluie et créez une structure pour les gouttes de pluie avec leurs propriétés.

#include <ncurses.h>
#include <stdlib.h>
#include <time.h>

#define MAX_RAIN 200

typedef struct {
    int x, y;
    char ch;
    int color;
    int speed;
} Raindrop;

Initialiser les couleurs

Créez une fonction pour initialiser les couleurs qui seront utilisées dans l'animation. Cette fonction utilisera les fonctions start_color et init_pair fournies par ncurses pour configurer les paires de couleurs.

void init_colors() {
    start_color();
    init_pair(1, COLOR_GREEN, COLOR_BLACK);
    init_pair(2, COLOR_CYAN, COLOR_BLACK);
    init_pair(3, COLOR_MAGENTA, COLOR_BLACK);
    init_pair(4, COLOR_YELLOW, COLOR_BLACK);
}

La fonction start_color() est la fonction qui active la fonction de couleur de ncurses. Cette fonction doit être appelée avant d'utiliser toute autre fonction de manipulation de couleur.

La fonction init_pair(1, COLOR_GREEN, COLOR_BLACK) est ensuite utilisée pour modifier la définition de la paire de couleurs. Elle accepte trois paramètres : le numéro de la paire de couleurs, le numéro de la couleur du premier plan et le numéro de la couleur d'arrière-plan. Ici, la fonction init_pair est utilisée pour définir quatre paires de couleurs avec une couleur du premier plan de vert, cyan, magenta et jaune, et une couleur d'arrière-plan de noir.

Implémenter la fonction principale

Dans la fonction main, configurez l'environnement ncurses, y compris la désactivation du buffering de ligne et de l'affichage des caractères saisis. Activez le pavé numérique pour les touches spéciales et configurez l'entrée non bloquante. Obtenez les dimensions maximales de l'écran et initialisez les couleurs à l'aide de la fonction définie précédemment.

int main() {
    initscr();
    cbreak();
    noecho();
    curs_set(0);
    keypad(stdscr, TRUE);
    nodelay(stdscr, TRUE);

    int max_x, max_y;
    getmaxyx(stdscr, max_y, max_x);
    init_colors();

    Raindrop rain[MAX_RAIN];

    srand(time(NULL));

    //... (le reste du code sera couvert dans les étapes suivantes)
}

Initialiser les paramètres des gouttes de pluie

Initialisez les propriétés de chaque goutte de pluie à l'aide d'une boucle. Fixez leurs positions initiales, les caractères, les couleurs et les vitesses de chute.

for (int i = 0; i < MAX_RAIN; i++) {
    rain[i].x = rand() % max_x;
    rain[i].y = rand() % max_y;
    rain[i].ch = rand() % 94 + 33;
    rain[i].color = rand() % 4 + 1;
    rain[i].speed = rand() % 3 + 1;
}

Implémenter la boucle d'animation

Configurez une boucle pour mettre à jour continuellement les positions des gouttes de pluie et les afficher sur l'écran. Vérifiez les entrées de l'utilisateur pour sortir de la boucle d'animation.

while (1) {
    int ch = getch();

    if (ch == 'q') {
        break;
    }

    for (int i = 0; i < MAX_RAIN; i++) {
        attron(COLOR_PAIR(rain[i].color));
        mvaddch(rain[i].y, rain[i].x, ' ');
        rain[i].y += rain[i].speed;
        if (rain[i].y >= max_y) {
            rain[i].y = 0;
            rain[i].x = rand() % max_x;
        }
        mvaddch(rain[i].y, rain[i].x, rain[i].ch);
        attroff(COLOR_PAIR(rain[i].color));
    }

    refresh();
    napms(50);
}

Utilisez la fonction getch() pour obtenir les caractères d'entrée de l'utilisateur et les stocker dans la variable entière ch.

La boucle for est utilisée pour simuler l'effet des gouttes de pluie. Elle parcourt un tableau appelé rain, qui contient des informations sur plusieurs gouttes de pluie. Chaque goutte de pluie est composée des propriétés suivantes : couleur, coordonnées de position (x et y), vitesse de chute (speed) et caractère (ch).

Cette boucle continuera jusqu'à ce que vous appuyiez sur la touche q, auquel moment le programme passera la déclaration break; et sortira de la boucle, mettant ainsi fin au programme.

Après la fin de la boucle d'animation, nettoyez l'environnement ncurses et quittez le programme.

endwin();
return 0;

Compilation et exécution

La commande de compilation est légèrement différente de la normale. Elle nécessite d'ajouter l'option -l à gcc pour inclure la bibliothèque ncurses :

cd ~/project
gcc -o code_rain code_rain.c -l ncurses
./code_rain

Résumé

Dans ce projet, vous avez appris à créer une simple animation de gouttes de pluie à l'aide de la bibliothèque ncurses en langage C. Vous avez configuré le projet, initialisé les composants nécessaires, implémenté la boucle d'animation et géré les entrées de l'utilisateur pour quitter le programme. Ncurses fournit un ensemble d'outils puissants pour créer des interfaces utilisateur basées sur le texte, et vous pouvez l'utiliser pour créer divers types d'applications basées sur le terminal.