SUPER MASTERMIND EN MODE GRAPHIQUE

#include <allegro.h>
#include <time.h>

#define blanc  1
#define noir   2
#define rouge  3
#define jaune  4
#define vert   5
#define bleu   6
#define violet 7


////////////////////////////////////////////////////////////////////////////////
//                POUR LE MODE GRAPHIQUE                                        //
////////////////////////////////////////////////////////////////////////////////
BITMAP *buffer; // bitmap du buffer
BITMAP *mouse; // bitmap de la souris
BITMAP *accueil;  // bitmap de l'ecran d'accueil
BITMAP *image;  // bitmap de bob
BITMAP *bouton;  // bitmap du menu
BITMAP *master;
SAMPLE *clinck;  // son du click
DATAFILE *datafile;  // datafile
int t,d;
int WIDTH=640;
int HEIGHT=480;

/////////////////////////////////////
// pour le scrolling
BITMAP *bkground;
int new_y=0;
int xs=0,ys=0;
/////////////////////////////////////

int selec_bouton(int,int,int,int);
void message(char*);
void credits();

struct Point{
    int x;
    int y;
};

////////////////////////////////////////////////////////////////////////////////
//                            LA CLASSE CERCLE                                         //
////////////////////////////////////////////////////////////////////////////////
class Cercle{
    public:
        Point centre;
        int couleur;
        
        Cercle(Point,int);
        Cercle();
        ~Cercle();
};

Cercle::Cercle(Point centr,int col){
    centre=centr;
    couleur=col;
}
Cercle::Cercle(){
    Point p;
    p.x=0;p.y=0;
    Cercle(p,blanc);
}
Cercle::~Cercle(){}


////////////////////////////////////////////////////////////////////////////////
//                            LA CLASSE MASTERMIND                                 //
////////////////////////////////////////////////////////////////////////////////
class MasterMind{
    private:
        int y1;//haut du cercle
        int y2;//bas du cercle
        int tour;
        Cercle tab[9][5];//matrice des cercles du joueur
        Cercle ordi[5];//tableau des cercles dde l'ordi
        Cercle courant;//la couleur choisie
        Point res[9];//les resultats
        bool jeu_fini;
    public:   
        MasterMind();
        ~MasterMind();
        void jouer();
        void colorise();
        void colore(int,int,int,int,int,int);
        int traitement(Cercle jou[],int tr);
};
MasterMind master_cour;//master mind en cours

MasterMind::MasterMind()
{
    y1=67;
    y2=87;
    jeu_fini=false;
    tour=0;//premier tour
    
    Point p;
    //pour joueur
    p.x=37;p.y=77;
    for(int i=0; i<9; i++){
        for(int j=0; j<5; j++){
            tab[i][j]=Cercle(p,blanc);
            p.x+=40;
        }
        p.x=37;
        p.y+=35;
    }
    
    //pour ordi
    p.x=37;p.y=44;
    for(int i=0; i<5; i++){
        ordi[i]=Cercle(p,(rand()%5)+3);
        p.x+=40;
    }
    
    //couleur courante
    p.x=253;p.y=414;
    courant=Cercle(p,blanc);
    
    //met les resultats a 0
    for(int i=0;i<9;i++){
        res[i].x=0;
        res[i].y=0;
    }
}

MasterMind::~MasterMind(){
    for(int i=0;i<9;i++)
        delete[] tab[i];
    delete[] ordi;
    delete[] res;
}

// donne le nb de blanc et noirs
int MasterMind::traitement(Cercle jou[],int tr){
    int bc[5],bt[5];
    int pnoir=0,pblanc=0;
    int i,j;
    
    for(i=0;i<5;i++){
        bc[i]=0;
        bt[i]=0;
    }

    for(i=0;i<5;i++){
        if(jou[i].couleur==ordi[i].couleur)
            pnoir++;
    }
           
    if(pnoir!=5){                   //si on a pas trouve la combinaison
        for(i=0;i<5;i++){            //compte le nbre de chaque couleurs choisis
            if(jou[i].couleur==3) bc[0]++;
            if(jou[i].couleur==4) bc[1]++;
            if(jou[i].couleur==5) bc[2]++;
            if(jou[i].couleur==6) bc[3]++;
            if(jou[i].couleur==7) bc[4]++;
        }
        for(i=0;i<5;i++){            //pareil mais avec les couleurs de l'ordi
            if(ordi[i].couleur==3) bt[0]++;
            if(ordi[i].couleur==4) bt[1]++;
            if(ordi[i].couleur==5) bt[2]++;
            if(ordi[i].couleur==6) bt[3]++;
            if(ordi[i].couleur==7) bt[4]++;
        }
           
        for(i=0;i<5;i++)//boucle qui compare les couleurs
            if(bt[i]!=0 && bc[i]!=0)
                if(bt[i]>=bc[i]) pblanc=pblanc+bc[i];
                else pblanc=pblanc+bt[i];
               
        pblanc=pblanc-pnoir;
        res[tr].x=pblanc;
        res[tr].y=pnoir;
        return 0;
    }
    return 1;//gagne la partie
}

void MasterMind::colore(int x,int y,int r,int c1,int c2,int c3)
{
    circlefill(master,x,y,r,makecol(c1,c2,c3));
}

void MasterMind::colorise()
{
    //pour le joueur
    for(int i=0; i<9; i++)
        for(int j=0; j<5; j++)
            switch(tab[i][j].couleur){
                case blanc:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,255,255,255);
                    break;
                case noir:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,0,0,0);
                    break;
                case rouge:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,255,0,0);
                    break;
                case jaune:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,255,255,0);
                    break;
                case vert:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,0,255,0);
                    break;
                case bleu:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,0,0,255);
                    break;
                case violet:
                    colore(tab[i][j].centre.x,tab[i][j].centre.y,10,200,0,255);
                    break;
            }
            
    //pour l'ordi
    for(int i=0; i<5; i++)
        switch(ordi[i].couleur){
                case blanc:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,255,255,255);
                    break;
                case noir:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,0,0,0);
                    break;
                case rouge:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,255,0,0);
                    break;
                case jaune:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,255,255,0);
                    break;
                case vert:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,0,255,0);
                    break;
                case bleu:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,0,0,255);
                    break;
                case violet:
                    colore(ordi[i].centre.x,ordi[i].centre.y,10,200,0,255);
                    break;
            }
    //pour la couleur courante
    switch(courant.couleur){
            case blanc:
                colore(courant.centre.x,courant.centre.y,10,255,255,255);
                break;
            case noir:
                colore(courant.centre.x,courant.centre.y,10,0,0,0);
                break;
            case rouge:
                colore(courant.centre.x,courant.centre.y,10,255,0,0);
                break;
            case jaune:
                colore(courant.centre.x,courant.centre.y,10,255,255,0);
                break;
            case vert:
                colore(courant.centre.x,courant.centre.y,10,0,255,0);
                break;
            case bleu:
                colore(courant.centre.x,courant.centre.y,10,0,0,255);
                break;
            case violet:
                colore(courant.centre.x,courant.centre.y,10,200,0,255);
                break;
    }
    
    //pour les resultats
    int xb=tab[0][4].centre.x+35;
    int yb=tab[0][4].centre.y-4;
    for(int i=0;i<9;i++){
        for(int j=0;j<res[i].x;j++){//les blancs
            colore(xb+(j*10),yb,2,255,255,255);
        }
        for(int j=0;j<res[i].y;j++){//les noirs
            colore(xb+(j*10),yb+10,2,0,0,0);
        }
        yb+=35;
    }
    
    //cache les couleurs
    if(!jeu_fini){
        rectfill(master,25,32,208,56,makecol(0,0,0));
    }
}

void MasterMind::jouer()
{
    bool ligne_complete;
    int retour=0;
    while(retour==0){
        clear_bitmap(buffer);
        for(int y=0;y<=HEIGHT;y+=bkground->h)
            for(int x=0;x<=WIDTH;x+=bkground->w)//ici c pour la largeur
                blit(bkground,buffer,0,0,x,y,bkground->w,bkground->h);
        blit(bouton,buffer,100,150,350,300,100,20);//retour et valider
        blit(bouton,buffer,100,200,350,350,100,20);
        blit(master,buffer,0,0,0,0,master->w,master->h);
        show_mouse(buffer);//affiche la souris
        colorise();//colorise les couleurs
        
        // teste pour la couleur courante
        if(mouse_y>399 && mouse_y<430){
            if(mouse_x>36 && mouse_x<65)
                if(mouse_b & 1)
                    courant.couleur=rouge;
            if(mouse_x>75 && mouse_x<103)
                if(mouse_b & 1)
                    courant.couleur=jaune;
            if(mouse_x>112 && mouse_x<139)
                if(mouse_b & 1)
                    courant.couleur=vert;
            if(mouse_x>148 && mouse_x<175)
                if(mouse_b & 1)
                    courant.couleur=bleu;
            if(mouse_x>184 && mouse_x<210)
                if(mouse_b & 1)
                    courant.couleur=violet;
        }
        //teste pour le choix du joueur
        if(mouse_y>y1 && mouse_y<y2){
            if(mouse_x>27 && mouse_x<46)
                if(mouse_b & 1)
                    tab[tour][0].couleur=courant.couleur;
            if(mouse_x>67 && mouse_x<86)
                if(mouse_b & 1)
                    tab[tour][1].couleur=courant.couleur;
            if(mouse_x>107 && mouse_x<126)
                if(mouse_b & 1)
                    tab[tour][2].couleur=courant.couleur;
            if(mouse_x>147 && mouse_x<166)
                if(mouse_b & 1)
                    tab[tour][3].couleur=courant.couleur;
            if(mouse_x>187 && mouse_x<206)
                if(mouse_b & 1)
                    tab[tour][4].couleur=courant.couleur;
        }
        
        if(mouse_x>350 && mouse_x<450){
            if(mouse_y>300 && mouse_y<320){
                //verifie d'abord si la ligne est complete
                ligne_complete=true;
                for(int i=0;i<5;i++){
                    if(tab[tour][i].couleur==blanc){
                        ligne_complete=false;
                    }
                }
                rect(buffer,348,298,451,321,makecol(0,0,255));
                message("Pour valider son choix");
                if(ligne_complete && selec_bouton(350,300,450,320)){
                    if(traitement(tab[tour],tour)){//si on gagne
                        jeu_fini=true;
                    }
                    else{
                        tour++;
                        if(tour==9){//si on perd
                            jeu_fini=true;
                        }
                        else//on continue
                            y1+=35;y2+=35;
                    }
                }
            }
            if(mouse_y>350 && mouse_y<370){
                rect(buffer,348,348,451,371,makecol(0,0,255));
                message("retour au menu");
                if(selec_bouton(350,350,450,370)){
                    retour=1;
                }
            }
        }
        //affiche tout ce joli monde a l'ecran
        blit(buffer,screen,0,0,0,0,640,480);
        clear_keybuf();
    }
}


////////////////////////////////////////////////////////////////////////////////
//                        FONCTIONS UTILES                                            //
////////////////////////////////////////////////////////////////////////////////

void message(char *mess)
{
    textout(buffer,font,mess,10,460,makecol(255,255,255));
}

int selec_bouton(int r1,int r2,int r3,int r4)
{
    int test=0;
    //tant qu'on reste a clicker
    while(mouse_b & 1){
        test=1;
        if(mouse_x>r1 && mouse_x<r3 && mouse_y>r2 && mouse_y<r4)
            rect(buffer,r1-2,r2-2,r3+1,r4+1,makecol(255,255,255));
        else
            rect(buffer,r1-2,r2-2,r3+1,r4+1,makecol(0,0,255));
        blit(buffer,screen,0,0,0,0,640,480);   
        show_mouse(buffer);
    }
    //qd on relache le click
    if(test==1 && mouse_x>r1 && mouse_x<r3 && mouse_y>r2 && mouse_y<r4){
        play_sample(clinck,255,128,1000,0);
        return 1;
    }
    return 0;
}


////////////////////////////////////////////////////////////////////////////////
//                        FONCTIONS GRAPHIQUES                                   //
////////////////////////////////////////////////////////////////////////////////

void intro(){
    for(int i=0; i<2;i++){
        clear_bitmap(buffer);
        masked_blit(accueil,buffer,0,0,0,0,640,480);
        blit(buffer,screen,0,0,0,0,640,480);
        rest(10);
    }
    while(!key[KEY_ENTER]){
    }
    destroy_bitmap(accueil);
    clear_keybuf();
}

void scroll(int y){
    clear(buffer);
    for(ys=new_y;ys<=HEIGHT;ys+=bkground->h)
        for(xs=0;xs<=WIDTH;xs+=bkground->w)//ici c pour la largeur
            blit(bkground,buffer,0,0,xs,ys,bkground->w,bkground->h);
            
    for(xs=0;xs<=WIDTH;xs+=bkground->w)
        blit(bkground,buffer,0,(bkground->h-new_y),xs,0,bkground->w,new_y);
        
    if (new_y>=bkground->h)new_y=0;
    else new_y++;
    textout(buffer,font,"CREDITS",270,y,makecol(255,255,255));
    textout(buffer,font,"$kinia",270,y+50,makecol(255,255,255));
    textout(buffer,font,"quelques ressources par:",200,y+100,makecol(255,255,255));
    textout(buffer,font,"   OsM3K,AmK,goldeneye",200,y+120,makecol(255,255,255));
    blit(buffer,screen,0,0,0,0,WIDTH,HEIGHT);
}

void credits(){
    int y=150;
    while(!key[KEY_ENTER]){
        scroll(y);
        rest(10);
        show_mouse(NULL);
        blit(buffer,screen,0,0,0,0,640,480);
    }
    clear_keybuf();
}

void menu(){
    int exit=0;
    int premier_jeu=0;
    MasterMind M;
    master_cour=M;
    while(!exit){
         clear_bitmap(buffer);
         draw_sprite(buffer,image,0,0);
         blit(bouton,buffer,0,0,10,150,100,220);
         if(mouse_x>10 && mouse_x<110){
            //commencer une partie
            if(mouse_y>150 && mouse_y<170){
                  rect(buffer,8,148,111,171,makecol(0,0,255));
                  message("Commence une nouvelle partie");
                  if(selec_bouton(10,150,110,170)){
                        premier_jeu=1;
                        //detruit l'ancien master mind
                        M.~MasterMind();
                        destroy_bitmap(master);
                        //reconstruit un nouveau master mind
                        master=load_bitmap("data/master.pcx",NULL);
                        MasterMind M;
                        master_cour=M;
                        master_cour.jouer();
                  }
            }
            //retour jeu
            if(mouse_y>200 && mouse_y<220){
                  rect(buffer,8,198,111,221,makecol(0,0,255));
                  message("Retourne a la partie");
                  if(premier_jeu && selec_bouton(10,200,110,220))
                        master_cour.jouer();
            }
            //options
            if(mouse_y>250 && mouse_y<270){
                  rect(buffer,8,248,111,271,makecol(0,0,255));
                  message("Pas disponible");
            }
            //Credits
            if(mouse_y>300 && mouse_y<320){
                  rect(buffer,8,298,111,321,makecol(0,0,255));
                  message("Affiche les credits du jeu");
                  if(selec_bouton(10,300,110,320))
                        credits();
            }
            //quitter
            if(mouse_y>350 && mouse_y<370){
                  rect(buffer,8,348,111,371,makecol(0,0,255));
                  message("Quitte le jeu");
                  if(selec_bouton(10,350,110,370))
                        exit=1;
            }
         }
         clear_keybuf();
         show_mouse(buffer);
         // affiche buffer a l'ecran
         blit(buffer,screen,0,0,0,0,640,480);
    }
}



////////////////////////////////////////////////////////////////////////////////
//                        FONCTION PRINCIPALE                                       //
////////////////////////////////////////////////////////////////////////////////

int main(){
    // declaration et installation des choses necessaires //
    allegro_init();
    install_keyboard();
    install_mouse();
    install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,"pong");
    install_timer();
    set_color_depth(16);
    if(set_gfx_mode(GFX_AUTODETECT,640,480,0,0) < 0)
    {
        allegro_message("Ce programme ne peut etre initialise\n");
        exit(0);
    }
    // cree le buffer ecran //
    buffer=create_bitmap(WIDTH,HEIGHT);
////////////////////////////////////////////////////////////
    // met l'image ds le pointeur datafile //
    // chargement du .dat //
    /*datafile=load_datafile("data.dat");
    if(!datafile){
        allegro_message("Erreur lors du chargement du fichier data.dat\n");
        exit(0);
    }
    image=(BITMAP *)datafile[bob].dat;
    accueil=(BITMAP *)datafile[titre].dat;
    bouton=(BITMAP *)datafile[boutons].dat;
    master=(BITMAP *)datafile[masterm].dat;
    clinck=(SAMPLE *)datafile[click].dat;
    bkground=(BITMAP *)datafile[bckground].dat;*/
    
    image=load_bitmap("data/bob.pcx",NULL);
    accueil=load_bitmap("data/titre.pcx",NULL);
    bouton=load_bitmap("data/boutons.pcx",NULL);
    master=load_bitmap("data/master.pcx",NULL);
    clinck=load_sample("data/click.wav");
    bkground=load_bitmap("data/bkground.bmp",NULL);
////////////////////////////////////////////////////////////
	// dessine la souris //
	mouse=create_bitmap(12,12);
	//dessine le pointeur //
	clear_to_color(mouse,makecol(255,0,255));
	triangle(mouse,1,1,10,10,0,10,makecol(2,100,250));
	line(mouse,0,0,11,11,makecol(255,255,255));
	line(mouse,0,0,0,11,makecol(255,255,255));
	line(mouse,0,11,11,11,makecol(255,255,255));
    // met le dessin cree dans la souris //
    set_mouse_sprite(mouse);
    // le pt agissant de la souris est //
    set_mouse_sprite_focus(0,0);
    // definit la zone de la souris //
    set_mouse_range(0,0,640,480);
    //place la souris //
    position_mouse(320,240);
////////////////////////////////////////////////////////////
    t=50;d=75;
    text_mode(-1);//transparence du texte
    // appel de la fonction intro et menu //
    srand(time(0));
    intro();
    menu();
////////////////////////////////////////////////////////////
    // vide le tableau key[] //
    clear_keybuf();
    // etteint le sample //
    stop_sample(clinck);
    // detruit les bitmaps //
    destroy_bitmap(buffer);
    destroy_bitmap(master);
    destroy_bitmap(bouton);
    destroy_bitmap(image);
    allegro_exit();
}
END_OF_MAIN();