Puissance 4

Salut,

Durant ma L1 d'informatique, j'ai dût concevoir un puissance 4 en C comme projet semestriel.
Rien de transcendant sur le papier mais de nombreuses difficultés à gérer en pratique .

La bibliothèque d'interface graphique qu'on utilise est une version simplifiée de la SDL. Par exemple pour afficher une fenêtre il suffit d'écrire:

Code:

start_graphics();

Par contre du coup on ne peut faire que des choses basiques (afficher du texte, dessiner des formes et changer les couleurs, c'est tout ).

Ce projet a nécessité pas moins de 666 lignes de codes (je vous jure ! ) mais une optimisation est possible...

Voici une capture d'écran:



Vous pouvez le télécharger ici:
https://mega.nz/#!Gkc10bbJ!DvBp2Mp4Sjg5DSPNLYTo64DvjHUBpoCnU-SxV0yBjDo

Je ne compte pas améliorer le projet (on peut pas faire grand chose par rapport aux limitations de la bibliothèqe de toute façon ).

N'hésitez pas à me dire ce que vous en pensez et si vous voulez les codes pour les étudier .
Bonne journée !   .

Re,

omg lé grafiq tro moch utiliz UE4 !!!
Non pour le coup je ferais pas ch*er parce-que c'est un puissance 4 et c'est très joli
En vrai c'est sympa, l'IA est vachement intelligente, GG !
(seule remarque, t'aurais dû faire en sorte que si on sélectionne une case qui ne contient pas de jeton en dessous d'elle, au lieu d'empêcher le joueur de placer son jeton ici, le mettre automatiquement tout en bas de la colonne )

Cordialement,
Softwarezatorman

re,

Oui mais là c'est 1000 lignes voir plus de code pour savoir et mémoriser l'emplacement de chaque jetons....

Cordialement,
Le réparateur de PC

Softwarezatorman a écrit:Re,

omg lé grafiq tro moch utiliz UE4 !!!

tu m'as tué !

Softwarezatorman a écrit:
Non pour le coup je ferais pas ch*er parce-que c'est un puissance 4 et c'est très joli
En vrai c'est sympa, l'IA est vachement intelligente, GG !

Merci . En fait c'est un algo très simple mais très efficace:

Code:


Si l'IA peut faire un alignement de 4 pions alors on le fait
Sinon si le joueur peut faire un alignement de 4 pions alors on empêche de le faire
Sinon si l'IA peut faire un alignement de 3 pions alors on le fait
Sinon si le joueur peut faire un alignement de 3 pions alors on empêche de le faire
Sinon si l'IA peut faire un alignement de 2 pions alors on le fait
Sinon si le joueur peut faire un alignement de 2 pions alors on empêche de le faire


Softwarezatorman a écrit:
(seule remarque, t'aurais dû faire en sorte que si on sélectionne une case qui ne contient pas de jeton en dessous d'elle, au lieu d'empêcher le joueur de placer son jeton ici, le mettre automatiquement tout en bas de la colonne )

ça c'est une bonne idée ! j'y ait pensé et... j'ai jamais implémenté ! merci !

@lereparateurdepc a écrit:
Oui mais là c'est 1000 lignes voir plus de code pour savoir et mémoriser l'emplacement de chaque jetons....

Les jetons sont mémorisés dans un tableau de 2 dimension de int en fait, si tu reprend l'image que j'ai posté pour illustrer voici le tableau correspondant:

0	0	0	0	0	0	2
0	0	0	0	0	0	1
2	1	2	2	1	2	2
1	2	1	1	2	1	1
1	2	2	1	2	2	2
1	2	1	1	2	1	1

Du coup ça va, ça revient à parcourir le tableau et analyser des cases voisines

Re,

pas con le raisonnement de l'IA !

Cordialement,
Softwarezatorman

Salut,

Excellent petit jeu  Fonctionne nickel en plus  ! 
Chapeau  
666 lignes ? SATAN va !

Salut,

@softwarezatorman: ouai
@blackorion35: merci , ah ah je suis Belzébuth !

re,

Je met le code à disposition pour ceux qui seraient curieux du fonctionnement (attention à la migraine ) :

Code:


/*
JEU DU PUISSANCE 4 EN C
DESCRIPTION: Fichier unique contenant tout les codes du jeu de puissance 4
*/



#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#include "libgraphique.h"
#define NB_LIGNE 7
#define NB_COLONNE 8

int C,D,I;//Pseudo-constantes définies dans le main (permettent de tracer une grille dynamique en fonction du nombre de colonne et de ligne)

typedef int MATRICE[NB_LIGNE][NB_COLONNE];
//MATRICE mat;

//Pré-déclaration des fonctions pour ne pas se soucier de leur ordre d'écriture

void matrice(MATRICE mat);
void afficher_numeros(void);
void afficher_grille(void);
void jeu(int mode, MATRICE mat);
void tours(int joueur);
void gagnant(int joueur, int mode);
void curseur(int x,int y,MATRICE mat);
void valide(int joueur, int x, int y);
void vider_la_grille();
void redessiner(MATRICE mat);
void joueur_actuel(int *joueur);
void detection_mouvement(int *x,int *y,int *touche);
int dans_la_grille(int x,int y);
int case_vide(MATRICE mat,int x,int y);
int puissance4(MATRICE mat,int x,int y);
void placement(MATRICE mat,int x,int y,int joueur);
int grille_pleine(MATRICE mat);
void aff_mat(MATRICE mat);
void alea_mat(MATRICE mat);
int alignement_horizontal(MATRICE mat,int joueur,int x,int y,int nbr);
int alignement_vertical(MATRICE mat,int joueur,int x,int y,int nbr);
int alignement_diagonal_m(MATRICE mat,int joueur,int x,int y,int nbr);
int alignement_diagonal_d(MATRICE mat,int joueur,int x,int y,int nbr);
void intelligence_artificielle(MATRICE mat,int *place,int *x,int *y);

void matrice(MATRICE mat){
/*SPEC
Initialise la matrice mat de taille NB_LIGNE *
NB_COLONNE en la remplissant de 0
*/
int i,j;
for(i=0;i<=NB_LIGNE-1;i++){
for(j=0;j<=NB_COLONNE-1;j++){
mat[i][j]=0;
}
}
}

void afficher_numeros(void){
/*SPEC
Dessine le numéro des NB_LIGNE lignes et des
NB_COLONNE en face de chaque lignes/colonnes.
*/
int i;
char a[5];
set_drawing_color(color_BLACK);
for(i=1;i<=NB_LIGNE;i++){
sprintf(a,"%d",i);
draw_string(C-I/2,D+(i*I)-(I/2),a);
}
for(i=1;i<=NB_COLONNE;i++){
sprintf(a,"%d",i);
draw_string(C+(I*i)-(I/2),D-(I/2),a);
}
update_graphics();
}

void afficher_grille(void){
/*SPEC
Affiche une grille de taille NB_LIGNE *
NB_COLONNE à partir des coordonnées initiales (C,D).
*/
int i,j;
set_drawing_color(color_BLACK);
for(j=1;j<=NB_COLONNE;j++){
for(i=1;i<=NB_LIGNE;i++){
draw_rectangle(C,D,C+(j*I),D+(i*I));
}
}
update_graphics();
}

void jeu(int mode, MATRICE mat){
/*SPEC
Lance le jeu dans le mode voulu (joueur vs joueur ou
joueur vs ia). Cette fonction va également orchestrer la coordination et
le lancement des fonctions du jeu (placement,verifications...). Elle s’arrête si sortie = 1 (le jeu est
finit).
*/
int joueur,sortie=0,x=0,y=0,a=x,b=y,bouger=0,place=0,touche,ia=0;
touche=0;
joueur=2;
while(sortie!=1){
place=0;
joueur_actuel(&joueur);
if(mode==2){// Si on choisit de combatre l'IA alors le placement du pion pour celle ci se fait de maniere differente
 if(joueur==2){
            if(ia==0){
                    x=rand()%NB_COLONNE;
                while(case_vide(mat,x,0)==0){
                    x=rand()%NB_COLONNE;
                }
                placement(mat,x,0,2);//le premier pion de l'IA est place aleatoirement
                ia=1;
                place=1;
            }else{
                intelligence_artificielle(mat,&place,&x,&y);
            }
 }else{
        curseur(a+1,b+1,mat);
 }
}else{
curseur(a+1,b+1,mat);
}
while(place==0){//Cette partie concerne le cas ou un joueur place un pion
detection_mouvement(&a,&b,&touche);
bouger=dans_la_grille(a,b);
if(bouger!=0){
    curseur(a+1,b+1,mat);
    x=a;y=b;
    if(touche==key_INSERT){
        bouger=case_vide(mat,a,b);
        if(bouger==1){
            bouger=puissance4(mat,a,b);
            if(bouger==1){
                placement(mat,a,b,joueur);
                place=1;
        }
    }
}
        //}
}
a=x;
b=y;
}
touche=0;
//on verifie si le pion declenche une victoire ou une egalite
if(alignement_horizontal(mat,joueur,x,y,4)!=1&&alignement_vertical(mat,joueur,x,y,4)!=1&&alignement_diagonal_m(mat,joueur,x,y,4)!=1&&alignement_diagonal_d(mat,joueur,x,y,4)!=1){
    sortie=grille_pleine(mat);
    if(sortie==1){
        gagnant(0,mode);
    }
}else{
    sortie=1;
    gagnant(joueur,mode);
}
joueur_actuel(&joueur);
if(alignement_horizontal(mat,joueur,x,y,4)==1&&alignement_vertical(mat,joueur,x,y,4)==1&&alignement_diagonal_m(mat,joueur,x,y,4)==1&&alignement_diagonal_d(mat,joueur,x,y,4)==1){
    sortie=1;
    gagnant(joueur,mode);
}
    joueur_actuel(&joueur);
}
}

void tours(int joueur){
/*SPEC
Affiche le joueur dont c’est le tour en fonction de la
variable joueur.
*/
char a[3],b[20];
sprintf(a,"%d",joueur);
strcpy(b,"Tour au joueur: ");
strcat(b,a);
set_drawing_color(color_WHITE);
draw_rectangle_full(0,WINDOW_HEIGHT-20,100,WINDOW_HEIGHT);
set_drawing_color(color_BLACK);
draw_string(0,WINDOW_HEIGHT-20,b);
//update_graphics();
}

void gagnant(int joueur, int mode){
/*SPEC
Affiche quand la partie est finnie puis le joueur qui a gagné ou affiche le cas où la
partie ne peut être continuée.
*/
set_drawing_color(color_WHITE);
draw_rectangle_full(0,WINDOW_HEIGHT-20,100,WINDOW_HEIGHT);
set_drawing_color(color_LIGHTMAGENTA);
set_font(font_HELVETICA_18);
draw_string(WINDOW_WIDTH/2.3,WINDOW_HEIGHT-30,"STOP !");// Pour que les joueur aient le temps de voir comment ils ont gagne/perdu
set_drawing_color(color_BLACK);
update_graphics();
get_key();
clear_screen();
update_graphics();
clear_screen();
if(joueur>0){//Ce que l'on affiche quand l'un des joueurs a gagne
        char a[2],b[25];
        set_font(font_HELVETICA_18);
        if(joueur==2&&mode==2){
        strcpy(b,"L'ordinateur a gagne !");
        }else{
        sprintf(a,"%d",joueur);
        strcpy(b,"Le joueur ");
        strcat(b,a);
        strcat(b," a gagne !");
        }
        set_drawing_color(color_BLACK);
        draw_string(WINDOW_WIDTH/3,WINDOW_HEIGHT/2,b);
        set_font(font_HELVETICA_12);
        draw_string(WINDOW_WIDTH/3,(WINDOW_HEIGHT/2)-20,"Appuyez sur n'importe quelle touche pour revenir au menu");
        if(joueur==1){
            set_drawing_color(color_YELLOW);
        }else{
            set_drawing_color(color_LIGHTRED);
        }
        draw_circle_full(WINDOW_WIDTH/4,WINDOW_HEIGHT/2,20);
}else{//Ce que l'on affiche en cas de grille pleine
        set_font(font_HELVETICA_18);
        set_drawing_color(color_BLACK);
        draw_string(WINDOW_WIDTH/3,WINDOW_HEIGHT/2,"La grille est pleine, match nul !");
        set_font(font_HELVETICA_12);
        draw_string(WINDOW_WIDTH/3,(WINDOW_HEIGHT/2)-20,"Appuyez sur n'importe quelle touche pour revenir au menu");
}
update_graphics();
}

void curseur(int x,int y,MATRICE mat){
/*SPEC
Affiche un curseur et le déplace en (x,y). Ce curseur
est celui qu’utilise l’utilisateur pour positionner un pion.
*/
set_drawing_color(color_GREEN);
draw_rectangle_full(C+((x-1)*I),D+((y-1)*I),C+((x-1)*I)+I,D+((y-1)*I)+I);
redessiner(mat);
update_graphics();
set_drawing_color(color_BLACK);
draw_rectangle_full(C+((x-1)*I),D+((y-1)*I),C+((x-1)*I)+I,D+((y-1)*I)+I);
set_drawing_color(color_WHITE);
draw_rectangle_full(C+((x-1)*I)+1,D+((y-1)*I)+1,C+((x-1)*I)+I-1,D+((y-1)*I)+I-1);
//on redessine la case sans actualiser pour que le curseur reste visible mais sera remplace par une case vide a la prochaine actualisation

}

void valide(int joueur, int x, int y){
/*SPEC
Affiche un pion dont la couleur varie en fonction du
joueur aux coordonnées (x,y).
*/
if(joueur==1){
 set_drawing_color(color_YELLOW);
}else{
 set_drawing_color(color_LIGHTRED);
}
draw_circle_full(C+((x-1)*I)+I/2,D+((y-1)*I)+I/2,I/2);
}

void vider_la_grille(){
/*SPEC
Vide la grille de taille NB_LIGNE * NB_COLONNE
*/
set_drawing_color(color_WHITE);
draw_rectangle_full(C,D,C+(NB_COLONNE*I),D+(NB_LIGNE*I));
afficher_grille();
afficher_numeros();
update_graphics();
}

void redessiner(MATRICE mat){
/*SPEC
Redessine les pions contenus dans la grille en fonction
de la matrice mat
*/
int i,j;
for(i=NB_LIGNE-1;i>=0;i--){
    for(j=0;j<NB_COLONNE;j++){
            if(mat[i][j]>0){
                valide(mat[i][j],j+1,NB_LIGNE-i);
            }
    }
}
update_graphics();
}

void joueur_actuel(int *joueur){
/*SPEC
Détermine le joueur qui doit jouer en fonction du
joueur précédent. Met le résultat dans la variable joueur. Affiche
également à l’écran le joueur actuel.
*/
if(*joueur==1){
    *joueur=2;
}else{
    *joueur=1;
}
tours(*joueur);
}

void detection_mouvement(int *x,int *y,int *touche){
/*SPEC
Détecte les touches appuyées et les renvoie par
référence. Quand il s’agit de touches de mouvements (↑→↓←), la
fonction renvoie également par référence la valeur des coordonnées
(x, y) que provoque ce mouvement.
*/
    int t=0;
    t=get_key();
        switch(t){
        case key_UP:
            *touche=0;*y=(*y)+1;
            break;
        case key_DOWN:
            *touche=0;*y=(*y)-1;
            break;
        case key_LEFT:
            *touche=0;*x=(*x)-1;
            break;
        case key_RIGHT:
            *touche=0;*x=(*x)+1;
            break;
        case key_INSERT:
            *touche=key_INSERT;
            break;
        case 32:
            //touche espace
            *touche=key_INSERT;
            break;
        case key_ESCAPE:
            exit(0);
            break;
        default:
            *touche=0;
            break;
        }
}

int dans_la_grille(int x,int y){
/*SPEC
Détermine si l’objet aux coordonnées (x,y) sera dans
la grille. Le résultat est un booléen.
*/
if(x>=0 && y>=0 && x<NB_COLONNE && y<NB_LIGNE){
    return 1;
}else{
    return 0;
}
}

int case_vide(MATRICE mat,int x,int y){
/*SPEC
Détermine si l’objet aux coordonnées (x,y) n’écrasera
pas un autre pion. Le résultat est un booléen.
*/
if(mat[NB_LIGNE-1-y][x]==0){
    return 1;
}
else{
    return 0;
}
}

int puissance4(MATRICE mat,int x,int y){
/*SPEC
Détermine si l’objet aux coordonnées (x,y) respecte
les règles du puissance 4 : Il y a un pion en dessous ou on est tout en
bas de la grille. Le résultat est un booléen.
*/

if(y==0||mat[NB_LIGNE-y][x]!=0){
    return 1;
}else{
    return 0;
}
}

void placement(MATRICE mat,int x,int y,int joueur){
/*SPEC
Place dans la matrice le pion de la couleur du joueur
aux coordonnées données. Le pion est également placé à l’écran.
*/
if(joueur==1)
    mat[NB_LIGNE-1-y][x]=1;
else{
    mat[NB_LIGNE-1-y][x]=2;
}
redessiner(mat);
}

int grille_pleine(MATRICE mat){
/*SPEC
Détermine si la matrice est pleine. Renvoie 1 en sortie
si c’est le cas (pour sortir de la boucle) et affiche la fin du jeu.
*/
int i,c=0;
for(i=0;i<NB_COLONNE;i++){
    if(mat[0][i]==0)
        c++;
}
if(c==0){
    return 1;
}else{
    return 0;
}
}

int alignement_horizontal(MATRICE mat,int joueur,int x,int y,int nbr)
{
/*SPEC
Détermine si 4 pions dans la matrice sont alignés
horizontalement dans l'axe des coordonnées du pion (x,y). Renvoie 1 en sortie si c’est le cas (pour sortir de la
boucle).
*/
    int i,o=0,sortie=0;
        for(i=0;i<=NB_COLONNE-1&&o<nbr;i++)
        {
            if(mat[NB_COLONNE-2-y][i]==joueur)
                o++;
            else{
                o=0;
            }
        }
        if(o==nbr){
            sortie=1;
        }
    return sortie;
}

int alignement_vertical(MATRICE mat,int joueur,int x,int y,int nbr)
{
/*SPEC
Détermine si 4 pions dans la matrice sont alignés
verticalement dans l'axe des coordonnées du pion (x,y). Renvoie 1 en sortie si c’est le cas (pour sortir de la
boucle).
*/
    int i,o=0,sortie=0;
        for(i=0;i<=NB_LIGNE-1&&o<nbr;i++)
        {
            if(mat[i][x]==joueur)
                o++;
            else{
                o=0;
            }
        }
        if(o==nbr){
            sortie=1;
        }
    return sortie;
}

int alignement_diagonal_m(MATRICE mat,int joueur,int x,int y,int nbr){
/*SPEC
Détermine si 4 pions dans la matrice sont alignés en
diagonale montante  dans l'axe des coordonnées du pion (x,y). Renvoie 1 en sortie si c’est le cas (pour sortir de
la boucle).
*/
int i,j,o=0;
i=x;j=y;
//on se met sur un coté de la grille, c'est plus façile pour vérifier les diagonales
while(i>0&&j>0){
if(i>=0)
 i--;
if(j>=0)
 j--;
}
x=i;
y=NB_LIGNE-1-j;

while(x<=NB_COLONNE-1&&y>=0&&o<nbr){
if(mat[y][x]==joueur)
 o++;
else{
o=0;
}
x++;
y--;
}
if(o==nbr){
            return 1;
        }
return 0;
}

int alignement_diagonal_d(MATRICE mat,int joueur,int x,int y,int nbr){
/*SPEC
Détermine si 4 pions dans la matrice sont alignés en
diagonale descendante dans l'axe des coordonnées du pion (x,y). Renvoie 1 en sortie si c’est le cas (pour sortir
de la boucle).
*/
int i,j,o=0;
i=x;j=y;
while(i<=NB_COLONNE-1&&j>0){
if(i<=NB_COLONNE-1)
 i++;
if(j>=0)
 j--;
}
x=i;
y=NB_LIGNE-1-j;
while(x>=0&&y>=0&&o<nbr){
if(mat[y][x]==joueur){
 o++;
}else{
o=0;
}
x--;
y--;
}
if(o==nbr){
            return 1;
        }
return 0;
}

void intelligence_artificielle(MATRICE mat,int *place,int *x,int *y){
/*SPEC
Cette procédure permet de faire jouer l'ordinateur contre le joueur.
*/
int i,j,tab[NB_COLONNE][2],t,nbr;
nbr=4;
while(nbr>=2&&*place==0){//on verifie pour tout les nombres d'alignements a tester (4,3,2)
t=0;
i=0;
j=0;
while(i<NB_COLONNE){//On va stocker les coordonnees des cases qui peuvent contenir un pion dans une variable appele tab
while(mat[j][i]==0&&j<NB_LIGNE){//Chaque case de tab contient l'ordonnee ou peut etre place le pion
j++;
}
if(j-1>-1){
tab[t][0]=i;
tab[t][1]=j-1;
}else{
tab[t][0]=i;
tab[t][1]=-1;//si le pion ne peut pas etre place
}
t++;
j=0;
i++;
}
/*on verifie pour chaque case contenu dans tab:
- si J1 etait place la, est-ce que il y aurait un alignement de 4 ou 3 ou 2 pions de ca couleur ?
- si J2 etait place la, est-ce que il y aurait un alignement de 4 ou 3 ou 2 pions de ca couleur ?
Le nombre de pion a tester est contenu dans la variable nbr
*/
for(i=0;i<NB_COLONNE&&*place==0;i++){
if(tab[i][1]!=-1){
mat[tab[i][1]][tab[i][0]]=2;
if((alignement_horizontal(mat,2,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_vertical(mat,2,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_diagonal_m(mat,2,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_diagonal_d(mat,2,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1)&&(*place!=1)){
mat[tab[i][1]][tab[i][0]]=2;
*x=tab[i][0];
*y=NB_LIGNE-1-tab[i][1];
tab[i][1]=-1;
*place=1;
redessiner(mat);
}
if((*place)!=1)
    mat[tab[i][1]][tab[i][0]]=1;
if((alignement_horizontal(mat,1,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_vertical(mat,1,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_diagonal_m(mat,1,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1||alignement_diagonal_d(mat,1,tab[i][0],NB_LIGNE-1-tab[i][1],nbr)==1)&&(*place!=1)){
mat[tab[i][1]][tab[i][0]]=2;
*x=tab[i][0];
*y=NB_LIGNE-1-tab[i][1];
tab[i][1]=-1;
*place=1;
redessiner(mat);
}else{
    if(*place!=1)
        mat[tab[i][1]][tab[i][0]]=0;
}
}
}
if(*place==0)
    nbr--;
}
}

/*SPEC: Ces procédures (facultatives) permettent un débogage plus efficace: la première affiche le contenu de la matrice telle
que les pions sont disposés, la seconde génère des valeurs aléatoires dans la matrice.*/

void aff_mat(MATRICE mat){
    int i,j;
for(i=0;i<NB_LIGNE;i++){
    for(j=0;j<NB_COLONNE;j++){
        printf("[%d]",mat[i][j]);
    }
    printf("\n");
}
printf("\n");
}

void alea_mat(MATRICE mat){
int i,j;
srand(time(0));
for(i=0;i<NB_LIGNE;i++){
    for(j=0;j<NB_COLONNE;j++){
        mat[i][j]=rand()%3;
    }
}
}


int main(void){
/*SPEC:
Initialise tout, demande le mode auquel on veut jouer
et lance la fonction jeu.
*/
int mode=0;
MATRICE mat;
/*
C=WINDOW_WIDTH/7;D=WINDOW_HEIGHT/7;
if(WINDOW_WIDTH<WINDOW_HEIGHT){
I=(0.99*(WINDOW_WIDTH-C))/NB_COLONNE;
}else{
I=(0.99*(WINDOW_HEIGHT-C))/NB_LIGNE;
}
*/
start_graphics();
while(1){

alea_mat(mat);
C=WINDOW_WIDTH/5;D=WINDOW_HEIGHT/5;
I=(0.80*(WINDOW_HEIGHT-C))/NB_LIGNE;
redessiner(mat); //Permet de dessiner une serie de pions aleatoires, purement esthetique.
C=WINDOW_WIDTH/7;D=WINDOW_HEIGHT/7;
I=(0.99*(WINDOW_HEIGHT-C))/NB_LIGNE;

set_drawing_color(color_LIGHTRED);
set_font(font_HELVETICA_18);
draw_string(WINDOW_WIDTH/2.5,WINDOW_HEIGHT-40,"PUISSANCE 4");
set_drawing_color(color_BLACK);
set_font(font_HELVETICA_12);

draw_string(C,WINDOW_HEIGHT-80,"A quel mode voulez-vous jouer ? ");
set_drawing_color(color_LIGHTBLUE);
draw_string(C+200,WINDOW_HEIGHT-80,"a.[Joueur VS Joueur] - b.[Joueur VS Ordi]");

set_drawing_color(color_BLACK);
set_font(font_HELVETICA_18);
draw_string(10,70,"Commandes:");
set_font(font_HELVETICA_12);
draw_string(10,50,"[Inserer] ou [Espace] -> Poser un jeton");
draw_string(10,30,"[Fleches directionnelles] -> Positionner un jeton");
draw_string(10,10,"[Echap] -> Quitter");
set_drawing_color(color_LIGHTMAGENTA);
draw_string(WINDOW_WIDTH/1.40,10,"POLIEN");
update_graphics();

mode=get_key();

if(mode==98){
    //set_drawing_color(color_LIGHTRED);
    //draw_string((WINDOW_WIDTH/5),WINDOW_HEIGHT-100,"Ce mode n'est pas disponible, la partie va commencer en J VS J !");
    //update_graphics();
    //get_key();
    mode=2;
}else{
    if(mode==97){
    mode=1;
}else{
    if(mode==key_ESCAPE)
        exit(0);
    mode=1;
}
clear_screen();
}
clear_screen();
afficher_grille();
afficher_numeros();
matrice(mat);
jeu(mode,mat);
get_key();
clear_screen();
update_graphics();
}
stop_graphics();
return 0;
}



re,

HOOOOO de l'Arduino

Bonne continuation

Cordialement,
Le réparateur de PC

re,

 euh ouai...
On peut aussi faire d'autres choses en C .

Bonne journée