PUZZLE

#include<string.h>
#include<stdlib.h>
#include<iostream.h>
#include<dos.h>
#include"raouf1.h"
#include"mouse.h"
#include<graphics.h>
			

# define fh 72
# define fb 80
# define fd 77
# define fg 75
# define fh 72

 t_screen splay;


 class puzzle
  {
 public:

    puzzle(int);//constructeur


    void permute(int,int,int,int) ;     //permute mat images
    void permute_int(int,int,int,int) ; //permute mat entiers
    void alea();          //
    int Test();
    void permut_possible();

    void Modifier_X(int);       //controler le nombre de permutation
    void Charge_Bmp();          //charger une nouvelle image
    void affiche();
    private:
	 t_image M[3][3];

	 int t2[3][3],x;
  };
//''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
      class Stage
	{public:
		Stage(int level);
		void Intro();             //introduction
		int booleen(){return bool;}     //bool= 1 quand satrt est selectionner
		void mod_bool(int n){bool=n;}



	private:
		int level,bool;unsigned char  result;
	   };
//.......................................................................
Stage::Stage(int)
{
    INIT_MOUSE();


    AFFICHE_MOUSE();
    int port =0x21;


}
//.....................................................................

void Stage::Intro()
{
 cleardevice();
 t_image raf;
 LoadImage(&splay, "raouf.bmp", &raf);           //chargement bmp1
 gotoxy(0,0);printf("PUZZLE");
 for (int i2=0;i2<=80;i2++)
  for (int j2=0;j2<=15;j2++)
  {
    setcolor(j2);
    setfillstyle(1,j2);
    if (getpixel(i2,j2)!=BLACK) {putpixel(i2,j2,0);pieslice(i2*8+120,j2*8+30,0,360,2);}

  }
 AFFICHE_MOUSE();


 SetPalette(&splay, &raf.ihHeader);
 DisplayImage(&splay, &raf,200,260,0);
 delay(100);


int bab=1;
while(bab)

 {


  POS_MOUSE(1);
  result=inportb(0x21);
  outportb(0x20,0x0a);
  result=inportb(0x20);
  outportb(0x20,0x0b);
  result=inportb(0x20);

  if(result!=0)
  {
  }



   if((x>240) && (x<380)&&(y>260) && (y<280)&&(etat==1)) {MASQUE_MOUSE();cleardevice();bab=0;bool=1;goto et;}
   if((x>240) && (x<380)&&(y>325) && (y<350)&&(etat==1)) {cleardevice();bab=0;bool=0;goto et;}
 DisplayImage(&splay, &raf,200,260,0);
 }
 et:

  DestroyImage(&raf);                     //destruction


 }

//========================================================================
  puzzle::puzzle(int x1){

	      x=x1;
	      LoadImage(&splay, "d1.bmp", &M[0][0]);
	      LoadImage(&splay, "d2.bmp", &M[0][1]);
	      LoadImage(&splay, "d3.bmp", &M[0][2]);
	      LoadImage(&splay, "d4.bmp", &M[1][0]);
	      LoadImage(&splay, "d5.bmp", &M[1][1]);
	      LoadImage(&splay, "d6.bmp", &M[1][2]);
	      LoadImage(&splay, "d7.bmp", &M[2][0]);
	      LoadImage(&splay, "d8.bmp", &M[2][1]);
	      LoadImage(&splay, "d9.bmp", &M[2][2]);



		 int cpt=0;                         //matrice des entiers
						    //ordonne de 0 a 8
						    // qui sert a tester..
		 for(int h=0;h<3;h++)
		  {  for (int j=0;j<3;j++)
		     { t2[h][j]=cpt;
		      cpt+=1;
		      }
		   }
		   t2[0][2]=2;

  }
//----------------------------------------------------------------------
void puzzle::Modifier_X(int x1)
{
x=x1;
}
 //========================================================================


int puzzle::Test()
{
int vrai=1;
int j,h=0;
int cpt=0;
   while((vrai)&&(h<3))
       { j=0;
	while((vrai)&&(j<3))
		 {if (t2[h][j] != cpt) vrai=0;

		  j+=1;
		  cpt+=1;
		 }
       h+=1;  }
return vrai;
}
//========================================================================







void puzzle::permute(int a,int b,int e,int f)     //adrresse
{ t_image c;
c=M[a][b];
M[a][b]=M[e][f];
M[e][f]=c;

}
void puzzle::permute_int(int a,int b,int e,int f)     //adrresse
{ int c;
c=t2[a][b];
t2[a][b]=t2[e][f];
t2[e][f]=c;

}

//=============================================================================
void puzzle::permut_possible()

{
int E,F;
E=0;F=0;
t_image win,lose;
LoadImage(&splay, "looser.bmp", &lose);
	      SetPalette(&splay,&lose.ihHeader);
	      LoadImage(&splay, "winner.bmp", &win);

  char choix;
    for(int i=0;i<3;i++)
       for(int j=0;j<3;j++)
	 if(t2[i][j]==2) {E=i;F=j;}
  int lin,col;
  if (F==0) col=200;
  if (F==1) col=290;
  if (F==2) col=380;
  if (E==0) lin=110;
  if (E==1) lin=200;
  if (E==2) lin=290;
  setfillstyle(1,6);
  setcolor(6);

  while(choix!='x')
  {

    choix=getch();

    switch(choix)
     {
	case fb:  if(E!=2){DisplayImage(&splay, &M[E][F],col,lin+90,0);

		  DisplayImage(&splay, &M[E+1][F],col,lin,0);
		  lin+=90;
		  permute(E,F,E+1,F);
		  permute_int(E,F,E+1,F);
		  E+=1;




		  break; }

	case fg:  if(F!=0){ DisplayImage(&splay, &M[E][F],col-90,lin,0);

		  DisplayImage(&splay, &M[E][F-1],col,lin,0);
		  col-=90;
		  permute(E,F,E,F-1);
		  permute_int(E,F,E,F-1);
		  F-=1;

		  }

		  break;
       case fh: if(E!=0){

		  DisplayImage(&splay, &M[E][F],col,lin-90,0);

		  DisplayImage(&splay, &M[E-1][F],col,lin,0);
		  lin-=90;
		  permute(E,F,E-1,F);
		  permute_int(E,F,E-1,F);
		  E-=1;

		  break;   }
      case fd:    if (F!=2){DisplayImage(&splay, &M[E][F],col+90,lin,0);
		 //  bar3d(col+90,lin,col+180,lin+90,0,0);
		  DisplayImage(&splay, &M[E][F+1],col,lin,0);
		  col+=90;
		  permute(E,F,E,F+1);
		  permute_int(E,F,E,F+1);
		  F+=1;

		  }


		  break;
    }
/* gotoxy(1,1);printf("MAT :\n");                 //affiche mat entiers
     for(int i=0;i<3;i++)
    {
       for (int j=0;j<3;j++)
	 {printf("  %d",t2[i][j]);}
	 printf("\n");
      }*/



 }
  //  cleardevice();

  if(Test()==0) {DisplayImage(&splay, &lose,0,0,0);}
  else  {DisplayImage(&splay, &win,0,0,0);}



 for (int i2=0;i2<=60;i2++)
  for (int j2=0;j2<=16;j2++)
  {
    setcolor(j2);
    setfillstyle(1,j2);
    if (getpixel(i2,j2)!=BLACK) {putpixel(i2,j2,0);pieslice(i2*8+160,j2*8+1,0,360,5);}

  }

}

//===========================================================
void puzzle::alea()

{
int E,F;
E=0;F=0;
t2[0][2]=2;
  char choix;
    for(int i=0;i<3;i++)
       for(int j=0;j<3;j++)
	 if(t2[i][j]==2) {E=i;F=j;}
  int lin,col;
  if (F==0) col=200;
  if (F==1) col=290;
  if (F==2) col=380;
  if (E==0) lin=110;
  if (E==1) lin=200;
  if (E==2) lin=290;
  setfillstyle(1,0);
  setcolor(9);
  int c;
  for(int i1=1;i1<x;i1++)
  {

    c=rand()%4;

    switch(c)
     {
       case 0: if(E!=2){DisplayImage(&splay, &M[E][F],col,lin+90,0);

		  DisplayImage(&splay, &M[E+1][F],col,lin,0);
		  lin+=90;
		  permute(E,F,E+1,F);
		  permute_int(E,F,E+1,F);
		   E+=1;




		  break; }

       case 1:  if(F!=0){ DisplayImage(&splay, &M[E][F],col-90,lin,0);
      // bar3d(col-90,lin,col-180,lin+90,0,0);
		  DisplayImage(&splay, &M[E][F-1],col,lin,0);
		  col-=90;
		  permute(E,F,E,F-1);
		  permute_int(E,F,E,F-1);
		  F-=1;

		  }

		  break;
       case 2: if(E!=0){

		  DisplayImage(&splay, &M[E][F],col,lin-90,0);
		  //bar3d(col,lin-90,col,lin,0,0);
		  DisplayImage(&splay, &M[E-1][F],col,lin,0);
		  lin-=90;
		  permute(E,F,E-1,F);
		  permute_int(E,F,E-1,F);
		  E-=1;

		  break;   }
      case 3:    if (F!=2){DisplayImage(&splay, &M[E][F],col+90,lin,0);
		    //  bar3d(col+90,lin,col+180,lin+90,0,0);
		  DisplayImage(&splay, &M[E][F+1],col,lin,0);
		  col+=90;
		  permute(E,F,E,F+1);
		  permute_int(E,F,E,F+1);
		  F+=1;




		  break;}
     default:  break;
    }
   /* gotoxy(1,1);printf("MAT :\n");         // afiche mat  entiers
     for(int i=0;i<3;i++)
    {
       for (int j=0;j<3;j++)
	 {printf("  %d",t2[i][j]);}
	 printf("\n");
      }*/

    delay(150);
 }
}








//=======================================================================
void puzzle::affiche()
{  cleardevice();

   SetPalette  (&splay, &M[0][0].ihHeader);
   DisplayImage(&splay, &M[0][0],200,110,0);
   DisplayImage(&splay, &M[0][1],290,110,0);
   DisplayImage(&splay, &M[0][2],380,110,0);
   DisplayImage(&splay, &M[1][0],200,200,0);
   DisplayImage(&splay, &M[1][1],290,200,0);
   DisplayImage(&splay, &M[1][2],380,200,0);
   DisplayImage(&splay, &M[2][0],200,290,0);
   DisplayImage(&splay, &M[2][1],290,290,0);
   DisplayImage(&splay, &M[2][2],380,290,0);
 }
//========================================================================





void main()
{
     InitGraphics(&splay);
     cleardevice();


     Stage s(1);
     int bool=1;
s.Intro();
cleardevice();
puzzle puz(20);
if (s.booleen())
  {



	    puz.affiche();
	    cleardevice();
	    setcolor(6);
	    rectangle(200,110,470,380);
	    rectangle(200,110,470,200);
	    rectangle(200,200,470,290);
	    rectangle(200,290,470,380);
	    rectangle(200,110,290,380);
	    rectangle(290,110,380,380);
	    rectangle(380,110,470,380);
	    puz.affiche();
	    puz.alea();
	    puz.permut_possible();


   }

getch();



}