Jeu de strategie africain awale

Soyez le premier à donner votre avis sur cette source.

Vue 16 924 fois - Téléchargée 1 690 fois

Description

Jeu de réflexion.
Jeu à un joueur contre le PC, à deux joueurs, démo.
Prog d'intelligence artificielle, le processeur cherchant le meilleur coup de facon recursive.
Plus d'infos, d'autres progs d'IA, voir le site :
http://pascal.libaud.free.fr

Source / Exemple :


#include <stdio.h>

//Définition de la structure de l'awalé
typedef struct
{
	int case_moi[6];
	int case_cpu[6];
	int score_moi;
	int score_cpu;
	int tour_jeu;
	int fini;
} awale;

// Définition de la structure de la case à retourner avec le gain de score
typedef struct
{
	int case_meilleure;
	int gain_score;
} case_retour;

// Affiche l'awale a l'ecran
//********************
void afficher(awale a)
//********************
{
	printf("\n\n\nTour de jeu : %s\n\n",(a.tour_jeu==1?"vous":"CPU"));
	printf("%3d %3d %3d %3d %3d %3d     score : %d\n\n\n",a.case_cpu[5],a.case_cpu[4],a.case_cpu[3],a.case_cpu[2],a.case_cpu[1],a.case_cpu[0],a.score_cpu);
	printf("%3d %3d %3d %3d %3d %3d     score : %d\n\n",a.case_moi[0],a.case_moi[1],a.case_moi[2],a.case_moi[3],a.case_moi[4],a.case_moi[5],a.score_moi);
}

// Le joueur joue un coup entre 0 et 5
// Déplace les pions, change le score
//*****************************************
void joueur_joue(awale* a,int case_choisie)
//*****************************************
{
	int case_gene=case_choisie;
	int nb_graine=a->case_moi[case_choisie];
	int case_bis=11; // Servira pour la règle : enlève tt enlève rien
	int enleve=0;
	
	
	a->case_moi[case_choisie]=0;
	
	//Dépose les graines
	while(nb_graine!=0)
	{
		case_gene++;
		if (case_gene==12) case_gene=0;
		if (case_gene==case_choisie) case_gene++;
		if (case_gene>5)
			a->case_cpu[case_gene-6]++;
		else
			a->case_moi[case_gene]++;
		nb_graine--;
	}

	// Vérifie la règle : enlève tt enlève rien
	if ((case_gene>5)&&((a->case_cpu[case_gene-6]==2)||(a->case_cpu[case_gene-6]==3)))
	{
		while ((case_bis!=case_gene)&&(enleve==0))
		{
			if (a->case_cpu[case_bis-6]!=0) enleve=1;
			case_bis--;
		}
		case_bis--;
		while ((case_bis>5)&&(enleve==0))
		{
			if ((a->case_cpu[case_bis-6]!=2)&&(a->case_cpu[case_bis-6]!=3)) enleve=1;
			case_bis--;
		}
		// si enleve==1, alors on peut enlever les graines gagnées
		if (enleve==1)
			while ((case_gene>5)&&((a->case_cpu[case_gene-6]==2)||(a->case_cpu[case_gene-6]==3)))
			{
				a->score_moi+=a->case_cpu[case_gene-6];
				a->case_cpu[case_gene-6]=0;
				case_gene--;
			}
	}	
	a->tour_jeu=2;
}
	
// Le cpu joue un coup entre 0 et 5
// Déplace les pions, change le score
//**************************************
void cpu_joue(awale* a,int case_choisie)
//**************************************
{
	int case_gene=case_choisie;
	int nb_graine=a->case_cpu[case_choisie];
	int case_bis=11; // Servira pour la règle : enlève tt enlève rien
	int enleve=0;
	
	
	a->case_cpu[case_choisie]=0;
	
	//Dépose les graines
	while(nb_graine!=0)
	{
		case_gene++;
		if (case_gene==12) case_gene=0;
		if (case_gene==case_choisie) case_gene++;
		if (case_gene>5)
			a->case_moi[case_gene-6]++;
		else
			a->case_cpu[case_gene]++;
		nb_graine--;
	}
	
	//Enlève celles gagnées et augmente le score
		// Vérifie la règle : enlève tt enlève rien
	if ((case_gene>5)&&((a->case_moi[case_gene-6]==2)||(a->case_moi[case_gene-6]==3)))
	{
		while ((case_bis!=case_gene)&&(enleve==0))
		{
			if (a->case_moi[case_bis-6]!=0) enleve=1;
			case_bis--;
		}
		case_bis--;
		while ((case_bis>5)&&(enleve==0))
		{
			if ((a->case_moi[case_bis-6]!=2)&&(a->case_moi[case_bis-6]!=3)) enleve=1;
			case_bis--;
		}
		// si enleve==1, alors on peut enlever les graines gagnèes
		if (enleve==1)
			while ((case_gene>5)&&((a->case_moi[case_gene-6]==2)||(a->case_moi[case_gene-6]==3)))
			{
				a->score_cpu+=a->case_moi[case_gene-6];
				a->case_moi[case_gene-6]=0;
				case_gene--;
			}
	}
	a->tour_jeu=1;
}
	
// Demande au joueur quel coup il veut jouer et le joue
//***************************
void demande_joueur(awale* a)
//***************************
{
	int i=0;
	int coup;
	
	// Vérifie si le jeu n'est pas fini
	if (a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5]==0)
	{
		while ((i+a->case_moi[i]<6)&&(i<6)) i++; // Vérifie si on peut donner des graines
		if (i==6)
		{
			a->fini=1;
			return; // Jeu fini
		}
	}
	
	printf("Quel coup : ");
	scanf("%d",&coup);
	
	// Coup entre 1 et 6
	while ((coup<1)||(coup>6))
	{
		printf("Il faut entre 1 et 6 : ");
		scanf("%d",&coup);
	}
	
	// Joue une case non vide
	while (a->case_moi[coup-1]==0)
	{
		printf("Il faut jouer une case non vide : ");
		scanf("%d",&coup);
	}
	
	// Vérifie si l'adversaire n'a pas de graine
	if (a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5]==0)
		while (coup+a->case_moi[coup-1] < 7)
		{
			printf("Il faut donner des graines ! (radin) :");
			scanf("%d",&coup);
		}
		
	joueur_joue(a,coup-1);
}

// Demande au cpu quel coup il veut jouer et le joue
//************************
void demande_cpu(awale* a)
//************************
{
	int i;
	int coup;
	
	// Vérifie si le jeu n'est pas fini
	if (a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5]==0)
	{
		while ((i+a->case_cpu[i]<6)&&(i<6)) i++; // Vérifie si on peut donner des graines
		if (i==6)
		{
			a->fini=1;
			return; // Jeu fini
		}
	}
	
	printf("Quel coup : ");
	scanf("%d",&coup);
	
	// Coup entre 1 et 6
	while ((coup<1)||(coup>6))
	{
		printf("Il faut entre 1 et 6 : ");
		scanf("%d",&coup);
	}
	
	// Joue une case non vide
	while (a->case_cpu[coup-1]==0)
	{
		printf("Il faut jouer une case non vide : ");
		scanf("%d",&coup);
	}
	
	// Vérifie si l'adversaire n'a pas de graine
	if (a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5]==0)
		while (coup-1+a->case_cpu[coup-1]<6)
		{
			printf("Il faut donner des graines ! (radin) :");
			scanf("%d",&coup);
		}
	
	cpu_joue(a,coup-1);
}

// Affecte les dernieres graines quand le jeu est fini
//*************************
void terminer_jeu(awale* a)
//*************************
{
	int i;
	a->score_moi+=a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5];
	a->score_cpu+=a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5];
	for (i=0;i<6;i++)
	{
		a->case_moi[i]=0;
		a->case_cpu[i]=0;
	}
}

// Définition de la fonction ... juste dessous de celle-ci
case_retour meilleure_case_joueur(awale a,int nbre_recursif);

// Cherche le meilleur coup du CPU de facon recursive
// Renvoie la case donnant le meilleur coup et le gain de score
//*******************************************************
case_retour meilleure_case_cpu(awale a,int nbre_recursif)
//*******************************************************
{
	int i;
	case_retour sortie={0,0};
	awale awa[6];
	int case_retenue=-1;
	int gain_retenu=-36;
	int gain_actuel;
	int donne[6]={0,0,0,0,0,0}; // Marque les cases qui ne donnent pas de graine
	
	// Vérifie si l'adversaire est sans graines et marque les cases qui ne donnent pas
	if (a.case_moi[0]+a.case_moi[1]+a.case_moi[2]+a.case_moi[3]+a.case_moi[4]+a.case_moi[5]==0)
	{
		for(i=0;i<6;i++)
			if (i+a.case_cpu[i] < 6)
				donne[i]=1;
		if (donne[0]+donne[1]+donne[2]+donne[3]+donne[4]+donne[5]==6) // Jeu fini
		{
			sortie.gain_score=a.score_moi-a.score_cpu;
			terminer_jeu(&a);
			sortie.case_meilleure=-1;
			sortie.gain_score+=a.score_cpu-a.score_moi;
			return sortie;
		}
	}
				
	for (i=0;i<6;i++)
		if ((a.case_cpu[i]!=0)&&(donne[i]==0))
		{
			awa[i]=a;
			cpu_joue(&awa[i],i);
			if (nbre_recursif==0)
				gain_actuel=a.score_moi-a.score_cpu+awa[i].score_cpu-awa[i].score_moi;
			else
			{
				sortie=meilleure_case_joueur(awa[i],nbre_recursif);
				gain_actuel=a.score_moi-a.score_cpu+awa[i].score_cpu-awa[i].score_moi-sortie.gain_score;
			}
			if (gain_actuel>gain_retenu)
			{
				gain_retenu=gain_actuel;
				case_retenue=i;
			}
		}
		
	sortie.case_meilleure=case_retenue;
	sortie.gain_score=gain_retenu;
	
	return sortie;
}
			

// Cherche le meilleur coup du joueur de facon recursive
// Renvoie la case donnant le meilleur coup et le gain de score
//**********************************************************
case_retour meilleure_case_joueur(awale a,int nbre_recursif)
//**********************************************************
{
	int i;
	case_retour sortie={0,0};
	awale awa[6];
	int case_retenue=-1;
	int gain_retenu=-36;
	int gain_actuel;
	int donne[6]={0,0,0,0,0,0}; // Marque les cases qui ne donnent pas de graine
	
	// Vérifie si l'adversaire est sans graines et marque les cases qui ne donnent pas
	if (a.case_cpu[0]+a.case_cpu[1]+a.case_cpu[2]+a.case_cpu[3]+a.case_cpu[4]+a.case_cpu[5]==0)
	{
		for(i=0;i<6;i++)
			if (i+a.case_moi[i] < 6)
				donne[i]=1;
		if (donne[0]+donne[1]+donne[2]+donne[3]+donne[4]+donne[5]==6) // Jeu fini
		{
			sortie.gain_score=a.score_cpu-a.score_moi;
			terminer_jeu(&a);
			sortie.case_meilleure=-1;
			sortie.gain_score+=a.score_moi-a.score_cpu;
			return sortie;
		}
	}
				
	for(i=0;i<6;i++)
		if ((a.case_moi[i]!=0)&&(donne[i]==0))
		{
			awa[i]=a;
			joueur_joue(&awa[i],i);
			if (nbre_recursif==0)
			{
				gain_actuel=a.score_cpu-a.score_moi+awa[i].score_moi-awa[i].score_cpu;
			}
			else
			{
				sortie=meilleure_case_cpu(awa[i],nbre_recursif-1);
				gain_actuel=a.score_cpu-a.score_moi+awa[i].score_moi-awa[i].score_cpu-sortie.gain_score;
			}
			if (gain_actuel>gain_retenu)
			{
				gain_retenu=gain_actuel;
				case_retenue=i;
			}
		}
		
	sortie.case_meilleure=case_retenue;
	sortie.gain_score=gain_retenu;
	
	return sortie;
}

// Affiche le gagnant pour jeu 1 joueur
//************************************
void afficher_gagnant_1joueur(awale a)
//************************************
{
	if (a.score_moi > a.score_cpu)
		printf("Le gagnant est le premier joueur !\n Félicitations.\n\n");
	else
		if (a.score_moi < a.score_cpu)
			printf("Le gagnant est l'ordinateur !\n Entraines-toi encore.\n\n");
		else
			printf("Match nul !\n Pas mal du tout.\n\n");
}

// Affiche le gagnant pour la demo
//*********************************
void afficher_gagnant_demo(awale a)
//*********************************
{
	printf("Fin de la démonstration.\n\n");
}			

// Affiche le gagnant pour jeu 2 joueurs
//*************************************
void afficher_gagnant_2joueurs(awale a)
//*************************************
{
	if (a.score_moi > a.score_cpu)
		printf("Le gagnant est le premier joueur !\n Félicitations\n\n");
	else
		if (a.score_moi < a.score_cpu)
			printf("Le gagnant est le deuxième joueur !\n Félicitations.\n\n");
		else
			printf("Match nul !\n Pas mal du tout aux deux.\n\n");
}

// Fait tourner le jeu, une fois le joueur, une fois le CPU
//******************************
void lance_jeu_1joueur(awale* a)
//******************************
{
	int i;
	int nbre_graine;
	int profondeur;
	case_retour choix_cpu;
		
	afficher(*a);
	while (a->fini==0)
	{
		demande_joueur(a);
		afficher(*a);
		//test_jeu_fini(a);
		if (a->fini==0)
		{
			// Calcule le nbre d'itérations en fonction du nbre total de graines
			nbre_graine=a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5]+a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5];
			profondeur=4;
			if (nbre_graine<24) profondeur+=1;
			if (nbre_graine<18) profondeur+=1;
			if (nbre_graine<12) profondeur+=1;
			if (nbre_graine<6)  profondeur+=2;
			if (nbre_graine<4)  profondeur+=4;
			
			choix_cpu=meilleure_case_cpu(*a,profondeur);
			if (choix_cpu.case_meilleure!=-1)
			{
				cpu_joue(a,choix_cpu.case_meilleure);
				afficher(*a);
			}
			else a->fini=1;
		}
		//test_jeu_fini(a);
	}
	terminer_jeu(a);
	afficher(*a);
	afficher_gagnant_1joueur(*a);
}

// Fait tourner le jeu en demo, le cpu joue seul
//***************************
void lance_jeu_demo(awale* a)
//***************************
{
	int i;
	int nbre_graine;
	int profondeur;
	case_retour choix_cpu;
	case_retour choix_moi;
		
	afficher(*a);
	while (a->fini==0)
	{
		nbre_graine=a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5]+a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5];
		profondeur=4;
		if (nbre_graine<24) profondeur+=1;
		if (nbre_graine<18) profondeur+=1;
		if (nbre_graine<12) profondeur+=1;
		if (nbre_graine<6)  profondeur+=2;
		if (nbre_graine<4)  profondeur+=4;
		
		choix_moi=meilleure_case_joueur(*a,profondeur);
		if (choix_moi.case_meilleure!=-1)
		{
			joueur_joue(a,choix_moi.case_meilleure);
			afficher(*a);
		}
		else a->fini=1;
			
		if (a->fini==0)
		{
			// Calcule le nbre d'itérations en fonction du nbre total de graines
			nbre_graine=a->case_moi[0]+a->case_moi[1]+a->case_moi[2]+a->case_moi[3]+a->case_moi[4]+a->case_moi[5]+a->case_cpu[0]+a->case_cpu[1]+a->case_cpu[2]+a->case_cpu[3]+a->case_cpu[4]+a->case_cpu[5];
			profondeur=4;
			if (nbre_graine<24) profondeur+=1;
			if (nbre_graine<18) profondeur+=1;
			if (nbre_graine<12) profondeur+=1;
			if (nbre_graine<6)  profondeur+=2;
			if (nbre_graine<4)  profondeur+=4;
							
			choix_cpu=meilleure_case_cpu(*a,profondeur);
			if (choix_cpu.case_meilleure!=-1)
			{
				cpu_joue(a,choix_cpu.case_meilleure);
				afficher(*a);
			}
			else a->fini=1;
		}
	}
	terminer_jeu(a);
	afficher(*a);
	afficher_gagnant_demo(*a);
}

// Fait tourner le jeu à 2 joueurs, le joueur joue pour lui et le cpu
//*******************************
void lance_jeu_2joueurs(awale* a)
//*******************************
{
	int i;
	
	afficher(*a);
	while (a->fini==0)
	{
		demande_joueur(a);
		afficher(*a);
		//test_jeu_fini(a);
		if (a->fini==0)
		{
			demande_cpu(a);
			afficher(*a);
			//test_jeu_fini(a);
		}
	}
	terminer_jeu(a);
	afficher_gagnant_2joueurs(*a);
}

int main()
{
	// Définition de l'awalé de référence
	awale   a={{4,4,4,4,4,4},{4,4,4,4,4,4},0,0,1,0};
	awale  aa={{4,4,4,4,4,4},{4,4,4,4,4,4},0,0,1,0};
	awale aaa={{4,4,4,4,4,4},{4,4,4,4,4,4},0,0,1,0};

	
	
	//lance_jeu_demo(&a);
	lance_jeu_1joueur(&aa);
	//lance_jeu_2joueurs(&aaa);
	return 0;	
}

Conclusion :


Prog réalisé avec DevC++, en mode shell. sans librairie graphique ni non standard.
Pour les règles ou autre chose sur le source, donner un avis :
http://pascal.libaud.free.fr

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
21
Date d'inscription
dimanche 20 octobre 2002
Statut
Membre
Dernière intervention
4 décembre 2004

on ne t'en veut pas loll t'inquiete ca arrive à tout le monde de faire des erreurs ;)
Messages postés
15
Date d'inscription
vendredi 20 février 2004
Statut
Membre
Dernière intervention
10 mai 2007

Il vient d'être mis dans la bonne rubrique, veuillez bien ne pas trop vous ofusquer pour cette erreur de ma part.
Le code source a été amélioré, mais pas dans la fenêtre ci-dessus car il ne rentrerait plus.
Messages postés
21
Date d'inscription
dimanche 20 octobre 2002
Statut
Membre
Dernière intervention
4 décembre 2004

c'est du C standard

Attention à ne pas confondre le C et le C# pour les codes écrit en C je pense que c'est dans la rubrique C++ qu'il faut les mettre
Messages postés
164
Date d'inscription
dimanche 16 novembre 2003
Statut
Modérateur
Dernière intervention
5 juillet 2005
1
Et surtout cygwin !
Messages postés
334
Date d'inscription
samedi 12 janvier 2002
Statut
Membre
Dernière intervention
3 juillet 2010

heum... ce n'est pas du c#
avec #include <string.h> etc...

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.