Super mastermind en mode graphique

Télécharger le projet
Commenter

Description

compilé avec dev c++ et allegro
sans me vanter il estpas trop mal
sans bugs, si vous en trouvez dites le

Source / Exemple : 


#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();

Conclusion :


donnez vos commentaires svp
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (skinia)