Discussion :

[Ehonn]

Faut mettre à jour son compilateur ^^'
Sous GCC 4.6, le sleep fonctionne (cf ton post précédent avec l'option -std=c++0x).

[Armulis]

J'ai réussi à faire un timer en utilisant la bibliothèque windows.
En gros, j'ai dû entrer ça:

Code :

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

1
2
3
 
#include <windows.h>
Sleep(/*temps en millisecondes/*)

Je ne sais pas si c'est portable sur d'autres consoles, mais pour l'instant j'ai d'autres questions à me poser...

[Iradrille]

A partir du moment où tu inclus windows.h, non ce n'est pas portable et ça compilera seulement sous Windows (voir la doc pour savoir pour quelles versions de Windows ça marchera).

[Ehonn]

Sinon, de façon portable, tu peux faire une attente active en 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
// gcc -Wall -Wextra -std=c99 -pedantic sleep.c -o sleep && time ./sleep
 
#include <time.h> 
 
 
void ms_sleep (unsigned long int ms)
{
	clock_t end = clock() + ms * CLOCKS_PER_SEC / 1000;
	while (clock() < end);
}
 
int main()
{
	ms_sleep(500);
 
	ms_sleep(2000);
 
	return 0;
}

[Iradrille]

une attente active

Je pense qu'entre un code non portable et une attente active, vaut mieux un code non portable

[Armulis]

Salut!

Alors... j'ai plus beaucoup de problèmes pour l'instant, et j'ai réussi à programmer un petit jeu style pokémon (seulement le combat, et j'utilise la console standard en guise d'interface).

J'ai utilisé des structures pour stocker toutes les données de chaque monstre sous un seul nom, et ça a l'air pas mal pour l'instant. Le système de combat est encore un peu brouillon (des monstres beaucoup trop forts, des effets imperceptibles...), mais ça tourne.

À-propos de l'affectation des données "monstres" à la structure "joueur", juste après le choix, j'aimerais avoir un conseil...
Voici un extrait (non-fonctionnel) de mon programme:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
if (reponse_txt==monstre_1.nom)
{
    joueur=monstre_1;
    joueurx=joueur;
}
else if (reponse_txt==monstre_suivant.nom)
{
    joueur=monstre_suivant;
    joueurx=joueur;
}
else

reponse_txt est la saisie que le joueur doit faire sur la console, après avoir vu la liste des monstres disponibles.
Après, je fais une série de "IF" pour tester un-à-un chaque monstre, et sous "ELSE", ça renvoie un truc du stxle "Vous avez fait une faute de frappe".
Les mots comme "monstre_1.nom" permettent d'extraire la valeur d'une variable contenue dans la structure.

Je pense que vous voyez où je veux en venir... En gros, le jour où je me retrouve avec une liste de 500 monstres disponibles, est-ce que je dois tapes une liste de 500 "ELSE IF", ou existe-t-il un moyen de simplifier ça par une boucle?
Si vous avez besoin de précisions, je vous donne tout ce que vous voulez
(le gagnant remportera une copie de mon jeu ^^).

[Iradrille]

Je pense que vous voyez où je veux en venir... En gros, le jour où je me retrouve avec une liste de 500 monstres disponibles, est-ce que je dois tapes une liste de 500 "ELSE IF", ou existe-t-il un moyen de simplifier ça par une boucle?
Si vous avez besoin de précisions, je vous donne tout ce que vous voulez
(le gagnant remportera une copie de mon jeu ^^).

Fais gaffe pour le changement de valeur de joueur et joueurx, la tu aura joueurx == joueur (peut etre voulu, pas trop compris)

Sinon tu peux stocker tes monstres dans une map<string, Monstre> avec le nom du monstre en clef si chaque monstre à un nom différent, sinon dans un vector.
Tu peux les retrouver avec un find après (map.find ou la fonction libre).

[Armulis]

J'ai créé une variable (de type structure) "joueur" et une autre, "joueurx". Lorsque le joueur choisit avec quel monstre (pokémon) il va jouer, les deux structures se voient affecter le même contenu. Mais plus loin dans le programme, seules les valeurs contenues dans "joueurx" sont modifiées, et celles de "joueur" servent d'archives (plafond des vies, base de défense, etc...)...

Merci pour ta réponse, Iradrille, mais j'ai juste besoin d'une indication: tu me proposes une méthode différente, là, c'est ça? (Moi je parlais de faire une boucle)

Si quelqu'un veut un .exe de mon programme, on peut trouver un moyen (je comptais utiliser ci-joint.com, mais ils n'acceptent pas les .exe...)

[ternel]

Bonjour,
pour l'exécutable, donne nous les sources, nous compilerons…
Si cela ne te vas pas, fais un installeur et héberge-le sur un site web

[Armulis]

Ouais, y'a qu'à faire ça.
(parler de .exe sur internet, c'est comme parler de bombes dans un avion... ^^)

Voici l'ensemble du code en l'état actuel.
Si j'arrive à trouver un bon système pour ranger les données de chacun des monstres, je pourrais en faire un peu plus.
L'intelligence artificielle vaut ce qu'elle vaut (c'est-à-dire pas grand chose) pour l'instant, mais pour moi il était seulement question de se familiariser un peu avec le principe.
Concernant le système de combat, il est purement archaïque, et les calculs sont un peu cons si je puis dire. Dans une version future, je verrai si je peux améliorer les calculs...
Bref: si vous voulez vous amuser, tout est là. AU cas où vous le transmettriez, merci de ne pas altérer le premier bloc de commentaires, vous serez chou =D

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
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
// Tactical-RPG basique, programmé en langage C++
// Conception: Michael Baracco
// Version 1.2 (26.02.2013)
 
#include <iostream>
#include <string>
#include <windows.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
 
using namespace std;
 
int main()
{
        // Déclaration de la structure pour stocker les données des monstres
        struct monstre
        {
            string nom;
            string description;
            double vies;
            double puissance;
            double defense;
            double regeneration;
            double bonus_off;
            double bonus_def;
        };
 
        // Variables générales
        int step=1; // étapes du programme
        double m; // variable de travail
        int n; // variable de travail
        string reponse_txt; // réponse du joueur
        string nom; // Nom du joueur
 
        // Monstres en combat
        // Monstre joueur
        struct monstre joueur;
        struct monstre joueurx;
        // Monstre adversaire
        struct monstre adversaire;
        struct monstre adversairex;
 
        // Données des monstres
        // Monstre 1
        struct monstre Pouki
        {
            "Pouki", // nom
            "polyvalent, pas de point fort ou de point faible", // description
            200.0, // vies
            40.0, // puissance
            0.5, // défense
            35.0, // régénération
            0.5, // bonus off
            0.5 // bonus def
        };
        // Monstre 2
        struct monstre Prakata
        {
            "Prakata", // nom
            "resistant, peu offensif", // description
            280.0, // vies
            30.0, // puissance
            0.8, // défense
            40.0, // régénération
            0.0, // bonus off
            0.15 // bonus def
        };
        // Monstre 3
        struct monstre Ponkipopo
        {
            "Ponkipopo", // nom
            "fragile, mais efficace", // description
            130.0, // vies
            60.0, // puissance
            0.2, // défense
            0.0, // régénération
            0.15, // bonus off
            0.1 // bonus def
        };
        // Monstre 4
        struct monstre Toto
        {
            "Toto", // nom
            "ben... c'est Toto, quoi...", // description
            100.0, // vies
            50.0, // puissance
            0.7, // défense
            25.0, // régénération
            0.1, // bonus off
            0.0 // bonus def
        };
        // Monstre 5
        struct monstre Kluburt
        {
            "Kluburt", // nom
            "la bombe atomique: puissant mais pas tres endurant", // description
            75.0, // vies
            70.0, // puissance
            0.1, // défense
            0.0, // régénération
            0.25, // bonus off
            0.0 // bonus def
        };
        // Monstre 6
        struct monstre Flugulune
        {
            "Flugulune", // nom
            "tres technique", // description
            100.0, // vies
            40.0, // puissance
            0.6, // défense
            35.0, // régénération
            0.3, // bonus off
            0.3 // bonus def
        };
        // Monstre 7
        struct monstre Massacrator
        {
            "Massacrator", // nom
            "la bête des bêtes", // description
            250.0, // vies
            60.0, // puissance
            0.3, // défense
            25.0, // régénération
            0.1, // bonus off
            0.1 // bonus def
        };
 
        // Initialisation du générateur aléatoire, pour que la même valeur ne sorte pas toujours en premier
        srand (time(NULL));
 
    // Programme
	while (step!=100) // Tant que le programme n'est pas terminé, le programme tourne
    {
        switch (step)
        {
        case 0: // Lecture de la réponse du joueur
            cin >> reponse_txt;
            step=n; // On retourne à l'étape indiquée par n
        break;
 
        case 1: // L'ordinateur demande le nom du joueur et lui propose un jeu
            cout << "Comment vous appelez-vous?" << endl;
            cin >> nom;
            cout << endl << "OK, bonjour " << nom << endl;
            cout << "                                                  (Suite)" << endl;
            getch();
            cout << "Voulez-vous jouer a un jeu avec moi?" << endl;
            Sleep(500);
            cout << "C'est un tactical RPG, un peu comme Pokemon" << endl << "                                                  (Repondez par oui ou par non)" << endl;
            step=0; n=2; // On va à case 2 après case 0
        break;
 
        case 2: // Analyse
            if (reponse_txt=="oui") // Le joueur veut jouer; l'ordinateur propose d'expliquer les règles
            {
                Sleep(250);
                cout << endl << "Oh merci beaucoup! On peut commencer alors" << endl;
                Sleep(750);
                cout << endl << "Dois-je vous expliquer les regles?" << endl;
                cout <<"                                                  " << "(Repondez par oui ou par non)" << endl;
                step=0; n=3; // On va à case 2 après case 0
            }
            else if (reponse_txt=="non") // Le joueur ne veut pas jouer
            {
                Sleep(250);
                cout << endl << "Dommage... bon, a la prochaine alors!" << endl;
                step=100;
            }
            else // Le joueur n'a pas répondu par oui ou par non, l'ordinateur insiste
            {
                Sleep(750);
                cout << endl << "Heu... quoi? Desole, je n'ai pas compris" << endl;
                Sleep(500);
                cout << "Vous voulez jouer ou pas?" << endl << "                                                  (Repondez par oui ou par non)" <<endl;
                step=0;
            }
        break;
 
        case 3: // Analyse
            if (reponse_txt=="oui") // L'ordinateur doit expliquer les règles au joueur
            {
            Sleep(250);
            cout << endl << "Je vous explique..." << endl;
            Sleep(1000);
            cout << "Ca se passe comme dans Pokemon: chacun choisit un monstre, et on se bat." << endl;
            Sleep(2000);
            cout << "Le premier qui n'a plus de vies a perdu" << endl;
            Sleep(1500);
            cout << "Pour l'instant le jeu n'est pas tres perfectionne" << endl;
            Sleep(1500);
            cout << "La premiere attaque est offensive, les autres sont techniques" << endl;
            Sleep(1500);
            cout << "Voila. Est-ce que je dois vous expliquer ca mieux?" << endl;
            cout << "                                                  " << "(Repondez par oui ou par non)" << endl;
            step=0; n=4; // On va à case 4 après case 0
            }
            else if (reponse_txt=="non") // Le joueur connaît les règles, le jeu peut commencer
            {
                Sleep(250);
                cout << endl << "Ah vous les connaissez deja!";
                reponse_txt="non"; step=4; // On va à case 4, mais la réponse est déjà donnée
            }
            else // Le joueur n'a pas répondu par oui ou par non, l'ordinateur insiste
            {
                Sleep(750);
                cout << endl << "Je n'ai pas compris..." << endl;
                Sleep(250);
                cout << "Dois-je expliquer les règles?" << endl << "                                                  (Repondez par oui ou par non)" <<endl;
                step=0;
            }
        break;
 
        case 4:
            // L'ordinateur explique les règles par un exemple concret
            if (reponse_txt=="oui")
            {
            Sleep(250);
            cout << endl << "Prenons un exemple..." << endl;
            Sleep(1000);
            cout << "Un des monstres s'appelle Pouki." << endl;
            Sleep(1000);
            cout << "Il a un certain nombre de vies, de puissance et de defense." << endl;
            Sleep(1500);
            cout << "Son attaque normale lui permet d'enlever des vies a son adversaire" << endl;
            Sleep(1500);
            cout << "Sa technique lui permet de regagner des vies" << endl;
            Sleep(1500);
            cout << "C'est pas si complique ou bien?" << endl;
                step=5;
            }
            else if (reponse_txt=="non")
            {
                Sleep(500);
                cout << endl << "Parfait!" << endl;
                step=5;
            }
            else
            {
                cout << endl;
                Sleep(750);
                cout << "Je crois que vous avez fait une faute de frappe, " << nom << endl;
                Sleep(250);
                cout << "Est-ce que je dois repeter les regles?" << endl;
                cout << "                                                  " << "(Repondez par oui ou par non)" << endl;
                step=0; n=4; // On va à case 4 après case 0
            }
        break;
 
        case 5: // L'ordinateur présente la liste des monstres disponibles
            cout << "                                                  (Suite)" << endl;
            getch();
            cout << endl << "Ok. Il y a 6 monstres que vous pouvez choisir:" << endl << endl;
            Sleep(750);
            cout << Pouki.nom << ", " << Pouki.description << endl << endl;
            Sleep(1250);
            cout << Prakata.nom << ", " << Prakata.description << endl << endl;
            Sleep(1250);
            cout << Ponkipopo.nom << ", " << Ponkipopo.description << endl << endl;
            Sleep(1250);
            cout << Toto.nom << ", " << Toto.description << endl << endl;
            Sleep(1250);
            cout << Kluburt.nom << ", " << Kluburt.description << endl << endl;
            Sleep(1250);
            cout << Flugulune.nom << ", " << Flugulune.description << endl << endl;
            cout << "                                                  (Tapez le nom)" << endl;
            step=0; n=6; // On va à case 6 après case 0
        break;
 
        case 6:
            // Choix du monstre en fonction de la réponse du joueur
            if (reponse_txt==Pouki.nom)
            {
                joueur=Pouki;
                joueurx=joueur;
            }
            else if (reponse_txt==Prakata.nom)
            {
                joueur=Prakata;
                joueurx=joueur;
            }
            else if (reponse_txt==Ponkipopo.nom)
            {
                joueur=Ponkipopo;
                joueurx=joueur;
            }
            else if (reponse_txt==Toto.nom)
            {
                joueur=Toto;
                joueurx=joueur;
            }
            else if (reponse_txt==Kluburt.nom)
            {
                joueur=Kluburt;
                joueurx=joueur;
            }
            else if (reponse_txt==Flugulune.nom)
            {
                joueur=Flugulune;
                joueurx=joueur;
            }
            else
            {
                cout << endl;
                Sleep(750);
                cout << "Ce n'est pas le nom d'un des monstres proposes..." << endl;
                Sleep(250);
                cout << "Concentrez-vous, s'il-vous-plait" << endl;
                step=0; n=6; break;// On va à case 6 après case 0
            }
            step=7;
        break;
 
        case 7:
            // Preparation du combat
            cout << endl;
            Sleep(750);
            cout << joueur.nom << " hein? Moi je prefere utiliser le mien, il est plus fort =P" << endl;
            adversaire=Massacrator;
            adversairex=adversaire;
            Sleep(1000);
            cout << "On commence?" << endl;
            cout << "                                                  (Suite)" << endl;
            getch();
            cout << "C'est parti!" << endl;
            step=50;
        break;
 
        case 50:
            // Ouverture du combat
            cout << endl;
            cout << endl;
            cout << endl;
            cout << endl;
            cout << endl;
            Sleep(2000);
            cout << "Bienvenue en mode combat" << endl;
            cout << "                                                  (Suite)" << endl;
            getch();
            cout << joueur.nom << " et " << adversaire.nom << " vont s'affronter dans un combat a mort hyper-deg'" << endl;
            cout << "                                                  (Suite)" << endl;
            getch();
            cout << "C'est " << nom << " qui commence, il faut bien qu'il ait une chance!" << endl;
            cout << "                                                  (Suite)" << endl;
            getch();
            step=51;
        break;
 
        case 51: // Affichage des statistiques
            // Barre de vies adversaire
            cout << endl;
            cout << "--------------------------------------------------" << endl;
            cout << endl;
            Sleep(250);
            cout << "Adversaire: " << adversaire.nom << endl;
            cout << "Vies: " << adversairex.vies << "/" << adversaire.vies << "   (";
            n=20*adversairex.vies/adversaire.vies; // Préparation des boucles pour afficher la barre de vies
            m=1;
            while (m<=n) // Boucle affichant les vies disponibles
            {
                Sleep(25);
                m=m+1;
                cout << "|";
            }
            m=1;
            while (m<=20-n) // Boucle affichant les vies perdues
            {
                Sleep(25);
                m=m+1;
                cout << " ";
            }
            cout << ")" << endl;
            // Barre de vies joueur
            Sleep(250);
            cout << "                              " << "Joueur: " << joueur.nom << endl;
            cout << "                              " << "Vies: " << joueurx.vies << "/" << joueur.vies << "   (";
            n=20*joueurx.vies/joueur.vies; // Préparation des boucles pour afficher la barre de vies
            m=1;
            while (m<=n) // Boucle affichant les vies disponibles
            {
                Sleep(25);
                m=m+1;
                cout << "|";
            }
            m=1;
            while (m<=20-n) // Boucle affichant les vies perdues
            {
                Sleep(25);
                m=m+1;
                cout << " ";
            }
            cout << ")" << endl << endl << "--------------------------------------------------" << endl << endl;
            step=52;
        break;
 
        case 52:
            // Choix de l'action à effectuer
            n=0;
            cout << "Quelle action voulez-vous effectuer?" << endl;
            Sleep(250);
            cout << "A. Attaque normale" << endl;
 
            Sleep(250);
            if (joueur.regeneration!=0)
            {
                cout << "B. Regenerer des vies" << endl;
                n++;
            }
            else
            {}
 
            Sleep(250);
            if (joueur.bonus_off!=0)
            {
                if (n==0)
                {cout << "B. ";}
                else
                {cout << "C. ";}
                cout << "Booster l'attaque" << endl;
                n++;
            }
            else
            {}
 
            Sleep(250);
            if (joueur.bonus_def!=0)
            {
                if (n==0)
                {cout << "B. ";}
                else if (n==1)
                {cout << "C. ";}
                else
                {cout << "D. ";}
                cout << "Booster la defense" << endl;
                n++;
            }
            else
            {}
            cout << "(Repondez par A, B, C ou D)" << endl;
            step=0; n=53; // On va à case 54 après case 0
        break;
 
        case 53:
            // Traitement de la réponse du joueur, calcul des conséquences
            Sleep(250);
            if (reponse_txt=="A")
            {   step=70; n=54;} // On va à case 54 après case 70
            else if (reponse_txt=="B")
            {
                if (joueur.regeneration!=0)
                {   step=71; n=54;} // On va à case 54 après case 71
                else if (joueur.bonus_off!=0)
                {   step=72; n=54;} // On va à case 54 après case 72
                else if (joueur.bonus_def!=0)
                {   step=73; n=54;} // On va à case 54 après case 73
                else
                {}
            }
            else if (reponse_txt=="C")
            {
                if (joueur.bonus_off!=0)
                {   step=72; n=54;} // On va à case 54 après case 72
                else if (joueur.bonus_def!=0)
                {   step=73; n=54;} // On va à case 54 après case 73
                else
                {}
            }
            else if (reponse_txt=="D")
            {   step=73; n=54;} // On va à case 54 après case 73
            else
            {
                cout << "S'il-vous-plait, il faut rester serieux!" << endl;
                cout << "(Repondez par A, B, C ou D)" << endl;
            }
        break;
 
        case 54: // Action de l'adversaire (intelligence artificielle)
            if (joueurx.vies<=adversairex.puissance) // Si je joueur a suffisamment peu de vies
            {
                    n = rand() % 4 + 1; // comportement choisi au hasard
                    if (n==1) // 1 chance sur 4 de booster la puissance
                    {   step=77; n=51;} // On va à case 51 après case 77
                    else // 3 chances sur 4 d'essayer d'abattre le joueur
                    {   step=75; n=51;} // On va à case 51 après case 75
            }
            else
            {
                if (adversairex.vies<=0.25*adversaire.vies) // Si l'adversaire a moins d'un quart de ses vies
                {
                    n = rand() % 4 + 1; // comportement choisi au hasard
                    if (n==1) // 1 chance sur 4 de booster la défense
                    {   step=78; n=51;} // On va à case 51 après case 78
                    else // 3 chances sur 4 de régénérer les vies
                    {   step=76; n=51;} // On va à case 51 après case 76
                }
                else if (adversairex.vies<=0.5*adversaire.vies) // Si l'adversaire a moins de la moitié de ses vies
                {
                    n = rand() % 6 + 1; // comportement choisi au hasard
                    if (n<=3) // 2 chances sur 6 d'attaquer
                    {   step=75; n=51;} // On va à case 51 après case 75
                    if (n==3) // 1 chance sur 6 de régénérer les vies
                    {   step=76; n=51;} // On va à case 51 après case 76
                    else // 3 chances sur 6 de booster la défense
                    {   step=78; n=51;} // On va à case 51 après case 78
                }
                else if (adversairex.vies<=0.75*adversaire.vies) // Si l'adversaire a moins des trois quarts de ses vies, il attaque
                {   step=75; n=51;} // On va à case 51 après case 75
                else
                {
                    n = rand() % 3 + 1; // comportement choisi au hasard
                    if (n==1) // 1 chance sur 3 d'attaquer
                    {   step=75; n=51;} // On va à case 51 après case 75
                    else // 2 chances sur 3 de booster l'attaque
                    {   step=77; n=51;} // On va à case 51 après case 77
                }
            }
 break;
             cout << "                                                  (Suite)" << endl;
            getch();
            step=51;
        break;
 
        case 70: // Le joueur attaque
            cout << joueur.nom << " attaque " << adversaire.nom << endl;
            adversairex.vies=adversairex.vies-(joueurx.puissance*(1.5-adversairex.defense));
            if (adversairex.vies<=1) // Vies jamais négatives, détection de la victoire
            {
                adversairex.vies=0;
                step=90;
                n=92;
                break;
            }
            else
            {}
            cout << "Il reste " << adversairex.vies << " vies a " << adversaire.nom << endl;
            step=n;
        break;
 
        case 71: // Le joueur régémère ses vies
            cout << joueur.nom << " regenere ses vies, elles passent de " << joueurx.vies << endl;
            joueurx.vies=joueurx.vies+joueur.regeneration;
            if (joueurx.vies>=joueur.vies) // Vies jamais supérieures au maximum
            {joueurx.vies=joueur.vies;}
            else
            {}
            cout << " a " << joueurx.vies << endl;
            step=n;
        break;
 
        case 72: // Le joueur booste sa puissance
            cout << joueur.nom << " booste sa puissance, elle passe de " << joueurx.puissance << endl;
            joueurx.puissance=joueurx.puissance*(1+joueur.bonus_off);
            cout << " a " << joueurx.puissance << endl;
            step=n;
        break;
 
        case 73: // Le joueur booste sa défense
            cout << joueurx.nom << " booste sa defense, elle passe de " << 100*joueurx.defense;
            joueurx.defense=joueurx.defense*(1.0+joueur.bonus_def);
            cout << "% a " << joueurx.defense << "%" << endl;
            step=n;
        break;
 
        case 75: // L'adversaire attaque
            cout << adversaire.nom << " attaque " << joueur.nom << endl;
            joueurx.vies=joueurx.vies-(adversairex.puissance*(1.5-joueurx.defense));
            if (joueurx.vies<=0) // Vies jamais négatives, détection de la défaite
            {
            step=90;
            n=91;
            break;
            }
            else
            {}
            cout << "Il reste " << joueurx.vies << " vies a " << joueur.nom << endl;
            step=n;
        break;
 
        case 76: // L'adversaire régémère ses vies
            cout << adversaire.nom << " regenere ses vies, elles passent de " << adversairex.vies << endl;
            adversairex.vies=adversairex.vies+adversaire.regeneration;
            if (adversairex.vies>=adversaire.vies) // Vies jamais supérieures au maximum
            {adversairex.vies=adversaire.vies;}
            else
            {}
            cout << " a " << adversairex.vies << endl;
            step=n;
        break;
 
        case 77: // L'adversaire booste sa puissance
            cout << adversaire.nom << " booste sa puissance, elle passe de " << adversairex.puissance << endl;
            adversairex.puissance=adversairex.puissance*(1.0+adversaire.bonus_off);
            cout << " a " << adversairex.puissance << endl;
            step=n;
        break;
 
        case 78: // L'adversaire booste sa défense
            cout << adversaire.nom << " booste sa defense, elle passe de " << 100*adversairex.defense;
            adversairex.defense=adversairex.defense*(1.0+adversaire.bonus_def);
            cout << "% a " << 100*adversairex.defense << "%" << endl;
            step=n;
        break;
 
        case 90: // Joueur vaincu
            cout << "--------------------------------------------------" << endl << endl;
            cout << "STOP!!! Le combat est termine!" << endl << endl;
            step=n;
        break;
        case 91: // Joueur vaincu
            cout << joueur.nom << " est mort" << endl << "Et voila le travail!" << endl << "Revenez quand vous voulez, " << nom << "!" << endl;
            step=100;
        break;
 
        case 92: // Adversaire vaincu
            cout << adversaire.nom << " est vaincu" << endl << "Aie aie aie!" << endl << "J'aurais du faire plus attention!" << endl;
            step=100;
        break;
 
        }
    }
return 0;
}

[Iradrille]

Whaa tu repousses les limites de "tout dans le main" la !

Sort la structure Monstre de ton main (tu peux la mettre dans monstre.h par exemple), et n'hésite pas à créer des fonctions pour rendre ton code plus lisible (et plus simple à maintenir).

Si j'arrive à trouver un bon système pour ranger les données de chacun des monstres, je pourrais en faire un peu plus.

Tu peux enregistrer tes données dans un fichier texte par exemple, puis le lire au début de ton programme.
Et tu faire pareil pour le texte si besoin.

[Armulis]

OK, merci, mais j'ai pas encore appris tout ça!
L'idée de faire des fonctions est un peu réglée par le "switch" géant, non? Par exemple la lecture de la réponse du joueur (case 0), elle est unique dans le code.
Stocker les données dans un fichier texte, et le lire à l'exécution... c'est ce qui va m'amener à avoir des "chargement en cours" quand j'aurai d'énormes paquets de données, c'est ça?

[ternel]

l'idée de faire des fonctions est de:

1. factoriser le code qui peut l'être
2. donner un nom aux parties du code
3. permettre la réutilisation
4. faciliter la lecture
5. clarifier les intentions

On se fiche totalement de la manière de retirer trois pv à un monstre. par contre, lire retirerPv(monstre, 3); est explicite.

Quant au "chargement en cours", oui cela y participera.
ce message devrait apparaitre quand tu fais des préparatifs, mais que rien n'est affichable…