Jeu a la chasse au lapin

Soyez le premier à donner votre avis sur cette source.

Vue 22 425 fois - Téléchargée 257 fois

Description

c'est un jeu vous devez placer des miroirs en indiquant les coordonee x et y pour devier un jet d'eau qui sort en haut a gauche en x1 y1 et orienter le miroir soit avec / soit \
le jet ne peux revenir sur lui-meme ni toucher les bord qui est une barriere electrique ni z, doit sortir obligatoirement en bas a droite le lapin est representé par W, le but c'est de pousser le lapin hors du jardin en prenant le moins de point possible
BON JEU

Source / Exemple :


#include <iostream>
using namespace std;

const int m=6,							//declaration de constantes
		  n=7,
		  p=3;

void affichage (char matrice[m][n])				//fonction de type void permettant l'affichage de
{												//matrice m*n la matrice m*n etant un parametre 
	for (int etoile=0; etoile<2*n+1; etoile++)		
		cout<<"*";
	cout<<endl;
	cout<<" ";
	for (int ligne=0; ligne<m ; ligne++)
	{		
		for (int colonne=0; colonne<n ; colonne++)
		{	
			cout<<matrice [ligne][colonne];
			if(colonne!=n-1)
				cout<<" ";
		}
		if (ligne!=m-1)
		{
			cout<<"*"<<endl;
			cout<<"*";
		}
	}
	cout<<endl;
	for (int etoile2=0; etoile2<2*n+1; etoile2++)
		cout<<"*";
	cout<<endl;
}

void deviation_jet (int &direction, int &coord_jet_y, int &coord_jet_x, char orientation_mir)
{										//fonction de type void servant a devier le jet d'eau
    if (orientation_mir==47)			//en fct de la direction du jet et de l'orientation
        switch (direction)				//du miroir, 47 en ASCII representant / 
        {
            case 1: direction=4;				    
                    coord_jet_y--;
                    break;
            case 2: direction=3;
                    coord_jet_x--;
                    break;
            case 3: direction=2;
                    coord_jet_y++;
                    break;
            case 4: direction=1;
                    coord_jet_x++;
                    break;
        }
    else 
         switch (direction)
        {
            case 1: direction=2;
                    coord_jet_y++;
                    break;
            case 2: direction=1;
                    coord_jet_x++;
                    break;
            case 3: direction=4;
                    coord_jet_y--;
                    break;
            case 4: direction=3;
                    coord_jet_x--;
                    break;
        } 
}

int compteur_de_point_negatif (char element_x_y,int &score)		//fct de type int servant a compter 
{									//les points negatifs element_x_y etant passe par valeur
	score -= element_x_y-'0';		//et score par reference. Apres avoir fait la soustraction 
	return(score);					//du score et element_x_y cad la valeur de la case 
}									//il retourne au module appelant la valeur de la variable score

bool est_ce_que_score_doit_valoir_moins_1000 (int coord_jet_x, int coord_jet_y,char element_x_y)
{											//fct de type bool cette fct sert a savoir si le score 
	bool renvoi_moins_1000=false;				//doit valoir -1000 cad que le jet touche Z ou une 
	if(element_x_y=='Z')						//autre barriere electrique ou que le jet revient sur  
		renvoi_moins_1000=true;					//lui meme
	else if (coord_jet_y>=m)
		renvoi_moins_1000=true;
	else if (coord_jet_x>=n && coord_jet_y!=m-1)		
		renvoi_moins_1000=true;	
	else if (element_x_y=='-')
		renvoi_moins_1000=true;
	else if (element_x_y=='|')
		renvoi_moins_1000=true;
	else if (coord_jet_y<0)
		renvoi_moins_1000=true;
	else if (coord_jet_x<0)	
		renvoi_moins_1000=true;	
	
	return (renvoi_moins_1000);				//renvois la la valeur de renvoi_moins_1000
}											//au module appelant

bool est_ce_qu_on_peux_placer_un_mir_en_x_y(int coord_x_ds_mat,int coord_y_ds_mat,char elt_x_y_ds_mat,char miroir)
{													//cette fct de type bool sert a savoir si on peut
	bool es_ce_permis_de_placer_1_mir=false;		//placer un miroir cad que les coordonnees introduites et
	if (coord_y_ds_mat>=0 && coord_y_ds_mat<m)		//passees par valeur sont ds la matrice et que que la case
		if (coord_x_ds_mat>=0 && coord_x_ds_mat<n)	//de coordonne x, y est libre et que l'orientaion  
			if (elt_x_y_ds_mat==' ')				//du miroir aussi passee par valeur est soit \ soit /
				if (miroir==47 || miroir==92)		//cad en ASCII 47 et 92
					es_ce_permis_de_placer_1_mir=true;
	return(es_ce_permis_de_placer_1_mir); 
}

bool est_ce_que_je_peux_avancer_tout_droit (char elt_x_y)	//cette fct de type bool sert a savoir 
{															//si on peut avancer tout droit cad
	bool permission_avancer_tt_droit=false;					//que la case indiquée est \ ou / ou W
	if (elt_x_y==' ' || elt_x_y=='W' || (elt_x_y>='1' && elt_x_y<='9')) //ou un chiffre entre
		permission_avancer_tt_droit=true;					//1 et 9 ou un espace
	return (permission_avancer_tt_droit);					//retourne la valeur de permission_avancer_tt_droit
}															//au module appelant 

void recopiage_de_la_mat (char jardin[m][n], char level[p][m][n], int niveau)
{											//fct de type void sert a recopier un des niveaux de la matrice jeu 
	for(int i=0 ;i<m; i++)					//dans la matrice jardin. 
		for(int j=0; j<n ; j++)				
			jardin[i][j]=level[niveau][i][j];	
}

int nounou (char jardin[m][n], int  nbmir) //fct nounou servant a calculer le score du niveau
{		
    int direction=1,	//declaration de variable de type entier, direction representant la direction du jet,
						//si le jet va vers la droite direction =1 vers le bas =2 vers la gauche =3 vers le 
						//haut =4, direction est initialisee a 1 car Pourkos tire vers la droite
        coord_jet_y=0,	//represente l'ordonnee du jet
        coord_jet_x=0,	//represente l'absisce du jet
		score=0;
        
    char orient_mir,	//declaration de variable de type caractere oriet_mir representant l'orientation
		 coordy,		//du miroir et coordx et coordy representant temporairement les coordonnees x et y 
		 coordx;		//des miroirs
		 

		 
	bool 
		 score_moins_1000=false;
	
	affichage(jardin);		 //appelle la fct affichage qui va afficher la matrice jardin
    cout <<"Veuiller placer "<<nbmir<<" miroir( y puis x puis son orientataion)"<<endl;    
    do			//boucle do while servant a placer les miroirs
    {		
		cin>>coordy>>coordx>>orient_mir;	//lis sur input les valeurs de coordy, coordx et orient_mir
		if (coordy>='1' && coordy<='6' && coordx>='1' && coordx<='7' && (orient_mir==47 || orient_mir==92))
		{								//si les coordonnees introduites sont comprises1 ds la matrice
			int coord_y=coordy-'0',     //et que le caractere representant le miroir est \ ou /
				coord_x=coordx-'0';		//alors la valeur ASCII de coordy et coordx - la valeur ASCII de 0
										//sera egal a l'entier coord_y et coord_x
			if(jardin[coord_y-1][coord_x-1]!=' ')	//si les coordonnees introduites representent autre chose
				cout<<"espace deja employe"<<endl;	//qu'un espace alors il affiche espace deja employe
			else	//autrement le miroir est place ds la matrice a l'endroit indiqué et on decremente de 1
			{		//nbmir qui represente le nombre de miroir
				jardin[coord_y-1][coord_x-1]=orient_mir;
				nbmir--;
			}
		}
		else	//autrement le programme affiche coordonnee ou caractere introduit incorrect
			cout<<"coordonnee ou caractere introduit incorrect"<<endl;
	}   
	while (nbmir>0);	//la boucle est reiteree tant qu'il faut placer des miroirs

	while(coord_jet_x<n && ! score_moins_1000) //cette boucle sert a faire avancer le jet ds la 
	{		//matrice en fct de la direction et des deviations. La boucle va etre iteree tant qu'on ne sort pas
			//de la matrice et tant qu'on n'a pas touché de fil electricque
		if (direction==1)  //si direction =1, la boucle etre iteree tant que coord_jet_x<n et que la fct
		{			//est_ce_que_je_peux_avancer_tout_droit renvoit la valeur vrai
			while (coord_jet_x<n && est_ce_que_je_peux_avancer_tout_droit ( jardin[coord_jet_y][coord_jet_x] ))
            {				
				if (jardin[coord_jet_y][coord_jet_x]=='W')		//si on passe sur W on ajoute 10 au score
					score +=10;
				else if (jardin[coord_jet_y][coord_jet_x]!=' ')	 //autrement on va faire appel a la fct comptant 
					compteur_de_point_negatif (jardin[coord_jet_y][coord_jet_x], score);	//les points negatifs			
				jardin[coord_jet_y][coord_jet_x]='-';   //place - ds la matrice jardin aux coordonnees indiquées
                coord_jet_x++;				//incremente coord_jet_x de 1 cad avance vers la droite				           
			}		 		
			if (coord_jet_x<n &&(jardin[coord_jet_y][coord_jet_x]==92 || jardin[coord_jet_y][coord_jet_x]==47))
						//si la case de coordonnee coord_jet_y coord_jet_x est egale a \ ou / et que coord_jet_x<n						
						//alors on appelle lafct deviation jet
				deviation_jet (direction, coord_jet_y, coord_jet_x, jardin[coord_jet_y][coord_jet_x]);			
			if (est_ce_que_score_doit_valoir_moins_1000 (coord_jet_x, coord_jet_y,jardin[coord_jet_y][coord_jet_x]))				
				score_moins_1000=true;	//si la fct est_ce_que_score_doit_valoir_moins_1000 renvoit vrai alors
										//electricité=vrai
		}							

			
	    else if(direction==2)
		{			
			while (coord_jet_y<m && est_ce_que_je_peux_avancer_tout_droit ( jardin[coord_jet_y][coord_jet_x] ))
            {				
				if (jardin[coord_jet_y][coord_jet_x]=='W')
					score +=10;
				else if (jardin[coord_jet_y][coord_jet_x]!=' ')
					compteur_de_point_negatif (jardin[coord_jet_y][coord_jet_x], score);
				jardin[coord_jet_y][coord_jet_x]='|';                            
                coord_jet_y++;				
            }			
            if (coord_jet_y<m && (jardin[coord_jet_y][coord_jet_x]==92 || jardin[coord_jet_y][coord_jet_x]==47))			
				deviation_jet (direction, coord_jet_y, coord_jet_x, jardin[coord_jet_y][coord_jet_x]); 							
			if (est_ce_que_score_doit_valoir_moins_1000 (coord_jet_x, coord_jet_y,jardin[coord_jet_y][coord_jet_x]))
				score_moins_1000=true;
		}
			
	    else if(direction==3)
		{			
			while (coord_jet_x>=0 && est_ce_que_je_peux_avancer_tout_droit ( jardin[coord_jet_y][coord_jet_x] ))
            {				
				if (jardin[coord_jet_y][coord_jet_x]=='W')
					score +=10;
				else if (jardin[coord_jet_y][coord_jet_x]!=' ')
					compteur_de_point_negatif (jardin[coord_jet_y][coord_jet_x], score);
				jardin[coord_jet_y][coord_jet_x]='-';
                coord_jet_x--;				
            }
			if (coord_jet_x>=0 && (jardin[coord_jet_y][coord_jet_x]==92 || jardin[coord_jet_y][coord_jet_x]==47))
				deviation_jet (direction, coord_jet_y, coord_jet_x, jardin[coord_jet_y][coord_jet_x]); 	
			if (est_ce_que_score_doit_valoir_moins_1000 (coord_jet_x, coord_jet_y,jardin[coord_jet_y][coord_jet_x]))
				score_moins_1000=true;									
		}

        else if (direction==4)
		{			
			while (coord_jet_y>=0 && est_ce_que_je_peux_avancer_tout_droit ( jardin[coord_jet_y][coord_jet_x] ))
            {				
				if (jardin[coord_jet_y][coord_jet_x]=='W')
					score +=10;
				else if (jardin[coord_jet_y][coord_jet_x]!=' ')
					compteur_de_point_negatif (jardin[coord_jet_y][coord_jet_x], score);
				jardin[coord_jet_y][coord_jet_x]='|';
                coord_jet_y--;				
           	}			
            if (coord_jet_y>=0 && (jardin[coord_jet_y][coord_jet_x]==92 || jardin[coord_jet_y][coord_jet_x]==47))
				deviation_jet (direction, coord_jet_y, coord_jet_x, jardin[coord_jet_y][coord_jet_x]);			
			if (est_ce_que_score_doit_valoir_moins_1000 (coord_jet_x, coord_jet_y, jardin[coord_jet_y][coord_jet_x]))
				score_moins_1000=true;
		}
	}
	
	if (score_moins_1000)	//Si score_moins_1000 = vrai alors score = -1000
		score=-1000; 
	
	affichage(jardin);	//on appelle la fct affichage avec comme parametre la matrice jardin
						//pour afficher cette matrice apres le tir
	return (score);		//retourne la valeur de score au module appelant
} 

int main()
{
	int niveau=0,        
		score,
		score_int,
		nb_miroir [p] ={6,5,4}; //declaration d'un vecteur de type entier representant le nb de miroirs par niveau
	char jardin[m][n],			//delaration d'une matrice de type caractere jardin m*n et d'une matrice jeu de
		jeu [p][m][n]=			//type m*n*p
				{
					{
						{' ','1',' ',' ','3',' ',' '},   //initialisation de la matrice jeu
						{'8',' ',' ','5',' ',' ','7'},
						{' ',' ',' ',' ','Z',' ',' '},
						{' ',' ','4',' ',' ','6',' '},
						{' ',' ','W',' ',' ',' ',' '},
						{'9',' ',' ',' ','2',' ',' '}
					},

					{
						{' ',' ',' ','Z',' ',' ',' '},
						{'5','1',' ','W',' ',' ',' '},
						{' ',' ','2',' ','7',' ',' '},
						{' ',' ',' ',' ',' ',' ',' '},
						{' ','8',' ','3',' ','9','6'},
						{' ',' ',' ',' ','5',' ',' '}
					},

					{
						{' ',' ',' ',' ','6',' ',' '},
						{' ',' ',' ',' ','2',' ','7'},
						{'4',' ',' ','1',' ',' ',' '},
						{' ',' ','Z',' ',' ',' ','8'},
						{' ',' ',' ',' ','3',' ',' '},
						{' ','9','W',' ',' ',' ',' '}
					}
				};
	
	recopiage_de_la_mat (jardin, jeu, niveau);	//on appelle la matrice recopiage_de_la_mat qui recopie le niveau 0 de jeu
											//ds la matrice jardin											
	score_int=nounou(jardin, nb_miroir[niveau]); //on appelle la fct nounou et on place le resultat de la fct ds score_int
	score=score_int;
	cout<<"score de ce niveau: "<<score_int<<endl;
	niveau++;		
	if (score_int>=0)		//si le score_int es positif cad qu'on passe on niveau suivant
	{	
		cout<<"bravo avez reussi le niveau"<<endl;
		recopiage_de_la_mat (jardin, jeu, niveau);	
		score_int=nounou(jardin, nb_miroir [niveau]);
		cout<<"score pour ce niveau: "<<score_int<<endl;
		if (score_int>=0)
		{
			cout<<"bravo avez reussi le niveau"<<endl;
			score +=score_int;			
			niveau++;			
			recopiage_de_la_mat (jardin, jeu, niveau);			
			score_int=nounou(jardin,  nb_miroir [niveau] );
			if (score_int!=-1000)
			{
				cout<<"score total: "<<score + score_int<<endl;
				cout<<"Bravo vous avez fini le jeu"<<endl;
			}
			else 
			{
				cout<<"score: -1000"<<endl;
				cout<<"GAME OVER"<<endl;
			}
		}
		else
			cout<<"GAME OVER"<<endl;
	}
    else
		cout<<"GAME OVER"<<endl;
 	
}

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
2
Date d'inscription
samedi 8 mai 2010
Statut
Membre
Dernière intervention
28 février 2013

Je n'arrive pas compiler correctement le jeu en C .. ?
Messages postés
1329
Date d'inscription
vendredi 15 août 2003
Statut
Membre
Dernière intervention
16 juin 2010
2
???
1 : ca serait cool de la part de celui qui a mis 1 de mettre un petit mot malgré tout
2 : c'est vrai que c'est injouable...dommage, j'ai pas tout compris mais le principe a l'air pas trop mal...refais nous ca avec une interface graphique ca sert 1000* mieux

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.