Le puissance 4
Durée : 3h
Inès de Courchelle
Objectifs :
- Réaliser le jeu puissance 4
- Coder avec des fichiers séparés
- Utiliser des Tableaux dynamiques
À chaque étape de programmation, vous devez vérifier si le programme :
- Compile sans warning
- Obtient les résultats attendus
- Avant de coder, il faut écrire un algo avec un papier et un stylo !
Règles du jeu
Le jeu du puissance 4 se joue sur un maGrille carré d’une taille de N x N. Il se joue à deux joueurs qui remplissent à tour de rôle le maGrille. Ils enfilent des pions chacun à leur tour. Le maGrille est en position vertical. Du coup, tous les pions s’empilent les un sur les autres (description du jeu)
Programme attendu
Questions régulièrement posées !
Dans la fonction jouer pourquoi quand res=0 ça renvoie 0 et ça passe le tour du joueur ?
- Par défaut on dit que l’utilisateur n’a pas bien saisie sa colonne
- On ne passe pas le tour du joueur c’est tour de jeu
- On demande à l’utilisateur de saisir une colonne et si cette colonne n’existe pas et/ou est compléte on renvoi faux (res=0)
- si la colonne existe et/ou est correcte on place le pion au bon endroit dans la grille
Dans la fonction jouer pourquoi tant que i< -1 ?
- Lorsque l’on place un pion dans notre puissance 4, il tombe dans la colonne jusqu’a rencontrer un autre pion ou bien jusqu’au fond.
- ICI, on démarre du bas de la colonne, (i:=taille-1; /* on initialise i à la taille de la colonne */)
- S’il y a un pion (différent de -1) alors on passe au dessus etc ..
- Cela nous permet d’EMPILER Les pions les uns sur les autres !
Dans la fonction jouer pourquoi le dernier sinon?
- c’est cette histoire d’empiler
- Si dans la dernière case j’ai un pion (1 ou 2) alors je passe à l’avant dernière case (i-1)
- si dans l’avant dernière case j’ai un pion (1 ou 2) alors je passe à l’avant avant dernière case (i-1)
- etc
1- Créer l’arborescence des fichiers suivantes
Dans le répertoire “INFO2”, ajouter le répertoire “TP3”
Les fichiers doivent être sauvegardés dans le même répertoire !
2- Créer le squelette du programme
puissance4.h
#ifndef __puissance4_H_
#define __puissance4_H_
/* toutes mes signatures/prototypes de fonctions/procédures */
#endif
puissance4.c
#include "puissance4.h"
/* corps des différentes fonctions/procédures */
main.c
#include <stdio.h>
#include "puissance4.h"
int main(){
printf("C'est le puissance 4 ! \n");
return 0;
}
Il y a plusieurs étapes de compilation :
- Compiler fonction.c
gcc -c -Wall puissance4.c -o puissance4.o
- Compiler main.c
gcc -c -Wall main.c -o main.o
- Compiler le tout !
gcc puissance4.o main.o -o exe
3- Créer la fonction permettant d’allouer une matrice NxN :
- N devra être une variable globale. Elle est fixée dans le programme.
- La compilation doit être séparée
- le corps de la fonction est dans le fichier puissance4.c
- la signature de la fonction dans fichier puissance4.h
- l’appel de la fonction dans le fichier main.c
- La matrice devra contenir uniquement des entiers
/* Auteur : ... */
/* Date : ... */
/* Résumé : ... */
/* Entrée(s) : ... */
/* Sortie(s) : ... */
int** allouer(int taille);
4- Créer une procédure permettant d’initialiser toutes les cases de le maGrille à -1
/* Auteur : ... */
/* Date : ... */
/* Résumé : ... */
/* Entrée(s) : ... */
/* Sortie(s) : ... */
void initialiser(int** maGrille,int taille);
5- Créer une procédure permettant d’afficher le maGrille
- Si la valeur de la case est -1 on affiche rien !
- Si la valeur de la case est 1 on affiche une croix !
- Si la valeur de la case est 2 on affiche un rond !
/* Auteur : ... */
/* Date : ... */
/* Résumé : ... */
/* Entrée(s) : ... */
/* Sortie(s) : ... */
void afficher(int** maGrille,int taille);
6- Créer une procédure jouer
Cette procédure doit :
- demander et vérifier la saisie de l’utilisateur
- est ce que l’on respecte la taille de la matrice ?
- est ce que la colonne est pleine ?
- …
- Si la saisie de l’utilisateur est juste alors je place le pion
- Si la saisie de l’utilisateur n’est pas possible, alors je lui redemande !
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
void jouer(int** maGrille,int taille, int joueur);
Indice pour algo Jouer
7- Créer la fonction vérifier une ligne
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
int VerificationLignes(int** grille,int ligne,int joueur, int taille);
ATTENTION : En C, on ne peut pas écrire
MAIS
IF (a==b && a==c && b==c)
ALORS Attention quand vous allez traduire vos algos !
VerificationLignes
VerificationLignes
![](img/verifierLignes1.png)
![](img/verifierLignes2.png)
Pourquoi nb colonnes - 3 ?
![](img/nbcolmoins3-1.png)
![](img/nbcolmoins3-2.png)
![](img/nbcolmoins3-3.png)
![](img/nbcolmoins3-4.png)
![](img/nbcolmoins3-5.png)
8- Créer la fonction vérifier une colonne
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
int VerificationColonnes(int** grille,int colonne,int joueur, int taille);
ATTENTION : En C, on ne peut pas écrire
MAIS
IF (a==b && a==c && b==c)
ALORS Attention quand vous allez traduire vos algos !
9- Créer les fonctions vérifier pour vérifier les diagonales
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
int Verificationdiag1(int** grille,int joueur, int taille);
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
int Verificationdiag2(int** grille,int joueur, int taille);
ATTENTION : En C, on ne peut pas écrire
MAIS
IF (a==b && a==c && b==c)
ALORS Attention quand vous allez traduire vos algos !
10- Créer une fonction ‘aGagne’
Cette fonction doit :
- vérifier :
- si sur une ligne, il y a 4 pions identiques
- si sur une colonne, il y a 4 pions identiques
- si sur une diagonale, il y a 4 pions identiques
- renvoyer :
- S’il y a un gagnant, le numéro du joueur 1 ou 2
- S’il y a match nul, un 0
- Sinon -1 (la partie n’est pas terminée)
/* Auteur : ... */
/* Date : ... */
/* Résumé : ... */
/* Entrée(s) : ... */
/* Sortie(s) : ... */
int aGagne(int** maGrille,int taille);
ATTENTION : En C, on ne peut pas écrire
MAIS
IF (a==b && a==c && b==c)
ALORS Attention quand vous allez traduire vos algos !
11- Créer la procédure ‘tourDeJeu’
Cette procédure doit :
- permettre aux joueurs de jouer à tour de rôle
- vérifier si un joueur a gagné
- afficher l’état de maGrille à chacun des joueurs
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
void tourDeJeu(int** maGrille,int taille);
12- Créer la procédure libéré
/* Auteur : */
/* Date : ...*/
/* Résumé : ...*/
/* Entrée(s) : ...*/
/* Sortie(s) : ...*/
void libere (int** maGrille,int taille);
13- (Bonus)
- Créer un makefile permettant de compiler le tout
- Ajouter au programme la possibilité de rajouter un argument à l’éxécution avec la taille de maGrille
- Créer un mode de jeu contre l’ordinateur