Rendu de travaux I, Algo

IFIP
33 avenue de la République
75011 PARIS
Rendu de travaux I,
Algo - langage C
Valérie Amiot
RP 50
2001-2002
SOMMAIRE
I.
Pourquoi sous C ?
II.
Présentation du jeu
1) But du jeu
III. Analyse fonctionnelle
IV.
Fonctionnalités
1) Déclaration
2) Fonction main
3) Fonction menu
4) Fonction initialisation
5) Fonction affiche
6) Fonction jeu1
7) Fonction coup_legal
8) Fonction coup1
9) Fonction coup2
10) Fonctions tests
11) Fonction gagne
12) Fonction jeu2
13) Fonction coup_ordi
V.
Schéma
VI.
Algorithmie
1) Le dessin de la grille
2) Le choix 2 : un joueur et l'ordinateur
3) Teste le coup joué si la case désignée est vide il y met le bon jeton
4) L'ordinateur joue
5) Teste si une combinaison horizontale est présente
6) Fonction Test ( ) appelle les différentes fonctions de tests pour voir si un des cas de victoire existe
VII. Langage C
1) Fonction qui teste une combinaison diagonale à droite présente
2) Fonction qui appelle les différentes fonctions de test pour voir si un cas de victoire existe
Algo - langage C
Jeu Puissance 4
I- Pourquoi sous C ?
Le langage C est un langage comportant des instructions et des structures de haut niveau tout en
générant un code rapide grâce à un compilateur très performant. Ses performances sont dues au fait
que les instructions du langage sont proches du langage machine, ce qui se traduit par un
programme compact, donc rapide, ... Ainsi, les programmes en C sont courts. Par contre ce langage
ne permet pas de faire des programmes avec une belle interface graphique.
Le jeu puissance 4 et simple, ne demande que peu de graphisme et pas spécialement de couleur. Par
conséquent le langage C est parfaitement adapté pour ce programme et celui ci bénéficiera de ses
performances.
II- Présentation du jeu
1) But du jeu
Dans une grille verticale, 2 joueurs mettent un pion à tour de rôle dans une des 7 colonnes. Celle
ci ne doit pas être déjà pleine. Le gagnant est le premier qui a aligné 4 de ses pions
horizontalement, verticalement ou en diagonale.
III- Analyse fonctionnelle
Le jeu de Puissance 4 sera utilisable de 2 façons :
· Utilisateur contre Utilisateur,
· Utilisateur contre Ordinateur.
Le jeu se présente sous la forme d'une grille verticalement posé sur la table. La grille est divisée en
7 colonnes creuses pour contenir les jetons. Le joueur insère des jetons par le haut, dans une
colonne, et ceux-ci tombent jusqu'à rejoindre la position la plus basse possible. Enfin ces colonnes
sont percées de trous (6 à l'origine) qui permettent de voir les jetons.
Chaque joueur possède des jetons d’une couleur différente de ceux de son adversaire, Rouge ou
Jaune. Chaque joueur joue alternativement un jeton. Un joueur choisit une colonne non pleine et y
insère son jeton. Celui-ci tombe et rejoint sa position. Jouer un coup revient donc à choisir un
numéro de colonne.
La partie s'arrête lorsque :
· un joueur aligne 4 jetons, horizontalement, verticalement ou en diagonale.
· la grille est pleine.
A la fin d'une partie, l'utilisateur décide d'arrêter de jouer, ou de recommencer la partie.
3
Algo - langage C
IV- Fonctionnalités
1) Déclaration
Tout d’abord on déclare les constantes utilisées : le nombre de lignes et de colonne de la grille,
les 2 caractères qui désignent les pions des joueurs. Puis les fonctions qui vont être appelées
(prototypage).
On crée un tableau statique dans la mémoire pour réserver la place nécessaire à l’exécution du
programme.
2) Fonction main
Elle contient juste la fonction menu .
3) Fonction menu
La fonction menu propose à l’utilisateur un choix de modes :
1. deux joueurs l’un contre l’autre,
2. un joueur contre l’ordinateur,
3. quitter.
En fonction du choix récupéré, le programme va faire appel aux cas désignés grâce à la fonction
switch qui gère les options. Si le joueur choisi 1) le programme lance les fonctions initialisation,
affiche et jeu1 décrite plus loin, pour le choix 2) les fonctions initialisation, affiche et jeu2 sinon
il quitte le jeu.
4
Algo - langage C
4) Fonction initialisation
Cette fonction parcourt le tableau statique horizontalement puis verticalement et vide chaque
case. Ceci est particulièrement utile si après une partie terminée le joueur choisi d’en faire une
nouvelle.
5) Fonction Affiche
Pour afficher la grille de jeu, la fonction parcours le tableau 5 fois horizontalement en affichant
sur chaque ligne impaire des pointilles la 6ème fois en plus des pointillés il affiche également le
numéro des colonnes. Verticalement il affiche des | sur chaque ligne impair ainsi que le numéro
de la ligne. Ce qui donne une grille de 7 colonnes et 6 lignes.
6) Fonction jeu1
Le choix 1 à été saisie : 2 joueurs vont s’affronter.
Jeu1 vérifie que ni le joueur 1 ni le joueur 2 n’ont gagné et que le grille n’est pas pleine. Si c’est
le cas, elle fait appel à la fonction Coup1 qui amène le joueur 1 à faire son choix. La variable
nbr_coup est incrémentée de 1 tandis que l’appel à la fonction Test permet de vérifier si ce coup
ne fait pas gagner le joueur 1.
Si le joueur 1 n’est pas gagnant après ce coup, c’est au tour du joueur 2 de choisir une colonne à
l’aide de l’appel à la fonction Coup2. La variable nbr_coup est également incrémentée de 1 et la
fonction Test est appeler pour vérifier que ce coup ne fait pas du joueur 2 le gagnant de la partie.
Si le nombre de coup devient égale à la multiplication du nombre de ligne par le nombre de
colonne, c’est à dire que la grille est pleine, la fonction Gagne renvoi 0, il n’y a aucun gagnant.
5
Algo - langage C
7) Fonction coup_legal
La fonction coup_legal vérifie que la colonne choisie existe bien dans la grille et qu’elle n’est pas
déjà pleine de jetons.
8) Fonction coup1
Tant qu’il n’y a aucune saisie, cette fonction demande au joueur 1 la colonne qu’il a choisi pour
mettre son pion et récupère ce choix. Elle vérifie en faisant appel à la fonction Coup_legal si la
colonne choisi est jouable si elle ne l’est pas elle demande au joueur 1 d’en jouer une autre.
Quand le joueur à choisi une colonne possible elle affiche à l’écran la grille mis à jour à l’aide de
la fonction Affiche.
9) Fonction coup2
Elle est identique à la fonction coup 1 mais s’adresse au joueur 2.
10) Fonctions de tests
Il y a 4 fonctions de test différentes : test_horiz, test_vert, test_diag_gche, test_diag_drte.
Chacune fonctionne exactement de la même façon que les autres, avec des if imbriqués, mais en
vérifiant à un endroit différent si 4 pions ne sont pas identiques.
Par exemple Test_horiz : pour le pion au milieu de la ligne si 3 pions de chaque coté lui sont
identiques alors la variable ok =1 retourne ok.
Une 5ème fonction de test vérifie les autres, si l’une d’elle renvoi un ok qui est égale à 1, elle
appelle la fonction Gagne en lui donnant le numéro du joueur concerné.
11) Fonction gagne
La fonction Gagne affiche à l’écran le gagnant grâce à une fonction Switch, si la grille est pleine
c’est à dire que la fonction Jeu1 ou Jeu2 lui a renvoyé 0, elle affiche à l’écran que la partie est
terminée. Si la fonction Test lui a renvoyé un numéro de gagnant, elle affiche le nom du gagnant.
12) Fonction jeu2
Le choix 2 à été saisie : 1 joueur affronte l’ordinateur.
Jeu2 vérifie que ni le joueur 1 ni le joueur 2 n’ont gagné et que le grille n’est pas pleine. Si
aucunes de ces expressions n’est vrai, elle fait appel à la fonction Coup1 qui amène le joueur à
faire son choix. La variable nbr_coup est incrémentée de 1 tandis que l’appel à la fonction Test
permet de vérifier si ce coup ne fait pas gagner le joueur.
6
Algo - langage C
Si le joueur n’est pas gagnant après ce coup, c’est au tour de l’ordinateur l’aide de l’appel à la
fonction Coup_ordi. La variable nbr_coup est également incrémentée de 1 et la fonction Test est
appeler pour vérifier que ce coup ne fait pas de l’ordinateur le gagnant de la partie.
Si le nombre de coup devient égale à la multiplication du nombre de ligne par le nombre de
colonne, c’est à dire que la grille est pleine, la fonction Gagne renvoi 0, il n’y a aucun gagnant.
13) Fonction coup_ordi
L’ordinateur choisi une colonne au hasard entre 1 et 7 grâce à la fonction rand et met son pion
dans la colonne choisi.
V- Schéma
Menu ( )
2 joueurs
Quitter
1 joueur
Initialisation ( )
vider le tableau
Initialisation ( )
vider le tableau
Affiche ( )
dessin de la grille
Affiche ( )
dessin de la grille
Jeu2 ( )
Jeu1 ( )
Tant que aucun gagnant
Tant que aucun gagnant
et grille non pleine
et grille non pleine
Coup1 ( )
Coup1 ( )
colonne choisie ?
colonne choisie ?
Coup_legal (int, col, char car ) Coup_legal (int col, char car )
colonne entre 1 et 7,
colonne entre 1 et 7,
colonne choisie non pleine
colonne choisie non pleine
met le pion ou rejoue
met le pion ou rejoue
Test ( )
Test ( )
appel aux fonctions test_horiz,
appel aux fonctions test_horiz
test_vert, test_diag_gche,
test_vert, test_diag_gche,
test_diag_drte. Si un des 4 tests test_diag_drte. Si un des 4 tests
est ok appel à gagne ( ) et lui
est ok appel à gagne ( ) et lui
renvoi le n° du joueur.
renvoi le n° du joueur.
Coup_ordi ( )
Coup2 ( )
choix d’une colonne au hasard
colonne choisie ?
mais forcément légale
Coup_legal ( ) et Test ( )
Test ( )
Gagne ( )
Gagne ( )
affiche joueur gagnant
affiche joueur gagnant
ou grille pleine
ou grille pleine
7
Algo - langage C
VI- Algorithmie
Explications précises sur les fonctions particulièrement difficiles.
1) Le dessin de la grille
void affiche()
{
int i, j, k;
POUR (i=0,k=0; (k<=LIGNE-1); i++)
{
SI ( (I MODULO 2) est contraire 0) /* i est impair */
{
AFFICHER (" --- --- --- --- --- --- --- ligne %d \n",k);
/*k est le numéro de la ligne*/
}
SINON
/* i est pair */
{
AFFICHER (" ");
POUR (j=0; j<=COLONNE-1; j++)
{
AFFICHER ("| %c ",grille[k][j]);
}
AFFICHER ("|\n");
k++;
}
}
AFFICHER ("
AFFICHER ("
--- --- --- --- --- --- --- ligne 6\n");
1 2 3 4 5 6 7 \n\n");
}
2) Le choix 2 : un joueur et l'ordinateur
void jeu2()
{
int gagnant1, gagnant2, nbr_coup
TANT QUE gagnant1 est égal à 0, que le gagnant2 est aussi égal à 0 et que nbr_coup est
inférieur à la multiplication de ligne par colonne
{
FAIRE appel à la fonction coup1();
incrémentation de coup de 1;
gagnant1 appel la fonction test(PION1,1);
SI gagnant1 est toujours égal à 0
{
8
Algo - langage C
ALORS appel à la fonction coup_ordi();
incrémentation de coup de 1;
gagnant2 appel la fonction test(PION2,2);
}
}
3) Teste le coup joué si la case désignée est vide il y met le bon jeton
int coup_legal(int col,char car)
{
int i, ok;
ok = 0;
SI ( (la variable globale col est inférieur à 0) et que (col est inférieur à COLONNE) )
{
POUR( i reçoit 0; ((ok est égal à 0) et (i inférieur à LIGNE)); i++)
{
SI( grille[LIGNE-i-1][col-1] est égal à VIDE)
{
ALORS ok reçoit 1;
grille[LIGNE-i-1][col-1] = la variable globale car;
}
}
}
return(ok);
}
4) L'ordinateur joue
void coup_ordi()
{
int col, coup;
coup reçoit 0;
col = 1 + (int) (7.0*rand()/(RAND_MAX+1.0));
coup = coup_legal(col, PION2);
affiche();
}
5) Teste si une combinaison horizontale est présente
int test_horiz(char car)
{
int i, j, ok;
ok = 0;
POUR ( i=0; i<LIGNE; i++)
{
POUR (j=0; j<COLONNE-3; j++)
{
9
Algo - langage C
SI (grille[i][j] est égal à la variable globale car)
{
SI (grille[i][j+1] est égal à la variable globale car)
{
SI (grille[i][j+2] est égal à la variable globale car)
{
SI (grille[i][j+3] est égal à la variable globale car)
{
ok=1;
}
}
}
}
}
}
return(ok);
}
6) Fonction Test ( ) appelle les différentes fonctions de tests pour voir si un des cas de victoire
existe
int test(char car, int joueur)
{
int ok=0;
SI (test_horiz(car) est égal à 1)
{
ALORS
ok=1;
}
SINON
{
SI (test_vert(car) est égal à 1)
{
ALORS
ok=1;
}
SINON
{
SI (test_diag_gche(car) est égal à 1)
{
ALORS
ok=1;
}
SINON
{
SI (test_diag_drte(car) est égal à 1)
{
ALORS
ok=1;
}
}
}
}
10
Algo - langage C
SI (ok est égal à 1)
{
ALORS
gagne(joueur);
}
return(ok);
}
VII. Langage C
1) Fonction qui teste une combinaison diagonale à droite présente
int test_diag_drte(char car)
{
int i, j, ok;
ok = 0;
for( i=0; i<LIGNE-3; i++)
{
for( j=0; j<COLONNE-3; j++)
{
if (car==grille[i][j])
{
if (car==grille[i+1][j+1])
{
if (car==grille[i+2][j+2])
{
if (car==grille[i+3][j+3])
{
ok=1;
}
}
}
}
}
}
return(ok);
}
2) Fonction qui appelle les différentes fonctions de test pour voir si un cas de victoire existe
int test(char car, int joueur)
{
int ok=0;
if (test_horiz(car)==1)
{
ok=1;
}
else
11
Algo - langage C
{
if (test_vert(car)==1)
{
ok=1;
}
else
{
if (test_diag_gche(car)==1)
{
ok=1;
}
else
{
if (test_diag_drte(car)==1)
{
ok=1;
}
}
}
}
if (ok==1)
{
gagne(joueur);
}
return(ok);
}
12