Super mastermind en mode graphique

Soyez le premier à donner votre avis sur cette source.

Vue 8 555 fois - Téléchargée 731 fois

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

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
74
Date d'inscription
dimanche 3 mars 2002
Statut
Membre
Dernière intervention
17 septembre 2006

il faut que tu ais un dossier data a coté de l'exe avec toutes les ressources à l'interieur : bob.pcx, boutons.pcx,...
sinon pas besoin de dlls ou de config particulières
si ca marche tjrs pas dis moi exactement ce que ca fait
Messages postés
627
Date d'inscription
mercredi 16 juin 2004
Statut
Membre
Dernière intervention
24 juillet 2011

Platage direct après le lancement de l'application....WIndows XP SP2, une idée ??
Messages postés
74
Date d'inscription
dimanche 3 mars 2002
Statut
Membre
Dernière intervention
17 septembre 2006

tu trouveras tout ce qu'il faut a www.allegro.cc
et ca marche aussi bien sous linux que sous windows
Messages postés
1
Date d'inscription
vendredi 5 novembre 2004
Statut
Membre
Dernière intervention
5 novembre 2004

Très intéressant.
Ou peut on trouver "allegro.h"?
C'est un utilitaire qui fonctionne uniquement avec windows ou fonctionne-t-il avec Linux également?

merci
Messages postés
231
Date d'inscription
vendredi 21 mars 2003
Statut
Membre
Dernière intervention
22 avril 2007

C fort joli !

Seul petit reproche, le jeu n'est pas terminé ^^ : Ya pas d'option !!! lol, et tu devrais faire différent niveau de jeu. Ensuite la souris scintille et laisse souvent des petites traces noires, c dommage.

A part ça, c sympas, continue comme ça!

++
Afficher les 7 commentaires

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.