old owrk done years ago

attrape.c

/**
    *   Projet 2 - Attrape-Sous
    *   BRISSET Dimitri & CLAVIE Baptiste
    *   L1 Promo 2012 - Groupe C
    *   Pour le 30/01/2008
*/

#include "conio.h"
#include <time.h>

/**
    *   Qqs defines...
*/
#define PION_JAUNE 0 // -- Constante pour un pion jaune
#define PION_ROUGE 1 // -- pour un pion rouge...
#define PION_NOIR 2 // -- pour un pion noir !
#define PION_NONE 3 // -- Constante pour pas de pions

#define SCORE_NONE 0 // -- Pas de points pour pas de pions :p
#define SCORE_JAUNE 1 // -- 1 point pour un pion jaune
#define SCORE_ROUGE 2 // -- 2 points pour un pion rouge
#define SCORE_NOIR 3 // -- 3 points pour un pion noir

#define HAUT -1 // -- D�placement vers le haut
#define DROITE 1 // -- D�placement vers la droite
#define BAS 1 // -- D�placement vers le bas
#define GAUCHE -1 // -- D�placement vers la gauche
#define ZERO 0 // -- Pas de mouvement

#define ABS 0 // -- Abscisse de d�placement
#define ORD 1 // -- Ordonn�e de d�placement

#define MAX_J 5 // -- Nombre de pixels par colonnes
#define MAX_I 4 // -- Nombres de pixels par lignes

#define J1 0 // -- Joueur 1
#define J2 1 // -- Joueur 2

#define TOTAL 3 // Score Total d'un joueur.

/**
    *   Qqs prototypes....
*/
void generation_damier(int curseurs[8][8]);
void stats(int tour, int score[2][4], int nb_pions[4]);
void actualisation(int curseurs[8][8], int tour, int score[2][4], int nb_pions[4]);
void rules();
void game();
void pause();

int no_possibilities(int curseurs[8][8], int pos[2]);
int game_over(int curseurs[8][8]);

int main(){
    int choix = 0;
    int result = 0;
    
    // -- Modification du titre de la fenetre
    system("title -- L'Attrape-Sous --");
    
    // -- Affichage du titre
    printf("-- L'Attrape-Sous --\n");
    printf("Par BRISSET Dimitri et CLAVIE Baptiste\n\n");
    
    printf("Menu Principal :\n");
    printf("\t1. Regles de Jeu\n");
    printf("\t2. Jeu\n\n");
    
    // -- Saisie s�curis�e !
    do {
        printf("Votre choix ? ");
        fflush(stdin);
        result = scanf("%ld", &choix);
    } while( result == 0 ); 
    
    if( choix == 1 ){
        system("cls");
        rules();
    }

    system("cls");
    game();
    
    gotoxy(MAX_J * 10, MAX_I * 10 + 12);
    printf("Merci d'avoir joue !\n\n");
    
    pause();
    
    return 0;
}

/**
    *   Le jeu en lui m�me
    *   @return void
*/
void game(){
    /**
        *   Quelques variables....
    */
    int curseurs[8][8] = {0}; // -- pions
    int points[4] = {SCORE_JAUNE, SCORE_ROUGE, SCORE_NOIR, SCORE_NOIR}; // -- Contient les score pour chaque pions.
    int nb_pions[4] = {34, 20, 10, 0}; // nbre de pions.
    int score[2][4] = {{0, 0, 0, 0}, {0, 0, 0, 0}}; // -- Score des joueurs
    
    int jeu_fini = 0; // -- Jeu Fini ?
    int tour_fini = 0; // - Tour actuel fini ?
    
    int alea = PION_NONE; // Type de pion pour la s�lection du d�but
    int tour = 1; // -- Tour actuel
    
    int result = 0; // -- Pour la saisie s�curis�e
    
    int pos[2]; // -- Les positions (case ou est actuellement le pion choisi par le joueur)
    int dir[2] = {0}; // -- Direction choisie (cases).
    
    int nb_coups = 0; // -- Nbre de coups / tour de joueurs
    int nb_tot_coups = 0; // -- Nbre de coups / tour
    
    int i,j; // cpts
    
    int *curseur = NULL; // -- Pointeur ref, qui pointe sur la case du curseur choisi.
    
    char saisie[3]; // -- Saisie de la localisation.
    
    // -- Initialisation du g�n�rateur al�atoire
    srand((unsigned) time(NULL));
    
    // -- On g�n�re l'emplacement des pions...
    for( i = 0; i < 8; i++ ){
        for( j = 0; j < 8; j++ ){
            // -- On fait un tirage entre 0 et le nombre de pions restants.
            alea = rand() % (nb_pions[PION_JAUNE] + nb_pions[PION_ROUGE] + nb_pions[PION_NOIR]);
            
            // -- Puis, en fonction du r�sultat, on titre une bonne couleur ("tirage pond�r�").
            if( alea < nb_pions[PION_JAUNE] ){
                alea = PION_JAUNE;
            }
            else if( alea < (nb_pions[PION_JAUNE] + nb_pions[PION_ROUGE]) ){
                alea = PION_ROUGE;
            }
            else{
                alea = PION_NOIR;
            }
        
            nb_pions[alea]--;
            
            curseurs[i][j] = alea;
        }
    }
    
    // -- On reremplit le tableau nb_pions
    nb_pions[0] = 34;
    nb_pions[1] = 20;
    nb_pions[2] = 10;
    nb_pions[3] = 0;
    
    for( i = 0; i < 2; i++ ){
        // -- G�n�ration du Damier, de la boite de stats
        actualisation(curseurs, tour, score, nb_pions);
        
        // -- Chaque joueurs enleve un pion jaune du damier.
        gotoxy(1, MAX_I * 10 + 2);
        printf("Enlevez un pion jaune du damier (par exemple : A1)\n\n");
        
        do {
            printf("J%ld : ", (i + 1));
            gets(saisie);
            
            // -- result vaut vrai ssi on a entr� un premier caract�re entre A et H, et un second entre 1 & 8, et si on a bien choisi un pion jaune
            result = ((saisie[0] >= 'A' && saisie[0] <= 'H') && (saisie[1] >= '1' && saisie[1] <= '8'));
            
            curseur = &curseurs[saisie[1] - '1'][saisie[0] - 'A'];
            result = result && ( *curseur == PION_JAUNE );
        } while( result == 0);
        
        // -- On �crase le pion qu'il y avait avant, et on "ajoute" un pion enlev�
        nb_pions[PION_JAUNE]--;
        nb_pions[PION_NONE]++;
        *curseur = PION_NONE;
    }
    
    // -- On boucle tant que jeu_fini (nombre total de coups "impossibles", soit pour chaque pion jaunes le tour se finit automatiquement) est pas �gal au nombre de pions jaunes pr�sents sur le terrain.
    do {
        // -- G�n�ration du Damier, de la boite de stats
        actualisation(curseurs, tour, score, nb_pions);
        
        nb_tot_coups = 0;
        
        gotoxy(1, MAX_I * 10 + 2);
        printf("Tour %ld\n\n", tour);
        
        i = 0;
        
        while( i < 2 && !jeu_fini ){
            nb_coups = 0;
        
            gotoxy(1, MAX_I * 10 + 2);
            printf("Tour %ld\n\n", tour);
            
            gotoxy(1, MAX_I * 10 + 4);
            printf("Joueur %ld\n", (i + 1));
            
            // -- Choix d'un pion de d�part
            do {
                printf("Choisissez un pion de depart : ");
                gets(saisie);
                
                // -- result vaut vrai ssi on a entr� un premier caract�re entre A et H, et un second entre 1 & 8, et si on a bien choisi un pion jaune
                result = ((saisie[0] >= 'A' && saisie[0] <= 'H') && (saisie[1] >= '1' && saisie[1] <= '8'));
                
                // -- On enregistre la position actuelle.
                pos[ABS] = saisie[0] - 'A';
                pos[ORD] = saisie[1] - '1';
                
                // -- On fait un pointeur (plus court...) vers le curseur actuel, puis on v�rifie si le pion choisi est bien jaune.
                curseur = &curseurs[pos[ORD]][pos[ABS]];
                result = result && ( *curseur == PION_JAUNE );
            } while( result == 0);
            
            // -- Le tour n'est pas fini avant d'avoir commenc�, sauf si y'a pas de possibilit�s....
            tour_fini = no_possibilities(curseurs, pos);
            
            while( !tour_fini ){
                gotoxy(1, MAX_I * 10 + 2);
                printf("Tour %ld", tour);
            
                gotoxy(1, MAX_I * 10 + 4);
                printf("Joueur %ld", (i + 1));
                
                gotoxy(1, MAX_I * 10 + 6);
                printf("Coup %ld", (nb_coups + 1));
                
                // -- On d�termine la position du texte de saisie
                gotoxy(1, MAX_I * 10 + 8);
                
                // - Tant que l'on a pas fait de saisies valide, on demande de choisir une case d'arriv�e.
                do {
                    printf("\nChoissisez votre case d'arrivee (vous etes sur la case %c%c) : ", (pos[ABS] + 'A'), (pos[ORD] + '1'));
                    gets(saisie);
                    
                    // -- Result vaut vrai ssi on a fait une bonne saisie, soit si on se dirige dans la bonne direction, si la saisie est OK,
                    result = ((saisie[0] >= 'A' && saisie[0] <= 'H') && (saisie[1] >= '1' && saisie[1] <= '8'));
                    
                    // -- On r�cup�re le direcion choisie.
                    dir[ABS] = (saisie[0] - 'A') - pos[ABS];
                    dir[ORD] = (saisie[1] - '1') - pos[ORD];
                    
                    // -- On v�rifie que dans la direction est valide.
                    result = result &&
                        (
                            dir[ORD] == (2 * HAUT) || 
                            dir[ORD] == (ZERO) || 
                            dir[ORD] == (2 * BAS)
                        ) && (
                            dir[ABS] == (2 * GAUCHE) || 
                            dir[ABS] == (ZERO) || 
                            dir[ABS] == (2 * DROITE)
                        );
                    
                    // -- Autre v�rification : on v�rifie si la case d'apr�s est libre, et que celle juste � cot� aussi.
                    result = result && 
                        (curseurs[saisie[1] - '1'][saisie[0] - 'A'] == PION_NONE) &&
                        (curseurs[pos[ORD] + dir[ORD] / 2][pos[ABS] + dir[ABS] / 2] != PION_NONE);
                        
                    // -- Derni�re v�rification (et pas des moindres) : on v�rifie que l'on a pas s�lectionn� le m^me pion...
                    result = result && !(dir[ABS] == 0 && dir[ORD] == 0);
                    
                } while( result == 0 );
                
                // -- On actualise les scores
                score[i][TOTAL] += points[curseurs[pos[ORD] + dir[ORD] / 2][pos[ABS] + dir[ABS] / 2]];
                score[i][curseurs[pos[ORD] + dir[ORD] / 2][pos[ABS] + dir[ABS] / 2]]++;
                nb_pions[curseurs[pos[ORD] + dir[ORD] / 2][pos[ABS] + dir[ABS] / 2]]--;
                nb_pions[PION_NONE]++;
                
                // -- On supprime le pion qui se trouvait sur le chemin, et celui qui se trouvait au point d'origine
                curseurs[pos[ORD] + dir[ORD] / 2][pos[ABS] + dir[ABS] / 2] = PION_NONE;
                curseurs[pos[ORD]][pos[ABS]] = PION_NONE;
                
                // -- Enfin, on remplace la destination par un pion jaune.
                curseurs[saisie[1] - '1'][saisie[0] - 'A'] = PION_JAUNE;
                
                // -- On actualise la position.
                pos[ABS] = saisie[0] - 'A';
                pos[ORD] = saisie[1] - '1';
                
                // -- On augmente le compte des coups jou�s.
                nb_coups++;
                
                // -- G�n�ration du Damier, de la boite de stats
                actualisation(curseurs, tour, score, nb_pions);
                
                // -- On d�termine si le tour et le jeu est fini.... 
                tour_fini = no_possibilities(curseurs, pos);
            }
            
            gotoxy(1, MAX_I * 10 + 4);
            printf("\nLe tour du joueur %ld est fini (%ld coups)\n", (i + 1), nb_coups);
            
            pause();
            
            // -- G�n�ration du Damier, de la boite de stats
            actualisation(curseurs, tour, score, nb_pions);
            
            nb_tot_coups += nb_coups;
            
            // -- Si le jeu est fini ou pas... ?
            jeu_fini = game_over(curseurs);
            
            // -- On incr�mente que si le jeu est pas fini.
            if( !jeu_fini ){
                i++;
            }
        }
        
        gotoxy(1, MAX_I * 10 +5);
        printf("Le tour %ld est maintenant fini (%ld coups joues) !\n\n", tour, nb_tot_coups);
        
        tour++;
        pause();
    } while( !jeu_fini );
    
    // -- G�n�ration du Damier, de la boite de stats
    actualisation(curseurs, tour, score, nb_pions);
    
    // -- Le jeu est fini ; on calcule le malus, on le retranche aux points de celui qui a jou� en dernier, et on affiche les scores finaux.
    gotoxy(MAX_J * 2, 10 * MAX_I + 2);
    printf("Le jeu est fini  !");
    
    gotoxy(MAX_J * 2, 10 * MAX_I + 4);
    printf("Calcul du malus...");
    
    // -- On soustrait le malus (points qu'on aurait du prendre...)
    score[i][TOTAL] -= ((SCORE_JAUNE * nb_pions[PION_JAUNE]) + (SCORE_ROUGE * nb_pions[PION_ROUGE]) + (SCORE_NOIR * nb_pions[PION_NOIR]));
    
    // -- Si n�gatif, alors on le met � 0.
    if( score[i][TOTAL] < 0 ){
        score[i][TOTAL] = 0;
    }
    
    printf(" Termine !");
    
    gotoxy(MAX_J * 2, 10 * MAX_I + 6);
    printf("Voici les scores finaux :\n");
    printf("\t\tJoueur 1 : %ld\n", score[J1][TOTAL]);
    printf("\t\tJoueur 2 : %ld", score[J2][TOTAL]);
    
    gotoxy(MAX_J * 3, 10 * MAX_I + 10);
    printf("Verdict : ");
    
    if( score[J1][TOTAL] == score[J2][TOTAL] ){
        printf("Egalite !");
    }
    else if( score[J1][TOTAL] > score[J2][TOTAL] ){
        printf("Le joueur 1 gagne !");
    }
    else {
        printf("Le joueur 2 gagne !");
    }
}

/**
    *   G�n�re le damier
    *   @param  array       curseurs    Array contenant les curseurs
    *   @return void
    *   @access public
*/
void generation_damier(int curseurs[8][8]){
    int i, j, k, l; // -- compteurs
    int colors[4] = {YELLOW, RED, BLACK, WHITE}; // -- Couleurs pour les pions
    
    char lettres[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
    
    printf("-- L'Attrape-Sous --\n");
    printf("Par BRISSET Dimitri et CLAVIE Baptiste\n\n");
    
    // -- G�n�ration des lettres de rep�rage
    for( j = 0; j < 8; j++ ){
        gotoxy(((MAX_J * (j + 1)) + 4), MAX_I + 2);
        printf("%c", lettres[j]);
    }
    
    for( i = 0; i < 8; i++ ){
        gotoxy(MAX_J, ((MAX_I * (i + 1)) + 6));
        printf("%ld", (i + 1));
    }
    
    textcolor(BLACK);
    textbackground(WHITE);
    for( i = 0; i < 8; i++ ){
        for( j = 0; j < 8; j++ ){
            gotoxy((MAX_J * (j + 1) + 2), ((i + 2) * MAX_I));
            printf("%c", 218);
            
            for( l = 0; l < (MAX_J - 2); l++ ){
                printf("%c", 196);
            }
            
            printf("%c", 191);
            
            for( k = 1; k <= (MAX_I - 1); k++ ){ 
                gotoxy((MAX_J * (j + 1) + 2), (((i + 2) * MAX_I) + k));
                printf("%c", 179);
                
                // -- Affichage d'espaces, pour le spions (au d�but)
                textbackground(colors[curseurs[i][j]]);
                for(l = 0; l < (MAX_J - 2); l++){
                    printf("%c", 32);
                }
                textbackground(WHITE);
                
                printf("%c", 179);
            }
            
            gotoxy((MAX_J * (j + 1) + 2), (((i + 2) * MAX_I) + (MAX_I - 1)));
            printf("%c", 192);
            
            for( l = 0; l < (MAX_J - 2); l++ ){
                printf("%c", 196);
            }
            
            printf("%c", 217);
        }       
    }
    
    textcolor(LIGHTGRAY);
    textbackground(BLACK);
}

/**
    *   G�n�re la boite de stats
    *   @param  integer tour        Num�ro de tour
    *   @param  array       score       Array contenant les scores
    *   @param  array       nb_pions    Array contenant le nombre et le score qui reste � se faire :)
    *   @return void
    *   @access public
*/
void stats(int tour, int score[2][4], int nb_pions[4]){
    const int SPACES_J = -2; // -- si on veut changer l'ecart entre le damier et les stats
    const int SPACES_I = MAX_I * 2 + (int)(MAX_I / 2) - 1; // -- si on veut changer l'ecart entre le haut et les stats
    
    int nb_points[3] = {SCORE_JAUNE * nb_pions[PION_JAUNE], SCORE_ROUGE * nb_pions[PION_ROUGE], SCORE_NOIR * nb_pions[PION_NOIR]};
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + SPACES_I);
    printf("Stats", tour);
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 2 + SPACES_I);
    printf("Nombre de tours joues : %ld", tour);
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 4 + SPACES_I);
    printf("Scores");
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 5 + SPACES_I);
    printf("Joueur 1 : %ld pts (", score[J1][TOTAL]);
    textcolor(YELLOW);
    printf("%ld", score[J1][PION_JAUNE]);
    textcolor(LIGHTGRAY);
    printf(" - ");
    textcolor(RED);
    printf("%ld", score[J1][PION_ROUGE]);
    textcolor(LIGHTGRAY);
    printf(" - %ld)", score[J1][PION_NOIR]);
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 6 + SPACES_I);
    printf("Joueur 2 : %ld pts (", score[J2][TOTAL]);
    textcolor(YELLOW);
    printf("%ld", score[J2][PION_JAUNE]);
    textcolor(LIGHTGRAY);
    printf(" - ");
    textcolor(RED);
    printf("%ld", score[J2][PION_ROUGE]);
    textcolor(LIGHTGRAY);
    printf(" - %ld)", score[J2][PION_NOIR]);
    
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 8 + SPACES_I);
    printf("Pions Restants");
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 9 + SPACES_I);
    printf("Jaunes : %ld (%ld pts)", nb_pions[PION_JAUNE], nb_points[PION_JAUNE]);
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 10 + SPACES_I);
    printf("Rouges : %ld (%ld pts)", nb_pions[PION_ROUGE], nb_points[PION_ROUGE]);
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 11 + SPACES_I);
    printf("Noirs : %ld (%ld pts)", nb_pions[PION_NOIR], nb_points[PION_NOIR]);
    gotoxy(MAX_J * 10 + SPACES_J, 2 * MAX_I + 12 + SPACES_I);
    printf("Pions Enleves : %ld (%ld pts)", nb_pions[PION_NONE], (104 - (nb_points[PION_JAUNE] + nb_points[PION_ROUGE] + nb_points[PION_NOIR])));
}

/**
    *   Regenere le damier et la boite de stats
    *   @param  integer curseurs    Les curseurs en cours d'utilisation
    *   @param  integer tour        Num�ro de tour
    *   @param  array       score       Array contenant les scores
    *   @param  array       nb_pions    Array contenant le nombre et le score qui reste � se faire :)
    *   @return void
    *   @access public
*/
void actualisation(int curseurs[8][8], int tour, int score[2][4], int nb_pions[4]){
    system("cls");
    generation_damier(curseurs);
    stats(tour, score, nb_pions);
}

/**
    *   Indique si un tour est fini
    *   @param  array       curseurs    Array contenant tous les curseurs du jeu
    *   @param  array       pos     Array contenant la position actuelle
    *   @return bool
    *   @access public
*/
int no_possibilities(int curseurs[8][8], int pos[2]){
    /*
        *    Condition de "tar�" ; 
        *
        *   On �value si il y a au moins un direction possible pour le pion selectione � la position pos, 
        *   c'est � dire si on est pas trop proches du damier (soit le carr� de 3 colonnes et 3 lignes apr�s le d�but du damier),
        *   et si il est possible de bouger dans cette direction (pion non vide � cot�, et pion vide juste apr�s). 
        *   Ceci pour les 8 directions possibles. 
        *
        *   On retourne vrai si y'a plus de possibilit�s, faux si y'en a encore.
    */
    return
        !(
            (
                ((pos[ORD] + HAUT) > 0) &&
                (curseurs[pos[ORD] + HAUT][pos[ABS] + ZERO] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * HAUT][pos[ABS] + ZERO] == PION_NONE)
            ) || (
                ((pos[ORD] + HAUT) > 0) &&
                ((pos[ABS] + DROITE) < 7) &&
                (curseurs[pos[ORD] + HAUT][pos[ABS] + DROITE] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * HAUT][pos[ABS] + 2 * DROITE] == PION_NONE)
            ) || (
                ((pos[ABS] + DROITE) < 7) &&
                (curseurs[pos[ORD] + ZERO][pos[ABS] + DROITE] != PION_NONE) &&
                (curseurs[pos[ORD] + ZERO][pos[ABS] + 2 * DROITE] == PION_NONE)
            ) || (
                ((pos[ORD] + BAS) < 7) &&
                ((pos[ABS] + DROITE) < 7) &&
                (curseurs[pos[ORD] + BAS][pos[ABS] + DROITE] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * BAS][pos[ABS] + 2 * DROITE] == PION_NONE)
            ) || (
                ((pos[ORD] + BAS) < 7) &&
                (curseurs[pos[ORD] + BAS][pos[ABS] + ZERO] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * BAS][pos[ABS] + ZERO] == PION_NONE)
            ) || (
                ((pos[ORD] + BAS) < 7) &&
                ((pos[ABS] + GAUCHE) > 0) &&
                (curseurs[pos[ORD] + BAS][pos[ABS] + GAUCHE] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * BAS][pos[ABS] + 2 * GAUCHE] == PION_NONE)
            ) || (
                ((pos[ABS] + GAUCHE) > 0) &&
                (curseurs[pos[ORD] + ZERO][pos[ABS] + GAUCHE] != PION_NONE) &&
                (curseurs[pos[ORD] + ZERO][pos[ABS] + 2 * GAUCHE] == PION_NONE)
            ) || (
                ((pos[ORD] + HAUT) > 0) &&
                ((pos[ABS] + GAUCHE) > 0) &&
                (curseurs[pos[ORD] + HAUT][pos[ABS] + GAUCHE] != PION_NONE) &&
                (curseurs[pos[ORD] + 2 * HAUT][pos[ABS] + 2 * GAUCHE] == PION_NONE)
            )
        );
}

/**
    *   Indique si le jeu est fini
    *   @param  int curseurs    Les curseurs
    *   @return int
*/
int game_over(int curseurs[8][8]){
    int pos[2] = {0}; // -- Positions
    int nb_pions = 0; // -- Nbre de pions jaunes.
    int i, j; // -- cpts
    int jeu_fini = 0;
    
    // -- Il suffit de voir si pour chaque pions jaunes trouv�s, il y a ou non une possibilit� de jeu. Si y'en a pas, on incr�mente jeu_fini de 1. Sinon, on fait rien.
    for( i = 0; i < 8; i++ ){
        for( j = 0; j < 8; j++ ){
            if( curseurs[i][j] == PION_JAUNE ){
                pos[ORD] = i;
                pos[ABS] = j;
                
                jeu_fini += no_possibilities(curseurs, pos);
                
                nb_pions++;
            }
        }
    }
    
    // -- On r�duit jeu_fini � une expression ; si il y a autant de coups injouables que de pions jaunes, le jeu est fini.
    jeu_fini = (jeu_fini == nb_pions);
    
    return jeu_fini;
}

/**
    *   Affiche les r�gles du jeu
    *   @return void
*/
void rules(){
    gotoxy(1, 1);
    printf("-- L'Attrape-Sous --\n");
    printf("Par BRISSET Dimitri et CLAVIE Baptiste\n\n");
    
    printf("Regles du Jeu \n\n");
    
    printf("1. Presentation du Jeu, But du Jeu\n");
    printf("\tL'Attrape-Sous est un jeu de plateau pour deux joueurs uniquement qui se deroule sur un plateau de 8x8 cases. Il y a donc 64 pions, repartis de la maniere suivante : 34 pions ");
    textcolor(YELLOW);
    printf("jaunes");
    textcolor(LIGHTGRAY);
    printf(", 20 pions ");
    textcolor(RED);
    printf("rouges");
    textcolor(LIGHTGRAY);
    printf(", et 10 pions noirs.\n");
    printf("\tLe but du jeu est de ramasser, en valeur, plus de points que son adversaire.\n\n");
    
    pause();
    
    printf("2. Valeurs des Pions\n");
    printf("\tVoici la valeur pour chaque pions ramasses...\n");
    textcolor(YELLOW);
    printf("\t\t Jaunes");
    textcolor(LIGHTGRAY);
    printf(" :: 1 point\n");
    textcolor(RED);
    printf("\t\t Rouges");
    textcolor(LIGHTGRAY);
    printf(" :: 2 points\n");
    printf("\t\t Noirs :: 3 points\n\n");
    
    pause();
    
    printf("3. Demarrage de la partie\n");
    printf("\t Les 64 pions sont aleatoirement repartis sur le plateau de jeu, puis, chaque joueurs retire chacuns un pion ");
    textcolor(YELLOW);
    printf("jaune ");
    textcolor(LIGHTGRAY);
    printf("du plateau.\n\n");
    
    pause();
    
    printf("4. Deroulement de la partie\n");
    printf("\tA son tout de jeu, le joueur choisit un pion ");
    textcolor(YELLOW);
    printf("jaune ");
    textcolor(LIGHTGRAY);
    printf("comme pion de depart, et effectue autant de saut que possible en deplacant ce pion. Lorsque plusieurs deplacements sont possibles, le joueur dont c'est le tour choisit le deplacement qu'il veut.\n\n");
    
    pause();
    
    printf("5. Regles de Saut\n");
    printf("\t\t A. Un pion ");
    textcolor(YELLOW);
    printf("jaune ");
    textcolor(LIGHTGRAY);
    printf("peut sauter un pion de n'importe quelle couleur si la case situee derriere ce pion dans le sens du deplacement est libre ;\n");
    printf("\t\t B. Les sauts sont possibles dans n'importe quelle direction (diagonales incluses).\n");
    printf("\t\t C. Un pion ");
    textcolor(YELLOW);
    printf("jaune ");
    textcolor(LIGHTGRAY);
    printf("ne peut sauter plusieurs pions a la fois.\n");
    printf("\tTous les pions ainsi sautes sont retires du plateau de jeu, et le joueur dont c'est le tour marque autant de points que la valeur des pions retires.\n\n");
    
    pause();
    
    printf("6. Fin de jeu\n");
    printf("\tLorsque plus aucuns deplacement n'est possible, la partie s'arrete. Chaque joueur compte alors le nombre de points qu'il a accumule jusqu'a present. On compte ensuite le nombre de points correspondants aux pions restants sur le plateau, ce qui donne un malus M. Ce malus M est applique au joueur qui a joue le dernier.\n\n");
    
    pause();
}

/**
    *   Emule system("pause");
*/
void pause(){
    printf("Appuyez sur une touche pour continuer...\n\n");
    while( !kbhit() );
    getch();
}

conio.c

/* A conio implementation for Mingw/Dev-C++.
 *
 * Written by:
 * Hongli Lai <hongli@telekabel.nl>
 * tkorrovi <tkorrovi@altavista.net> on 2002/02/26. 
 * Andrew Westcott <ajwestco@users.sourceforge.net>
 *
 * Offered for use in the public domain without any warranty.
 */

#ifndef _CONIO_C_
#define _CONIO_C_

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <windows.h>
#include <string.h>
#include "conio.h"

#ifdef __cplusplus
extern "C" {
#endif

static int __BACKGROUND = BLACK;
static int __FOREGROUND = LIGHTGRAY;


void
clrscr ()
{
    DWORD written;

    FillConsoleOutputAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
      __FOREGROUND + (__BACKGROUND << 4), 2000, (COORD) {0, 0},
      &written);
      FillConsoleOutputCharacter (GetStdHandle
      (STD_OUTPUT_HANDLE), ' ',
      2000, (COORD) {0, 0}, &written);
    gotoxy (1, 1);
}


void
clreol ()
{
    COORD coord;
    DWORD written;
    CONSOLE_SCREEN_BUFFER_INFO info;

    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE),
      &info);
    coord.X = info.dwCursorPosition.X;
    coord.Y = info.dwCursorPosition.Y;

    FillConsoleOutputCharacter (GetStdHandle (STD_OUTPUT_HANDLE),
      ' ', info.dwSize.X - info.dwCursorPosition.X, coord, &written);
    gotoxy (coord.X, coord.Y);
}


void
delline()
{
    COORD coord;
    DWORD written;
    CONSOLE_SCREEN_BUFFER_INFO info;

    GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE),
      &info);
    coord.X = info.dwCursorPosition.X;
    coord.Y = info.dwCursorPosition.Y;

    FillConsoleOutputCharacter (GetStdHandle (STD_OUTPUT_HANDLE),
      ' ', info.dwSize.X * info.dwCursorPosition.Y, coord, &written);
    gotoxy (info.dwCursorPosition.X + 1,
    info.dwCursorPosition.Y + 1);
}


int
_conio_gettext (int left, int top, int right, int bottom,
  char *str)
{
    int i, j, n;
    SMALL_RECT r;
    CHAR_INFO buffer[25][80];

    r = (SMALL_RECT) {left - 1, top - 1, right - 1, bottom - 1};
    ReadConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
      (PCHAR_INFO) buffer, (COORD) {80, 25}, (COORD) {0, 0}, &r);

    lstrcpy (str, "");
    for (i = n = 0; i <= bottom - top; i++)
    for (j = 0; j <= right - left; j++)
    {
        str[n] = buffer[i][j].Char.AsciiChar;
        n++;
    }
    str[n] = 0;
    return 1;
}


void
gotoxy(int x, int y)
{
  COORD c;

  c.X = x - 1;
  c.Y = y - 1;
  SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c);
}


void
puttext (int left, int top, int right, int bottom, char *str)
{ 
    int i, j, n;
    SMALL_RECT r;
    CHAR_INFO buffer[25][80];

    memset (buffer, 0, sizeof (buffer));
    r = (SMALL_RECT) {left - 1, top - 1, right - 1, bottom - 1};

    for (i = n = 0; i <= bottom - top; i++)
    for (j = 0; j <= right - left && str[n] != 0; j++)
    {
        buffer[i][j].Char.AsciiChar = str[n];
        buffer[i][j].Attributes = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
        n++;
    }

    WriteConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
      (CHAR_INFO *) buffer, (COORD) {80, 25},
      (COORD) {0, 0}, &r);
}


void
_setcursortype (int type)
{
    CONSOLE_CURSOR_INFO Info;

    Info.dwSize = type;
    SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
      &Info);
}


void
textattr (int _attr)
{
    SetConsoleTextAttribute (GetStdHandle(STD_OUTPUT_HANDLE), _attr);
}


void
textbackground (int color)
{
    __BACKGROUND = color;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
      __FOREGROUND + (color << 4));
}


void
textcolor (int color)
{
    __FOREGROUND = color;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
      color + (__BACKGROUND << 4));
}


int
wherex ()
{
    CONSOLE_SCREEN_BUFFER_INFO info;

    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    return info.dwCursorPosition.X + 1;
}


int
wherey ()
{
    CONSOLE_SCREEN_BUFFER_INFO info;

    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    return info.dwCursorPosition.Y + 1;
}


#ifdef __cplusplus
}
#endif

#endif /* _CONIO_C_ */

conio.h

/* A conio implementation for Mingw/Dev-C++.
 *
 * Written by:
 * Hongli Lai <hongli@telekabel.nl>
 * tkorrovi <tkorrovi@altavista.net> on 2002/02/26. 
 * Andrew Westcott <ajwestco@users.sourceforge.net>
 *
 * Offered for use in the public domain without any warranty.
 */

#ifndef _CONIO_H_
#define _CONIO_H_


#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define BLINK 0

typedef enum
{
    BLACK,
    BLUE,
    GREEN,
    CYAN,
    RED,
    MAGENTA,
    BROWN,
    LIGHTGRAY,
    DARKGRAY,
    LIGHTBLUE,
    LIGHTGREEN,
    LIGHTCYAN,
    LIGHTRED,
    LIGHTMAGENTA,
    YELLOW,
    WHITE
} COLORS;


#define cgets	_cgets
#define cprintf	_cprintf
#define cputs	_cputs
#define cscanf	_cscanf
#define ScreenClear clrscr

/* blinkvideo */

void clreol (void);
void clrscr (void);

int _conio_gettext (int left, int top, int right, int bottom,
                    char *str);
/* _conio_kbhit */

void delline (void);

/* gettextinfo */
void gotoxy(int x, int y);
/*
highvideo
insline
intensevideo
lowvideo
movetext
normvideo
*/

void puttext (int left, int top, int right, int bottom, char *str);

// Screen Variables

/* ScreenCols
ScreenGetChar
ScreenGetCursor
ScreenMode
ScreenPutChar
ScreenPutString
ScreenRetrieve
ScreenRows
ScreenSetCursor
ScreenUpdate
ScreenUpdateLine
ScreenVisualBell
_set_screen_lines */

void _setcursortype (int type);

void textattr (int _attr);

void textbackground (int color);

void textcolor (int color);

/* textmode */

int wherex (void);

int wherey (void);

/* window */



/*  The code below was part of Mingw's conio.h  */
/*
 * conio.h
 *
 * Low level console I/O functions. Pretty please try to use the ANSI
 * standard ones if you are writing new code.
 *
 * This file is part of the Mingw32 package.
 *
 * Contributors:
 *  Created by Colin Peters <colin@bird.fu.is.saga-u.ac.jp>
 *
 *  THIS SOFTWARE IS NOT COPYRIGHTED
 *
 *  This source code is offered for use in the public domain. You may
 *  use, modify or distribute it freely.
 *
 *  This code is distributed in the hope that it will be useful but
 *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
 *  DISCLAMED. This includes but is not limited to warranties of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * $Revision: 1.4 $
 * $Author: hongli $
 * $Date: 2002/04/26 19:31:25 $
 *
 */

char*	_cgets (char*);
int	_cprintf (const char*, ...);
int	_cputs (const char*);
int	_cscanf (char*, ...);

int	_getch (void);
int	_getche (void);
int	_kbhit (void);
int	_putch (int);
int	_ungetch (int);


int	getch (void);
int	getche (void);
int	kbhit (void);
int	putch (int);
int	ungetch (int);


#ifdef __cplusplus
}
#endif

#endif /* _CONIO_H_ */