Aide placement aléatoire sur une grille (bataille navale)

**dyslesia** · 03/05/2008, 14h57

Bonjour à tous,
Dans le cadre de nos cours de C je doit faire un petit projet, et j'ai choisi de réaliser une bataille navale en graphique (j'utilise allegro, faute de connaitre autre chose...)
Et je bloque totalement à la fonction qui place aléatoirement les bateaux sur la grille (plus particulièrement au cas ou un bateau viendrait à en croiser un autre)

voila la boucle que j'ai deja faite mais qui ne marche pas... :

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
 
for(Tbateaux=0;Tbateaux<5;Tbateaux++)
    {
        direction = nb_aleatoire_0_1(); //on genere la direction du bateau
 
        if(direction == 0) //si direction en x
        {
            while(x[Tbateaux]+(Tbateaux+1)>9&&x[Tbateaux]-(Tbateaux+1)<0) //si ca depasse a gauche ou a droite
            {
                for(i=0;i<Tbateaux+1;i++) // i correspond à la taille du bateau
                {
                    if(bateauxPJ[x[Tbateaux]+i][y[Tbateaux]] == 1) //si le bateau a placer en croise un autre
                    {
                        x[Tbateaux] = nb_aleatoire_1_10();
                        y[Tbateaux] = nb_aleatoire_1_10();
                    }
                }
            }
 
            for(i=0;i<=Tbateaux+1;i++) //une fois qu'on est sur que les bateaux sont bien placés, on les inscrits réellement dans le tableau
            {
                 bateauxPJ[x[Tbateaux]+i][y[Tbateaux]] = 1;
            }
 
        }
    }

Excusez-moi si le code n'est pas très propre...
Merci d'avance pour votre aide!

**Emmanuel Delahaye** · 03/05/2008, 20h54

Envoyé par dyslesia

Bonjour à tous,
Dans le cadre de nos cours de C je doit faire un petit projet, et j'ai choisi de réaliser une bataille navale en graphique (j'utilise allegro, faute de connaitre autre chose...)
Et je bloque totalement à la fonction qui place aléatoirement les bateaux sur la grille (plus particulièrement au cas ou un bateau viendrait à en croiser un autre)

Montre la fonction nb_aleatoire_1_10() ... L'usage est de poster du code compilable...

**dyslesia** · 03/05/2008, 21h06

merci de votre réponse,

voila la fonction nb_aleatoire_1_10() :

Code :

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

1
2
3
4
5
6
 
int nb_aleatoire_1_10(void)
{
    return  (int) ((float) rand() / RAND_MAX * (10));
 
}

Qui est mal nommée d'ailleurs puisqu'elle renvoi un nombre en 0 et 9...

Désolé je suis nouveau sur le forum, je posterais un code entièrement compilable la prochaine fois.
Mais mon soucis n'est pas tellement un problème de programmation mais plus d'algorithmique, en fait trouver la solution en C à mon problème...

**droggo** · 03/05/2008, 23h18

Gia,

Envoyé par dyslesia

Mais mon soucis n'est pas tellement un problème de programmation mais plus d'algorithmique, en fait trouver la solution en C à mon problème...

Il s'agit donc d'implémentation en C, pas d'algorithme, qui est indépendant du langage (en principe

).

**dyslesia** · 04/05/2008, 00h47

Oui voila c'est un souci d'implémentation, je ne connaissait pas le mot mais c'était l'idée

J'ai refait un petit programme compilable qui affiche le nombre de cases de bateaux (logiquement 20 si tout marche bien...) helas ce n'est pas le cas

et le placement des bateaux sur une grille factice (je commence a désespérer) :

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
 
#include <stdio.h>
#include <stdlib.h>
 
int nb_aleatoire_1_10(void);
int nb_aleatoire_0_1(void);
 
int main(void)
{
    srand(time(NULL));
 
   /* *********************************************
     NOM DES VARIABLES DE CASE DE DEPART TIREE ALEATOIREMENT
     DE CHACUN DES BATEAUX
 
     x[0] = n° de case en x du minier             *
     x[1] = n° de case en x du sous-marin         *
     x[2] = n° de case en x de la fregate         *
     x[3] = n° de case en x du destroyer          *
     x[4] = n° de case en x du porte-avion        *
     pareil en y                                  */
 
    int bateauxPJ[10][10];
    int direction;  // entier qui donne la direction du bateau, aleatoirement 0 ou 1
    int x[5];
    int y[5];
    int Tbateaux; // Tbateaux de 1 à 4 (du minier n°1 au porte-avion)
    int i,c;
    int sommebateaux;
 
    for(i=0;i<10;i++) //initialisation du tableau à 0
    {
        for(c=0;c<10;c++)
        {
            bateauxPJ[i][c] = 0;
        }
    }
 
    for(i=0;i<5;i++) //on place les valeurs des cases, p-e incorrectes
    {
        x[i] = nb_aleatoire_1_10();
        y[i] = nb_aleatoire_1_10();
    }
 
    for(Tbateaux=0;Tbateaux<5;Tbateaux++)
    {
        direction = nb_aleatoire_0_1(); //on genere la direction du bateau
 
        if(direction == 0) //si direction en x
        {
            i = 0;
            while(x[Tbateaux]+(Tbateaux+1)>9) //si ca depasse a droite
            {
                while(bateauxPJ[x[Tbateaux]+i++][y[Tbateaux]] == 1) //si le bateau a placer en croise un autre
                {
                    x[Tbateaux] = nb_aleatoire_1_10();
                    y[Tbateaux] = nb_aleatoire_1_10();
                    if(i>Tbateaux+1) i = 0;
                }
            }
 
            for(i=0;i<=Tbateaux+1;i++) //une fois qu'on est sur que les bateaux sont bien placés, on les inscrits
            {
                bateauxPJ[x[Tbateaux]+i][y[Tbateaux]] = 1;
            }
 
        }
 
        else if(direction == 1) //si direction en y
        {
            i = 0;
            while(y[Tbateaux]+(Tbateaux+1)>9)
            {
                while(bateauxPJ[x[Tbateaux]][y[Tbateaux]+i++] == 1)
                {
                    x[Tbateaux] = nb_aleatoire_1_10();
                    y[Tbateaux] = nb_aleatoire_1_10();
                    if(i>Tbateaux+1) i = 0;
                }
            }
 
            for(i=0;i<=Tbateaux+1;i++) 
            {
                 bateauxPJ[x[Tbateaux]][y[Tbateaux]+i] = 1;
            }
        }
    }
 
    sommebateaux = 0;
 
    for(i=0;i<10;i++)
    {
        for(c=0;c<10;c++)
        {
            sommebateaux = sommebateaux + bateauxPJ[i][c];
        }
    }
 
    printf("nombre de bateaux : %d\n\n",sommebateaux);
 
    for(i=0;i<10;i++)
    {
        printf(" \n");
        for(c=0;c<10;c++)
        {
            if (bateauxPJ[i][c] == 0) printf("+");
            else if (bateauxPJ[i][c] == 1) printf("#");
        }
    }
 
return 0;
}
 
int nb_aleatoire_1_10(void)
{
    return  (int) ((float) rand() / RAND_MAX * (10));
}
int nb_aleatoire_0_1(void)
{
    return  (int) ((float) rand() / RAND_MAX *2);
}

J'ai modifié au passage la fonction du placement aléatoire...cela me parait un peu plus correct mais c'est pas très propre et manifestement c'est toujours pas ca...
Merci de votre aide

**Emmanuel Delahaye** · 04/05/2008, 09h44

Envoyé par dyslesia

J'ai refait un petit programme compilable qui affiche le nombre de cases de bateaux (logiquement 20 si tout marche bien...) helas ce n'est pas le cas

et le placement des bateaux sur une grille factice (je commence a désespérer) :

Il manque <time.h>

J'ai du mal à comprendre cet algorithme...

Quel est le nombre de bateaux à placer par catégorie ?
Quelles sont les règles de placement des bateaux ?

Je verrais ça plutôt comme ç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
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
 
/*
   Bataille navale
*/
 
#include <stdio.h>
 
#define NELEM(a) (sizeof(a)/sizeof*(a))
 
typedef enum
{
   WATER,
   STS_NB
}
sts_e;
 
struct play
{
   sts_e a[10][10];
};
 
void play_init (struct play *this)
{
   size_t i;
   for (i = 0; i < NELEM (this->a); i++)
   {
      size_t j;
      for (j = 0; j < NELEM (*this->a); j++)
      {
         this->a[i][j] = WATER;
      }
   }
}
 
void play_display (struct play const *this)
{
   size_t i;
   for (i = 0; i < NELEM (this->a); i++)
   {
      size_t j;
      for (j = 0; j < NELEM (*this->a); j++)
      {
         printf ("%2d", this->a[i][j]);
      }
      puts ("");
   }
   puts ("");
}
 
typedef enum
{
   UNDEFINED,
   N,
   S,
   E,
   W,
   DIR_NB
}
dir_e;
 
struct boat
{
   /* position */
   int x0;
   int y0;
   dir_e dir;
 
   /* definition */
   int len;
   char const *name;
};
 
/* 
Regles de placement
 
Les bateaux sont droits
les bateaux peuvent toucher le bord
 
les bateaux ne peuvent se toucher, même par le coin
 
NON :
XXX
   XXX
 
OUI :
XXX
    XXX
*/
void placement (struct play *p_play, struct boat *p_boat)
{
   printf ("Placement de '%s'\n", p_boat->name);
 
{
   /* tirage du x */
}
 
}
 
int main (void)
{
/* zone de jeux */
   struct play play;
 
   /* liste des bateaux a placer */
   struct boat a_boats[] = {
      {0, 0, UNDEFINED, 5, "Porte avion"},
 
      {0, 0, UNDEFINED, 4, "Cuirassier"},
 
      {0, 0, UNDEFINED, 3, "Destroyer 1"},
      {0, 0, UNDEFINED, 3, "Destroyer 2"},
 
      {0, 0, UNDEFINED, 2, "Fregate 1"},
      {0, 0, UNDEFINED, 2, "Fregate 2"},
      {0, 0, UNDEFINED, 2, "Fregate 3"},
 
      {0, 0, UNDEFINED, 1, "Vedette 1"},
      {0, 0, UNDEFINED, 1, "Vedette 2"},
      {0, 0, UNDEFINED, 1, "Vedette 3"},
      {0, 0, UNDEFINED, 1, "Vedette 4"},
   };
 
   size_t i;
 
randomize();
 
   play_init (&play);
   play_display (&play);
 
   for (i = 0; i < NELEM (a_boats); i++)
   {
      struct boat *p = a_boats + i;
      placement (&play, p);
   }
 
   play_display (&play);
 
   return 0;
}

**dyslesia** · 04/05/2008, 14h24

Merci bien!
je vais me pencher sur ce code car je ne crois pas que ce soit de mon niveau...enfin il y a les structures et 2-3 autres petites choses que je n'aient pas encore vu.

Sinon le nombre de bateaux est de 6 allant d'une taille de 2 à 6 cases, j'ai choisi 2 de 2 cases et 1 pour chaque autre taille.
Les règles de placement sont libres, tant qu'ils ne se croisent pas et ne sortent pas de la grille.
Je vous tient au courant, merci encore.

EDIT : voila j'ai regardé je comprend mieux deja, c'est vrai que les structures c'est puissant!, mais je ne suis pas assez a l'aise avec encore.
Il n'y a plus que ca que je ne comprend pas
:

Code :

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

#define NELEM(a) (sizeof(a)/sizeof*(a))

ainsi que DIR_NB et STS_NB dans les typedef enum

**Emmanuel Delahaye** · 04/05/2008, 16h05

Envoyé par dyslesia

Sinon le nombre de bateaux est de 6 allant d'une taille de 2 à 6 cases, j'ai choisi 2 de 2 cases et 1 pour chaque autre taille.
Les règles de placement sont libres, tant qu'ils ne se croisent pas et ne sortent pas de la grille.

Il peuvent se toucher ?

Code :

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

#define NELEM(a) (sizeof(a)/sizeof*(a))

C'est un mécanisme basé sur la définition d'un tableau qui retourne le nombre d'éléments d'un tableau.

ainsi que DIR_NB et STS_NB dans les typedef enum

Ce sont des constantes qui désignent automatiquement le nombre de valeurs définies avant.

J'ai fait un algorithme de placement basé sur le principe énoncé au-dessus :

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
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
 
/*
   Bataille navale
*/
 
/* http://delahaye.emmanuel.free.fr/clib/ */
#include "ed/inc/random.h"
#include "ed/inc/prt.h"
 
#include <stdio.h>
#include <assert.h>
 
#define NELEM(a) (sizeof(a)/sizeof*(a))
 
typedef enum
{
   WATER,
   BOAT,
   SEEN,
   STS_NB
}
sts_e;
 
struct elem
{
   sts_e sts;
   char const *id;
};
 
struct play
{
   struct elem a[20][20];
};
 
void play_init (struct play *this)
{
   size_t y;
   for (y = 0; y < NELEM (this->a); y++)
   {
      size_t x;
      for (x = 0; x < NELEM (*this->a); x++)
      {
         this->a[y][x].sts = WATER;
         this->a[y][x].id = "~~";
      }
   }
}
 
void play_display (struct play const *this)
{
   size_t y;
   for (y = 0; y < NELEM (this->a); y++)
   {
      size_t x;
      for (x = 0; x < NELEM (*this->a); x++)
      {
         printf ("%2d", this->a[y][x].sts);
      }
      puts ("");
   }
   puts ("");
}
 
void play_display_boats (struct play const *this)
{
   size_t y;
   for (y = 0; y < NELEM (this->a); y++)
   {
      size_t x;
      for (x = 0; x < NELEM (*this->a); x++)
      {
         printf ("%2s", this->a[y][x].id);
      }
      puts ("");
   }
   puts ("");
}
 
typedef enum
{
   N,
   S,
   E,
   W,
   DIR_NB,
   UNDEFINED
}
dir_e;
 
struct boat
{
   /* position */
   int x0;
   int y0;
   dir_e dir;
 
   /* definition */
   int len;
   char const *id;
   char const *name;
};
 
static void put_boat (struct play *p_play, struct boat *p_boat)
{
   int i;
   for (i = 0; i < p_boat->len; i++)
   {
      switch (p_boat->dir)
      {
      case N:
         {
            struct elem *p =
               &p_play->a[p_boat->y0 - p_boat->len + 1 + i][p_boat->x0];
            p->sts = BOAT;
            p->id = p_boat->id;
         }
         break;
      case S:
         {
            struct elem *p = &p_play->a[p_boat->y0 + i][p_boat->x0];
            p->sts = BOAT;
            p->id = p_boat->id;
 
         }
         break;
      case E:
         {
            struct elem *p = &p_play->a[p_boat->y0][p_boat->x0 + i];
            p->sts = BOAT;
            p->id = p_boat->id;
         }
         break;
      case W:
         {
            struct elem *p =
               &p_play->a[p_boat->y0][p_boat->x0 - p_boat->len + 1 + i];
            p->sts = BOAT;
            p->id = p_boat->id;
         }
         break;
      default:
         /* gros bug ! */
         assert (0);
      }
   }
}
 
/* check */
static int room_enough (struct play const *p_play, struct boat const *p_boat,
                        int x0, int y0, int dir)
{
   int ok = 1;
   int i;
   for (i = 0; ok && i < p_boat->len; i++)
   {
      switch (dir)
      {
      case N:
         {
            int y = y0 - p_boat->len + 1 + i;
            PRT_I (y);
            ok = y >= 0 && p_play->a[y][x0].sts == WATER;
         }
         break;
      case S:
         {
            int y = y0 + i;
            ok = y < (int) NELEM (p_play->a) && p_play->a[y][x0].sts == WATER;
         }
         break;
      case E:
         {
            int x = x0 + i;
            ok = x < (int) NELEM (*p_play->a)
               && p_play->a[y0][x].sts == WATER;
         }
         break;
      case W:
         {
            int x = x0 - p_boat->len + 1 + i;
            ok = x >= 0 && p_play->a[y0][x].sts == WATER;
         }
         break;
      default:
         /* gros bug ! */
         assert (0);
      }
   }
 
   return ok;
}
 
void mark_ns (struct play *p_play, dir_e dir, int x0, int xlen, int y0,
              int ylen)
{
   int x;
   for (x = -1; x < xlen + 1; x++)
   {
      int xx = x0 + x;
      if (xx >= 0 && xx < (int) NELEM (*p_play->a))
      {
         int y;
         for (y = -1; y < ylen + 1; y++)
         {
            int yy = -1;
            switch (dir)
            {
            case N:
               yy = y0 - ylen + 1 + y;
               break;
            case S:
               yy = y0 + y;
               break;
            default:
               assert (0);
            }
            if (yy != -1)
            {
               if (yy >= 0 && yy < (int) NELEM (p_play->a))
               {
                  if (p_play->a[yy][xx].sts == WATER)
                  {
                     p_play->a[yy][xx].sts = SEEN;
                     p_play->a[yy][xx].id = "||";
                  }
               }
            }
         }
      }
   }
}
 
void mark_ew (struct play *p_play, dir_e dir, int x0, int xlen, int y0,
              int ylen)
{
   int x;
   for (x = -1; x < xlen + 1; x++)
   {
      int xx = -1;
      switch (dir)
      {
      case W:
         xx = x0 - xlen + 1 + x;
         break;
      case E:
         xx = x0 + x;
         break;
      default:
         assert (0);
      }
      if (xx != -1)
      {
         if (xx >= 0 && xx < (int) NELEM (*p_play->a))
         {
            int y;
            for (y = -1; y < ylen + 1; y++)
            {
               int yy = y0 + y;
               if (yy >= 0 && yy < (int) NELEM (p_play->a))
               {
                  if (p_play->a[yy][xx].sts == WATER)
                  {
                     p_play->a[yy][xx].sts = SEEN;
                     p_play->a[yy][xx].id = "==";
                  }
               }
            }
         }
      }
   }
}
 
static void mark_boat (struct play *p_play, struct boat const *p_boat)
{
   switch (p_boat->dir)
   {
   case N:
   case S:
      mark_ns (p_play, p_boat->dir, p_boat->x0, 1, p_boat->y0, p_boat->len);
      break;
   case E:
   case W:
      mark_ew (p_play, p_boat->dir, p_boat->x0, p_boat->len, p_boat->y0, 1);
      break;
   default:
      assert (0);
   }
}
 
/*
Regles de placement
 
Les bateaux sont droits
les bateaux peuvent toucher le bord
 
les bateaux ne peuvent se toucher, même par le coin
 
NON :
XXX
   XXX
 
OUI :
XXX
    XXX
*/
void placement (struct play *p_play, struct boat *p_boat)
{
   printf ("Placement de '%s'\n", p_boat->name);
 
   {
      /* tirage du x et du y */
      int x;
      int y;
      dir_e dir;
      int err;
 
      do
      {
         err = 0;
 
         x = random (NELEM (p_play->a));
         y = random (NELEM (*p_play->a));
 
         err = p_play->a[x][y].sts != WATER;
 
         if (!err)
         {
            dir = random (DIR_NB);
 
            err = !room_enough (p_play, p_boat, x, y, dir);
         }
      }
      while (err);
 
      p_boat->x0 = x;
      p_boat->y0 = y;
      p_boat->dir = dir;
 
      put_boat (p_play, p_boat);
      mark_boat (p_play, p_boat);
 
   }
 
}
 
int main (void)
{
/* zone de jeux */
   struct play play;
 
   /* liste des bateaux a placer */
   struct boat a_boats[] = {
      {0, 0, UNDEFINED, 5, "PA", "Porte avion"},
 
      {0, 0, UNDEFINED, 4, "CU", "Cuirassier"},
 
      {0, 0, UNDEFINED, 3, "D1", "Destroyer 1"},
      {0, 0, UNDEFINED, 3, "D2", "Destroyer 2"},
 
      {0, 0, UNDEFINED, 2, "F1", "Fregate 1"},
      {0, 0, UNDEFINED, 2, "F2", "Fregate 2"},
      {0, 0, UNDEFINED, 2, "F3", "Fregate 3"},
 
      {0, 0, UNDEFINED, 1, "V1", "Vedette 1"},
      {0, 0, UNDEFINED, 1, "V2", "Vedette 2"},
      {0, 0, UNDEFINED, 1, "V3", "Vedette 3"},
      {0, 0, UNDEFINED, 1, "V4", "Vedette 4"},
 
   };
 
   size_t i;
 
   randomize ();
 
   play_init (&play);
   play_display (&play);
 
   for (i = 0; i < NELEM (a_boats); i++)
   {
      struct boat *p = a_boats + i;
      placement (&play, p);
   }
 
   play_display (&play);
   play_display_boats (&play);
 
   return 0;
}

- J'ai augmenté la taille de l'aire de jeu à 20x20
- J'ai mis un certain nombre de bateaux qui n'est probablement pas ta répartition (facile à adapter)
- J'ai ajouté la consigne 'les bateaux ne doivent pas se toucher'.

**dyslesia** · 09/05/2008, 21h08

Merci beaucoup pour votre aide,
j'ai reprogrammé la gestion des bateaux en utilisant des structures et ca me facilite beaucoup la vie!
encore merci !

Aide placement aléatoire sur une grille (bataille navale)

C

Discussions similaires

Partager

Partager