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;
}

ATTENTION : Comment dois-je compiler ?

Il y a plusieurs étapes de compilation :

1. Compiler fonction.c

gcc -c -Wall puissance4.c -o puissance4.o

2. Compiler main.c

gcc -c -Wall main.c -o main.o

3. 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

IF (a=b=c)

MAIS

IF (a==b && a==c && b==c)

ALORS Attention quand vous allez traduire vos algos !

VerificationLignes

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

IF (a=b=c)

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

IF (a=b=c)

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

IF (a=b=c)

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)

1. Créer un makefile permettant de compiler le tout
2. Ajouter au programme la possibilité de rajouter un argument à l’éxécution avec la taille de maGrille
3. Créer un mode de jeu contre l’ordinateur