Discussion :

[walase]

Bonjour,

Je souhaite diviser mon programme en plusieurs partie et lorsque je compile mon main j'obtiens ce message :

main.c:(.text.startup+0x29): undefined reference to `createLabyrinth'

main.c:(.text.startup+0x31): undefined reference to `afficheLabyrinth'

j'utilise geany

Mon fichier main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <stdio.h>
#include <stdlib.h>
#include "graphics.h"
#include "labyrinthe.h"
 
int main()
{
	init_graphics(MAX,MAX);	
	Case L[NBCASELONG][NBCASELARGE];
 
	createLabyrinth(L);
	afficheLabyrinth(L);
 
	wait_escape();
	exit(0);
}

labyrinthe.c contient bien labyrinthe.h et ses fonctions et labyrinthe.h est comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <stdlib.h>
 
#define WALL 1 
#define PATH 0
#define MAX 600
#define MAX 600
#define LONGUEURCASE 30
#define LARGEURCASE 30
#define NBCASELONG MAX/LONGUEURCASE
#define NBCASELARGE MAX/LARGEURCASE
#define RAYON (LONGUEURCASE/2.2)
 
 typedef struct Case{
	POINT pos;
	int mh; // mur haut
	int mg; // mur gauche
	int md; // mur droit
	int mb; // mur bas
}Case;
 
typedef struct Direction{
	int VectX;
	int VectY;
}Direction;
 
 Direction initDirection();
 Direction changeDirection(Direction dir, int deplace);
 void initLabyrinth(Case L[NBCASELONG][NBCASELARGE]);
 int connecte(Case connect[], Case c, int nbConnect);
 void createLabyrinth(Case L[NBCASELONG][NBCASELARGE]);
 void afficheCase(Case c);
 void afficheLabyrinth(Case L[NBCASELONG][NBCASELARGE]);

j'ai oublié quelque chose mais je vois pas et lorsque dans le main je supprime les 2 lignes create et affiche du coup j'ai bien mon graphique qui s'affiche mais rien dedans ce qui est normal

merci de votre aide

[Metalman]

Tes procédures ont été mises dans d'autres fichiers ?

Il faudrait "plutôt" les déclarer dans les .h associés à ces fichiers (simplement pour rester bien organisé), et ne pas oublier ces fichiers dans la ligne de compilation ! (les .h ne sont pas nécessaires à la compilation, tant qu'ils sont bine en include)

EDIT : tu cherches à générer des .o ou le binaire final ?
Si tu ne veux faire que des .o sans linker, n'oublie pas l'argument "-c" à gcc !

[walase]

geany compile automatiquement , je compile pas par le terminal :/

[Metalman]

Hmmm... je ne peux pas vraiment installer de logiciel là où je suis (ni spécialement envie de tester geany pour te l'avouer ^^'), mais sur un screenshot je vois un menu "Projet"... et "Build" !

As-tu par hasard des champs quelque part dans ces menus te permettant de mettre plusieurs sources dans le projet ?

L'erreur qui t'est remontée t'indique en fait qu'il n'arrive pas à créer un exécutable, car 2 fonctions "déclarées ailleurs" n'arrivent pas à être liées à ton fichier main.c

[walase]

Donc en fait si je prends par le terminal je devrais écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

c'est bien ça ?

[Metalman]

Si toutes tes sources sont dans ces 2 fichiers, oui !

[walase]

Aparament c'est plutot un probleme de makefile et je m'y connais pas trop
mon makefile de base est composé comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CC=gcc
CFLAGS=-O2 -Wall `sdl-config --cflags`
LIBS=`sdl-config --libs` -lm -lSDL_ttf
 
#Cible generique pour Linux
%: graphics.o %.c
	rm -f $@
	$(CC) $(CFLAGS) graphics.o $@.c -o $@ $(LIBS)
 
graphics.o: graphics.c graphics.h
	rm -f police.h
	touch police.h
	if test -e /usr/include/SDL_ttf.h;           then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/include/SDL/SDL_ttf.h;       then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL_ttf.h;     then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL/SDL_ttf.h; then echo "#define SDL_TTF_OK" > police.h; fi
	$(CC) $(CFLAGS) -c graphics.c
 
clean:
	rm -f police.h

c'est notre makefile de base pour les cours , et il faudrait rajouter du coup un labyrinthe.o etc je pense

edit:
j'ai donc fait :
labyrinthe.o : labyrinthe.c labyrinthe.h $(CC) $(CFLAGS) -o labyrinthe.o -c labyrinthe.c $(LIBS)

main: labyrinthe.o labyrinthe.h $(CC) -Wall -o main labyrinthe.o $(LIBS)

mais je sais pas si le fichier.o je dois le créer ou si il se crée automatiquement

[kwariz]

Bonsoir,

Effectivement ton makefile n'est pas prévu pour de la «compilation séparée» avec des modules que tu écris toi même.
D'après ce que tu écris je déduis que pour construire ton exécutable, geany va simplement lancer un `make main` ce qui avec ton makefile va compiler main.c et lier le résultat avec graphics.o et les bibliothèques qu'il faut.
Tu as le choix entre patcher «salement» (à mon avis) en rajoutant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
labyrinthe.o: labyrinthe.c graphics.h
	$(CC) $(CFLAGS) -c labyrinthe.c

pour créer labyrinthe.o (je suppose que labyrinthe.c contient un #include "graphics.h"). Puis de dire que tu as besoin de labyrinthe.o pour créer ton exécutable et qu'il en dépend. Cela consiste à rejouter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
%: graphics.o %.c labyrinthe.o labyrhinte.h
	rm -f $@
	$(CC) $(CFLAGS) labyrinthe.o graphics.o $@.c -o $@ $(LIBS)

Si tu as envie d'un makefile un peu plus propre tu peux essayer de t'inspirer de celui qui est un peu plus générique dans un de mes projets posté ici : Générateur de combinaisons.

Edit : suite à ton edit
Oui tu donnes la recette de création de labyrinthe.o avec la ligne laburinthe.o: ...
Il n'est crée que si on en a besoin et tu dis en avoir besoin pour créer ton exécutable sur la ligne %: ... il sera donc crée.
Je vois que tu as la bonne idée de rajouter un -Wall .... super !
Tu peux aussi rajouter -Wextra (tu auras encore plus de warnings).

Edit2 : si tu as le temps et l'envie, essaye de te construire un makefile propre et de le poster ici. Nous pourrons t'aider à y arriver si ça te tente.

[walase]

Je t'avouerais que j'ai pu trop le temps ^^
Oui labyrinthe.c contient #include "graphics.h".

je vais vous mettre mes fichiers parce que là je trouve vraiment pas pourquoi
labyrinthe.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
#include <stdio.h>
#include <stdlib.h>
#include "graphics.h"
#include "labyrinthe.h"
 
 
Direction initDirection(){
	Direction dir;
	dir.VectX = 0;
	dir.VectY = 0;
	return dir;
}
 
Direction changeDirection(Direction dir, int deplace)
{
	if(deplace == 0) dir.VectY = -1;
	if(deplace == 1) dir.VectX = +1;
	if(deplace == 2) dir.VectY = +1;
	if(deplace == 3) dir.VectX = -1;
	return dir;
}
 
void initLabyrinth(Case L[NBCASELONG][NBCASELARGE])
{ 
	int i;
	int j;
	for(i = 0; i < NBCASELONG; i++)
	{
		for(j = 0; j < NBCASELARGE; j++)
		{
			L[i][j].pos.x = i;
			L[i][j].pos.y = j;
			L[i][j].mh = WALL;
			L[i][j].mg = WALL;
			L[i][j].md = WALL;
			L[i][j].mb = WALL;
		}
	}
}
 
int connecte(Case connect[], Case c, int nbConnect)
{
	int i;
	for(i = 0; i < nbConnect; i++)
	{
		if((connect[i].pos.x == c.pos.x) && (connect[i].pos.y == c.pos.y))
		{
			return true;
		}
	}
	return false;
}
 
void createLabyrinth(Case L[NBCASELONG][NBCASELARGE])
{ 
	initLabyrinth(L);
	int nbConnect = (NBCASELONG * NBCASELARGE); // nb cases connectées au max
	Case connect [nbConnect];
	connect[0] = L[0][0];
 
	int D_or_H = alea_int(2);
	if(D_or_H == 0)
	{
		connect[1] = L[1][0];
		L[0][0].md = PATH;
		L[1][0].mg = PATH;
	}
	else
	{
		connect[1] = L[0][1];
		L[0][0].mh = PATH;
		L[0][1].mb = PATH;
	}
 
	int choix = 2;
	Direction dir;
	int deplace;
	while(choix < nbConnect)
	{
		int val = alea_int(choix);
		Case c = connect[val];
 
		int test[4] = {-1, -1, -1, -1};
		int compteur = 4;
		while(compteur != 0)
		{
			dir = initDirection();
			deplace = alea_int(4);
			if(test[deplace] == -1)
			{
				test[deplace] = deplace;
				compteur --;
				dir = changeDirection(dir, deplace);
			}
			else continue;
 
			if((c.pos.x + dir.VectX >= 0) && (c.pos.x + dir.VectX < NBCASELONG) && (c.pos.y + dir.VectY >= 0) && (c.pos.y + dir.VectY < NBCASELARGE))
			{
				if(dir.VectX == -1)
				{
					if(connecte(connect, L[c.pos.x - 1][c.pos.y], choix) == false) 
					{
						L[c.pos.x][c.pos.y].mg = PATH;
						L[c.pos.x - 1][c.pos.y].md = PATH;
						connect[choix] = L[c.pos.x - 1][c.pos.y];
						choix++;
						break;
					}
				}
				else if(dir.VectX == 1)
				{
					if(connecte(connect, L[c.pos.x + 1][c.pos.y], choix) == false)
					{
						L[c.pos.x][c.pos.y].md = PATH;
						L[c.pos.x + 1][c.pos.y].mg = PATH;
						connect[choix] = L[c.pos.x + 1][c.pos.y];
						choix++;
						break;
					}
				}
				else if(dir.VectY == -1)
				{
					if(connecte(connect, L[c.pos.x][c.pos.y - 1], choix) == false)
					{
						L[c.pos.x][c.pos.y].mb = PATH;
						L[c.pos.x][c.pos.y - 1].mh = PATH;
						connect[choix] = L[c.pos.x][c.pos.y - 1];
						choix++;
						break;
					}
				}
				else if(dir.VectY == 1)
				{
					if(connecte(connect, L[c.pos.x][c.pos.y + 1], choix) == false)
					{
						L[c.pos.x][c.pos.y].mh = PATH;
						L[c.pos.x][c.pos.y + 1].mb = PATH;
						connect[choix] = L[c.pos.x][c.pos.y + 1];
						choix++;
						break;
					}
				}
			}
		}
	}
	int compteur = 1;
	while(compteur != 0)
	{
		int x = 0;
		int y = 0;
		while(x == 0 || y == 0)
		{
			x = alea_int(NBCASELONG - 1);
			y = alea_int(NBCASELARGE - 1);
		}
		int choix = alea_int(4);
		if(choix == 0)
		{
			L[x][y].mb = PATH;
			L[x][y - 1].mh = PATH;
		}
		else if(choix == 1)
		{
			L[x][y].md = PATH;
			L[x + 1][y].mg = PATH;
		}
		else if(choix == 2)
		{
			L[x][y].mh = PATH;
			L[x][y + 1].mb = PATH;
		}
		else 
		{
			L[x][y].mg =PATH;
			L[x - 1][y].md = PATH;
		}
		compteur--;
	}
}
 
 
void afficheCase(Case c)
{
	POINT p1;
	POINT p2;
	if(c.mg == WALL)
	{
		p1.x = c.pos.x * LONGUEURCASE;
		p1.y = c.pos.y * LARGEURCASE;
		p2.x = c.pos.x * LONGUEURCASE + 1;
		p2.y = c.pos.y * LARGEURCASE + LARGEURCASE;
		draw_fill_rectangle(p1, p2, blanc);
	}
	if(c.mb == WALL)
	{
		p1.x = c.pos.x * LONGUEURCASE;
		p1.y = c.pos.y * LARGEURCASE;
		p2.x = c.pos.x * LONGUEURCASE + LONGUEURCASE;
		p2.y = c.pos.y * LARGEURCASE + 1;
		draw_fill_rectangle(p1, p2, blanc);
	}
	if(c.md == WALL)
	{
		p1.x = c.pos.x * LONGUEURCASE + LONGUEURCASE - 1;
		p1.y = c.pos.y * LARGEURCASE;
		p2.x = c.pos.x * LONGUEURCASE + LONGUEURCASE;
		p2.y = c.pos.y * LARGEURCASE + LARGEURCASE;
		draw_fill_rectangle(p1, p2, blanc);
	}
	if(c.mh == WALL)
	{
		p1.x = c.pos.x * LONGUEURCASE;
		p1.y = c.pos.y * LARGEURCASE + LARGEURCASE - 1;
		p2.x = c.pos.x * LONGUEURCASE + LONGUEURCASE;
		p2.y = c.pos.y * LARGEURCASE + LARGEURCASE;
		draw_fill_rectangle(p1, p2, blanc);
	}
}
 
void afficheLabyrinth(Case L[NBCASELONG][NBCASELARGE])
{
	int i;
	int j;
	for(i = 0; i < NBCASELONG; i++)
	{
		for(j = 0; j < NBCASELARGE; j++)
		{
			afficheCase(L[i][j]);
		}
	}
	//POINT p1, p2;
	/*p1.x = alea_int(rand()%(NBCASELONG));
	p1.y = alea_int(rand()%(NBCASELONG));
	p2.x = MAX - 3;
	p2.y = MAX - 2;
	draw_fill_rectangle(p1, p2, vert);*/
 
}

labyrinthe.h:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <stdlib.h>
 
#define WALL 1 
#define PATH 0
#define MAX 600
#define MAX 600
#define LONGUEURCASE 30
#define LARGEURCASE 30
#define NBCASELONG MAX/LONGUEURCASE
#define NBCASELARGE MAX/LARGEURCASE
#define RAYON (LONGUEURCASE/2.2)
 
 typedef struct Case{
	POINT pos;
	int mh; // mur haut
	int mg; // mur gauche
	int md; // mur droit
	int mb; // mur bas
}Case;
 
typedef struct Direction{
	int VectX;
	int VectY;
}Direction;
 
extern Direction initDirection();
extern Direction changeDirection(Direction dir, int deplace);
extern void initLabyrinth(Case L[NBCASELONG][NBCASELARGE]);
extern int connecte(Case connect[], Case c, int nbConnect);
extern void createLabyrinth(Case L[NBCASELONG][NBCASELARGE]);
extern void afficheCase(Case c);
extern void afficheLabyrinth(Case L[NBCASELONG][NBCASELARGE]);

Mon main.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <stdlib.h>
#include "graphics.h"
#include "labyrinthe.h"
 
 
int main()
{
	init_graphics(MAX,MAX);	
	Case L[NBCASELONG][NBCASELARGE];
 
	createLabyrinth(L);
	afficheLabyrinth(L);
 
	wait_escape();
	exit(0);
}

Bon mon makefile complet que j'ai réessayé de faire en suivant tes consignes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
CC=gcc
CFLAGS=-O2  -Wall `sdl-config --cflags`
LIBS=`sdl-config --libs` -lm -lSDL_ttf
 
#Cible generique pour Linux
%: graphics.o %.c labyrinthe.o labyrhinte.h rm -f $@ $(CC) $(CFLAGS) labyrinthe.o graphics.o $@.c -Wextra -Wall -o $@ $(LIBS)
 
graphics.o: graphics.c graphics.h 
	rm -f police.h
	touch police.h
	if test -e /usr/include/SDL_ttf.h;           then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/include/SDL/SDL_ttf.h;       then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL_ttf.h;     then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL/SDL_ttf.h; then echo "#define SDL_TTF_OK" > police.h; fi
	$(CC) $(CFLAGS) -c graphics.c
 
labyrinthe.o: labyrinthe.c graphics.h labyrinthe.h $(CC) $(CFLAGS) -c labyrinthe.c
 
 
 
clean:
	rm -f police.h

Et lorsque je compile mon main.c par geany cela m'affiche:

main.c:(.text+0x81): undefined reference to `init_graphics'
main.c:(.text+0x89): undefined reference to `createLabyrinth'
main.c:(.text+0x91): undefined reference to `afficheLabyrinth'

je joins mon projet

[kwariz]

Alors la syntaxe du makefile est parfois étrange mais elle doit être respectée. Un des blocs principaux d'un makefile est la recette en gros on a :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
cible: dépendance1 dépendance2 ...
____commande 1
____commande 2

Les ____ doivent impérativement être un caractère TAB sinon ça ne fonctionnera jamais.

Je te proprose le makefile suivant pour ton projet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# On définit le compilateur et les options de compilations                                                                                                                                                                        
CC=gcc
CFLAGS=-O2 -Wall -Wextra `sdl-config --cflags`
LIBS=`sdl-config --libs` -lm -lSDL_ttf
RM=rm -f
 
# On crée la liste de tous les fichiers sources                                                                                                                                                                                   
SRC=$(wildcard *.c)
# On en déduit la liste des fichiers objets                                                                                                                                                                                       
OBJ=$(SRC:.c=.o)
 
# La cible principale sera main (pour garder le même                                                                                                                                                                              
# comportement que l'ancien makefile                                                                                                                                                                                              
# main dépend de tous les fichiers objets                                                                                                                                                                                         
main: $(OBJ)
        $(CC) -o $@ $(LIBS) $^
 
# On explique comment on crée un fichier .o à partir                                                                                                                                                                              
# d'un fichier .c                                                                                                                                                                                                                 
%.o: %.c
        $(CC) $(CFLAGS) -c $< -o $@
 
# À partir d'ici on a plus besoin que de donner les exceptions                                                                                                                                                                    
# au comportement par défaut et les dépendances (il y a moyen                                                                                                                                                                     
# d'automatiser ça aussi mais on va rester simple)                                                                                                                                                                                
 
main.o: main.c graphics.h labyrinthe.h
 
labyrinthe.o: labyrinthe.c graphics.h labyrinthe.h
 
graphics.o: graphics.c graphics.h police.h
 
police.h: graphics.c graphics.h
        if test -e /usr/include/SDL_ttf.h;           then echo "#define SDL_TTF_OK" > police.h; fi
        if test -e /usr/include/SDL/SDL_ttf.h;       then echo "#define SDL_TTF_OK" > police.h; fi
        if test -e /usr/local/include/SDL_ttf.h;     then echo "#define SDL_TTF_OK" > police.h; fi
        if test -e /usr/local/include/SDL/SDL_ttf.h; then echo "#define SDL_TTF_OK" > police.h; fi
 
# Ici on met quelques cibles classiques et pratiques                                                                                                                                                                              
.PHONY: clean
clean:
        $(RM) main $(OBJ) police.h

Bon, il est loin d'être parfait mais il fonctionnera pas trop mal tant que tu n'as qu'un exécutable qui est construit à partir de tous les fichiers sources.

Si tu ajoutes un autre fichier source, il faudra modifier à la main la partie dépendances. Par exemple si tu ajoutes un fichier joueur.c qui possède un header joueur.h que tu inclues uniquement dans le main il faudra modifier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

main.o: main.c graphics.h labyrinthe.h

en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

main.o: main.c graphics.h labyrinthe.h joueur.h

et rajouter la ligne qui définit les dépendances de joueur.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

joueur.o: joueur.c joueur.h <tous les fichiers .h inclus dans ton joueur.c>

Cette étape aussi pourrait aussi s'automatiser.

Edit: le makefile à downloader (au cas où pour les tabs ...)
Makefile.zip

[Metalman]

Essaye avec ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
CC=gcc
CFLAGS=-O2  -Wall `sdl-config --cflags`
LDFLAGS=`sdl-config --libs` -lm -lSDL_ttf
FILE=graphics.c labyrinthe.c main.c
SRC=${FILE}
OBJS=${SRC:.c=.o}
TARGET=monprojet
 
${TARGET}:
	rm -f police.h
	touch police.h
	if test -e /usr/include/SDL_ttf.h;           then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/include/SDL/SDL_ttf.h;       then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL_ttf.h;     then echo "#define SDL_TTF_OK" > police.h; fi
	if test -e /usr/local/include/SDL/SDL_ttf.h; then echo "#define SDL_TTF_OK" > police.h; fi
	make all
 
all: ${OBJS}
	$(CC) $(LDFLAGS) $(OBJS) -o $(TARGET)
 
%.o: %.c
	$(CC) $(CFLAGS) -c $<
 
clean:
	rm -f police.h
	rm -f $(OBJS)
	rm -rf *~
	rm -rf *#*

[walase]

Ah nickel ça fonctionne les gars ! merci énormément !
J'ai pris celui de kwariz
Vous etes géniaux !
edit : j'ai plus cas rajouter mes autres fichiers .c ( genre les perso comme tu as du deviné )