client_state_io.c

#include "state_io.h"     // Inclut les structures et les prototypes des fonctions
#include <ncurses.h>      // Inclut la bibliothèque Ncurses pour avoir un affichage plus propre dans le terminal

int socket_serveur;
int jeu_actif = 1;                                              // Flag indiquant si le jeu est actif
territoire_t territoires_affichage[NB_TERRITOIRES];             // Tableau des territoires pour stocker leur état et les afficher
pthread_mutex_t mutex_affichage = PTHREAD_MUTEX_INITIALIZER;    // Mutex pour protéger l'affichage

// Pointeurs vers les fenêtres ncurses
WINDOW *win_map;    // Pour la carte
WINDOW *win_input;  // Pour les commandes
WINDOW *win_help;   // Pour l'aide

// Prototypes des fonctions
void *thread_reception(void *arg);          // Fonction pour recevoir les mises à jour du serveur pour chaque thread
void initialiser_ncurses(void);             // Initialise l'environnement ncurses et configure les 3 fenêtres
void nettoyer_ncurses(void);                // Nettoie l'environnement ncurses avant de quitter
void afficher_map(void);                    // Met à jour et affiche la carte du jeu dans la fenêtre win_map
void afficher_aide_ncurses(void);           // Affiche les instructions et l'aide dans la fenêtre win_help
void traiter_entree_utilisateur(void);      // Gère la saisie des commandes par l'utilisateur
void mettre_a_jour_territoires(char *etat); // Met à jour le tableau des territoires

int main(int argc, char *argv[]) {
    // Initialisation du serveur
    struct sockaddr_in addr_serveur;
    pthread_t thread_recv;
    char *ip;
    int port;

    // Vérification des arguments de ligne de commande
    if (argc != 3) {
        printf("On utilise : %s <ip_serveur> <port>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    // Récupération de l'IP et du port
    ip = argv[1];
    port = atoi(argv[2]);

    // Création du socket
    socket_serveur = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_serveur < 0) {
        perreur("socket");
    }

    // Configuration de l'adresse du serveur
    memset(&addr_serveur, 0, sizeof(addr_serveur));
    addr_serveur.sin_family = AF_INET;
    addr_serveur.sin_port = htons(port);           // On convertit le port
    
    // Convertion de l'adresse IP en binaire
    if (inet_pton(AF_INET, ip, &addr_serveur.sin_addr) <= 0) { 
        erreur("Adresse IP invalide");
    }

    // Connexion au serveur
    if (connect(socket_serveur, (struct sockaddr*)&addr_serveur, sizeof(addr_serveur)) < 0) {
        perreur("connect");
    }

    // Initialisation de l'affichage des territoires
    int i;
    for (i = 0; i < NB_TERRITOIRES; i++) {
        territoires_affichage[i].id = i;
        territoires_affichage[i].proprietaire = LIBRE;
        territoires_affichage[i].soldats = 0;
    }

    // Initialisation de l'interface ncurses
    initialiser_ncurses();

    // Création du thread de réception des données du serveur
    if (pthread_create(&thread_recv, NULL, thread_reception, NULL) != 0) {
        nettoyer_ncurses();
        perreur("Création thread réception");
    }

    // Affichage de l'aide et de la carte
    afficher_aide_ncurses();
    afficher_map(); 

    // Traitement des commandes 
    traiter_entree_utilisateur();

    // Nettoyage du jeu avant de quitter
    jeu_actif = 0;                      // Flag de fin de partie
    pthread_join(thread_recv, NULL);    // On attend la fin du thread de réception
    close(socket_serveur);              // Fermeture du socket de connexion au serveur
    nettoyer_ncurses();                 // Nettoyage de l'environnement ncurses

    return EXIT_SUCCESS;
}


// Implémentation des fonctions pour l'affichage grace à ncurses et au mutex dédié à l'affichage

// Initialise les fenêtres pour l'afichage ncurses
void initialiser_ncurses(void) {
    initscr();                     // Initialise le mode ncurses.
    start_color();                 // Active la gestion des couleurs.
    cbreak();                      // Désactive la mise en tampon de ligne et désactive les touches Ctrl.
    noecho();                      // Désactive l'écho des caractères tapés par l'utilisateur.
    keypad(stdscr, TRUE);          // Active les touches spéciales (flèches, F-keys).
    
    // Définition des paires de couleurs (numéro, couleur du texte, couleur du fond)
    init_pair(1, COLOR_WHITE, COLOR_BLACK);
    init_pair(2, COLOR_WHITE, COLOR_BLUE);
    init_pair(3, COLOR_WHITE, COLOR_RED);
    
    // Création des fenêtres
    win_map = newwin(15, 60, 0, 0);
    win_help = newwin(4, 60, 16, 0);
    win_input = newwin(3, 60, 21, 0);
    
    // Bordures autour des fenêtres
    wborder(win_map, 0, 0, 0, 0, 0, 0, 0, 0);
    wborder(win_help, 0, 0, 0, 0, 0, 0, 0, 0);
    wborder(win_input, 0, 0, 0, 0, 0, 0, 0, 0);
    
    // Affichage des titres
    mvwprintw(win_map, 0, 2, " CARTE STATE.IO ");
    mvwprintw(win_help, 0, 2, " AIDE ");
    mvwprintw(win_input, 0, 2, " COMMANDES ");
    
    // Rafraichissement de l'affichage
    wrefresh(win_map);
    wrefresh(win_help);
    wrefresh(win_input);
}

// Nettoie l'environnement ncurses
void nettoyer_ncurses(void) {
    // Supprime les fenêtre
    if (win_map){
        delwin(win_map);
    }
    if (win_help){
        delwin(win_help);
    }
    if (win_input){
        delwin(win_input);
    }
    // Termine le mode ncurses
    endwin();
}

// Affiche la carte
void afficher_map(void) {
    // On protège les données grâce au mutex
    pthread_mutex_lock(&mutex_affichage);
    
    // On efface la fenetre de la carte puis on remet la bordure et le titre
    werase(win_map);
    wborder(win_map, 0, 0, 0, 0, 0, 0, 0, 0);
    mvwprintw(win_map, 0, 2, " CARTE STATE.IO "); 
    
    // Affichage des 10 territoires en 2 lignes de 5
    int ligne, colonne, i = 0;
    for (ligne = 0; ligne < 2; ligne++) {
        for (colonne = 0; colonne < 5; colonne++) {
            if (i < NB_TERRITOIRES) {
                int y = 2 + ligne * 6;
                int x = 2 + colonne * 11;

                // Assignation de la couleur selon le propriétaire
                int color_pair;
                char *nom_proprietaire;
                switch (territoires_affichage[i].proprietaire) {
                    case LIBRE:
                        color_pair = 1;
                        nom_proprietaire = "LIBRE";
                        break;
                    case JOUEUR_1:
                        color_pair = 2;
                        nom_proprietaire = "  J1 ";
                        break;
                    case JOUEUR_2:
                        color_pair = 3;
                        nom_proprietaire = "  J2 ";
                        break;
                    default:
                        color_pair = 1;
                        nom_proprietaire = "  ?? ";
                        break;
                }
                
                // Activation des paires de couleur
                wattron(win_map, COLOR_PAIR(color_pair));
                
                // Format d'affichage d'un territoire
                mvwprintw(win_map, y, x, "+-------+");
                mvwprintw(win_map, y+1, x, "|  T%02d  |", i);
                mvwprintw(win_map, y+2, x, "| %s |", nom_proprietaire);
                mvwprintw(win_map, y+3, x, "| %5d |", territoires_affichage[i].soldats);
                mvwprintw(win_map, y+4, x, "+-------+");
                
                // Désactivation des paires de couleur
                wattroff(win_map, COLOR_PAIR(color_pair));

                // On passe au territoire suivant en incrémentant l'indice de la boucle
                i++;
            }
        }
    }
    
    // On débloque le mutex et on raffraichit l'affichage
    pthread_mutex_unlock(&mutex_affichage);
    wrefresh(win_map);
}

// Affiche la fenêtre d'aide
void afficher_aide_ncurses(void) {

    // On efface la fenetre d'aide puis on remet la bordure et le titre
    werase(win_help);
    wborder(win_help, 0, 0, 0, 0, 0, 0, 0, 0);
    mvwprintw(win_help, 0, 2, " AIDE ");

    // Affichage des commandes disponibles
    mvwprintw(win_help, 1, 2, "m <source> <destination> - Deplacer les soldats");
    mvwprintw(win_help, 2, 2, "q - Quitter");
    
    // Rafraîchit l'affichage de l'aide
    wrefresh(win_help);
}

// Réception des messages envoyés par le serveur au client
void *thread_reception(void *arg) {
    (void)arg; // Permet d'enlever le warning de non utilisation de l'argument
    // Buffer pour stocker la ligne reçue du serveur
    char ligne[LIGNE_MAX]; 
    
    // On boucle sur le flag du jeu actif 
    while (jeu_actif) {
        // On essaye de lire une ligne du socket du serveur
        if (lire_ligne(socket_serveur, ligne) <= 0) {
            // On utilise le mutex et la fenêtre commande pour afficher l'erreur
            pthread_mutex_lock(&mutex_affichage);
            werase(win_input);
            wborder(win_input, 0, 0, 0, 0, 0, 0, 0, 0);
            mvwprintw(win_input, 1, 2, "Connexion perdue avec le serveur");
            wrefresh(win_input);
            pthread_mutex_unlock(&mutex_affichage);
            jeu_actif = 0; // On termine le jeu
            afficher_map();
            break;
        }
        // Si la ligne commence par "STATE:", il faut mettre à jour les territoires
        if (strncmp(ligne, "STATE:", 6) == 0) { 
            mettre_a_jour_territoires(ligne + 6);
            afficher_map();
        }
    }
    
    // On termine le thread
    pthread_exit(NULL);
}

// Mise à jour des territoires
void mettre_a_jour_territoires(char *etat) {
    // On protége les données des territoires affichés grâce au mutex
    pthread_mutex_lock(&mutex_affichage);
    
    // On découpe la chaîne d'états en tokens qui représentent chacun un territoire
    char *token = strtok(etat, ";"); 
    while (token != NULL) {
        int territoire, proprietaire, soldats;
        // Récupère les informations du token sous la forme teritoire,propriétaire,soldats et les stocke
        if (sscanf(token, "%d,%d,%d", &territoire, &proprietaire, &soldats) == 3) {
            if (territoire >= 0 && territoire < NB_TERRITOIRES) {
                // Mise à jour du propriétaire et du nombre de soldats
                territoires_affichage[territoire].proprietaire = proprietaire;
                territoires_affichage[territoire].soldats = soldats;
            }
        }
        // On passe à l'état suivant
        token = strtok(NULL, ";");
    }
    // Dévérouillage du mutex
    pthread_mutex_unlock(&mutex_affichage);
}

// Triatement des commandes
void traiter_entree_utilisateur(void) {
    // On utilise 2 buffers pour la ligne saisie et pour formater la commande
    char ligne[LIGNE_MAX];
    char commande[32]; 
    int source, destination;
    
    // Tant que le jeu est actif
    while (jeu_actif) {
        // On efface la zone de saisie
        werase(win_input);
        wborder(win_input, 0, 0, 0, 0, 0, 0, 0, 0);
        mvwprintw(win_input, 0, 2, " COMMANDES ");
        mvwprintw(win_input, 1, 2, "> ");
        wrefresh(win_input);
        
        // Activation de l'écho pour afficher ce qui est tapé
        echo();

        // Lecture de la commande
        mvwgetnstr(win_input, 1, 4, ligne, LIGNE_MAX - 1);

        // Désactivation de l'écho
        noecho();
        
        // Si la ligne est vide, on continue la boucle
        if (strlen(ligne) == 0) { 
            continue;
        }
        
        // Traitement des commandes :

        // Commande pour quitter
        if (strcmp(ligne, "quit") == 0 || strcmp(ligne, "q") == 0) { // Commande de quitter.
            jeu_actif = 0; // Met fin à la boucle principale.
            break;
        }
        // Commande de déplacement de sodats
        if (sscanf(ligne, "move %d %d", &source, &destination) == 2 || sscanf(ligne, "m %d %d", &source, &destination) == 2) {
            snprintf(commande, sizeof(commande), "MOVE %d %d", source, destination); // Formate la commande à envoyer au serveur.
            ecrire_ligne(socket_serveur, commande); // Envoie la commande "MOVE" au serveur.
            continue;
        }
        
        // Sinon, on afficher une erreur dans la zone de saisie
        werase(win_input);
        wborder(win_input, 0, 0, 0, 0, 0, 0, 0, 0);
        mvwprintw(win_input, 0, 2, " COMMANDES ");
        mvwprintw(win_input, 1, 2, "Commande inconnue. Regardez la fenêtre AIDE.");
        wrefresh(win_input);
        sleep(2); // Affiche le message d'erreur pendant 2 secondes.
    }
}

// Fonctions utilitaires pour la gestion des erreurs et lire/écrire les lignes

// Ces 2 premières fonctions permettent juste de formater l'affichage des erreurs et de gagner du temps
void erreur(const char *msg) {
    fprintf(stderr, "Erreur: %s", msg);
    exit(EXIT_FAILURE);
}

void perreur(const char *msg) {
    perror(msg);        // Affiche un message d'erreur système basé sur errno.
    exit(EXIT_FAILURE);
}

// Fonction pour envoyer les commandes au serveur
int ecrire_ligne(int socket, const char *ligne) {
    int len = strlen(ligne);
    // On écrit les données de la ligne sur le socket puis on va à la ligne
    if (write(socket, ligne, len) != len) { 
        return -1;
    }
    if (write(socket, "\n", 1) != 1) {
        return -1;
    }
    // Retourne le nombre de caractères écrits
    return len + 1;
}

// Lecture des lignes 
int lire_ligne(int socket, char *ligne) {
    int i = 0;
    char c;
    // On lit caractère par caractère jusqu'à la fin de ligne ou la taille maximale
    while (i < LIGNE_MAX - 1) { 
        if (read(socket, &c, 1) <= 0) {
            return -1;
        }
        // Si un caractère de nouvelle ligne est trouvé, on termine la ligne et on renvoie le nombre de caractères lus
        if (c == '\n') { 
            ligne[i] = '\0';
            return i;
        }
        // On stocke le caractère et on passe au suivant
        ligne[i] = c;
        i++;
    }
    // On s'assure que la ligne est toujours terminée par null
    ligne[i] = '\0'; 
    return i;
}