Discussion :

[maxiNoob]

oui bonne idée que cette procédure, mais ça ne résout pas ma question du stockage des données, je m'explique:

les données sont de types différents, string pour le nom, integer pour la force, etc..., or je ne peux pas les stocker dans 1 seul tableau, je vais devoir en faire plusieurs différents, ça ne va pas surcharger la mémoire ? (question de noob hein )


arf je dois mal m'expliquer

il serait plus simple de créer ma base de données de monstres ds un fichier, que je lirai pour remplir mes monstres avec ta procédure.
mais je n'arrive pas à comprendre comment faire

désolé d'être confus et lourd, mais j'ai un pseudo à assumer

[richard]

Pour cela il faut que tu crées une variable fichier

Code :

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

File of

puis que tu ouvres ton fichier en écriture que tu écrives et que tu fermes. Il faut aussi écrire la procédure qui te permettra de réouvrir le fichier sauvé sur le disque de lire les valerus et de les affecter à tes variables.

Je te conseille de potaser la doc sur les fichiers en Pascal (peut-être vaut-il mieux commencer par des fichiers simples avant d'attaquer les fichiers textes ...). Regarde les tutos sur développez.

[richard]

Voici un bout de code sur les fichiers qui pourra peut-être t'aider à comprendre.

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
 
(*$r+*)
program fichier_simple;
  uses crt;
  type t_fiche= record
                  prenom: string[21];
                  age: integer;
                end;
  var personnages: file of t_fiche;
      une_personne: t_fiche;
      choix: char;
 
  procedure cree;
    begin
      assign(personnages, 'a:amis.dta');
      rewrite(personnages);
      close(personnages);
    end; (* cree *)
 
  procedure ajoute;
    var choix1: char;
    begin
      assign(personnages, 'a:amis.dta');
      reset(personnages);
      while not eof(personnages) do
        read(personnages, une_personne);
 
      repeat
        write('    pr‚nom ? '); readln(une_personne.prenom);
        write('    age    ? '); readln(une_personne.age);
        write(personnages, une_personne);
 
        write('  continuer, Quitter ? ');
        choix1:= readkey; writeln(choix1);
      until choix1= 'q';
 
      close(personnages);
    end; (* ajoute *)
 
  procedure liste;
    var numero: integer;
    begin
      assign(personnages, 'a:amis.dta');
      reset(personnages);
      numero:= 0;
 
      while not eof(personnages) do
      begin
        read(personnages, une_personne);
        write('  fiche ', numero: 3);
        writeln(une_personne.prenom: 22, une_personne.age: 3);
        numero:= numero+ 1;
      end;
 
      close(personnages);
    end; (* liste *)
 
  procedure modifie;
    var numero: integer;
        choix1: char;
    begin
      assign(personnages, 'a:amis.dta');
      reset(personnages);
 
      repeat
        write('  modifie la fiche num‚ro ? '); readln(numero);
        seek(personnages, numero); read(personnages, une_personne);
        with une_personne do
        begin
          write('    ', prenom, ' pr‚nom ? '); readln(prenom);
          write('    ', age,    ' age    ? '); readln(age);
        end;
        seek(personnages, numero); write(personnages, une_personne);
 
        write('continuer, Quitter ? ');
        choix1:= readkey; writeln(choix1);
      until choix1= 'q';
 
      close(personnages);
    end; (* modifie *)
 
  begin (* principal *)
    clrscr;
    repeat
      writeln;
      write('Créer, Ajouter … la fin, Lister, Modifier, Quitter ? ');
      choix:= readkey; writeln(choix);
      case choix of
        'c' : cree;
        'a' : ajoute;
        'l' : liste;
        'm' : modifie;
      end;
    until choix= 'q';
  end. (* principal *)

[darrylsite]

En parlant de memoire, il serait mieux à mon avis de laisser turbo pascal pour un compilateur plus recent, freepascal par exemple qui supporte bien les codes developpés sous turbo.

[maxiNoob]

hé magnifique richard, ton exemple de code est complet
je vais l'adapter, je te tiendrais au courant de mes progrés
ça prendra bien 2 ou 3 jours

je pensai naïvement qu'on pouvait créer un fichier sans le programme

encore merci

trop génial ce forum

[richard]

En parlant de memoire, il serait mieux à mon avis de laisser turbo pascal pour un compilateur plus recent, freepascal par exemple qui supporte bien les codes developpés sous turbo.

+1

Ca je crois qu'on ne le répètera jamais assez (je l'ai déjà écrit au début de ce fil) ...

[maxiNoob]

bah voilà, grâce à ton exemple j'ai pu créer un fichier de monstres
effectivement cet outil est super pratique et finalement très simple

du coup je le poste là pour avoir vos critiques et une optimisation éventuelle

il est sous TPW, sous free il faut juste remplacer WinCrt par Crt

encore merci, il me reste à présent à créer un fichier pour mes personnages

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
 
 
(*$r+*)
program JDR_BD_Perso; {**  Version Monstres **}
 
Uses WinCrt;
 
 
Type
    tPerso = record
     name : string[25];
     race : byte;
     carrier : byte;
     level : byte;
     weapon1 : byte;
     weapon2 : byte;
     def: byte;
     money : integer;
     ptExp: integer;
     CaracP : Array[1..8] of integer;
     CaracS : Array[1..8] of integer;
     stuff : array[1..6] of string[15];
     end;
 
 
Const
     Path: string = 'c:\tpw\jdr\datas\monsters.dta';
 
 
Var
   Persos: file of tPerso;
     a_monster: tPerso;
     choix: char;
     i: integer;
 
 
 
procedure cree;
   begin
     writeLn(' Etes vous sûr ? ceci écrase le fichier!');choix:= readkey;
     if choix <> 'o' then exit;
     assign(Persos, path);
     rewrite(Persos);
     close(Persos);
     ClrScr;
     write(#7);
     writeLn;
     writeLn(' FICHIER Créé !!! ');
     readkey;
   end; (* cree *)
 
 
 
  procedure ajoute;
    var choice: char;
    begin
      assign(Persos, path);
      reset(Persos);
      while not eof(Persos) do
        read(Persos, a_monster);
        writeln('Saisie des Monstres:');writeln;
      repeat
          with a_monster do
            Begin
        write('    nom du Monstre ? '); readln(name);
        write('    race (0) ? '); readln(race);
        write('    venin (0-1) ? '); readln(carrier);
        write('    niveau  ? '); readln(level);
        write('    arme 1  ? '); readln(weapon1);
        write('    arme 2  ? '); readln(weapon2);
        write('    classe armure  ? '); readln(def);
        write('    argent  ? '); readln(money);
        write('    Points Exp      ? '); readln(ptExp);
        write('    Capac combat   ? '); readln(caracP[1]);
        write('    Capac tir      ? '); readln(caracP[2]);
        write('    Force  ? ');readln(caracP[3]);
        write('    Endurance  ? ');readln(caracP[4]);
        write('    Agilité  ? ');readln(caracP[5]);
        write('    Intelligence   ? '); readln(caracP[6]);
        write('    Force mentale  ? '); readln(caracP[7]);
        write('    Sociabilité    ? '); readln(caracP[8]);
        write('    PtsAttaque ? '); readln(caracS[1]);
        write('    PtsBless (8-14) ? '); readln(caracS[2]);
       caracS[3] := (caracP[3] div 10);
       caracS[4] := (caracP[4] div 10);
        write('    Mouvement (3-5)  ? '); readln(caracS[5]);
       caracS[6] := 0;
        write('    Pts Destin  (1-3)  ? '); readln(caracS[7]);
       caracS[8] := 0;
           end;
 
        write(Persos, a_monster);
        write('  continuer,  Quitter ? ');
        choice:= readkey; writeln(choice);
      until (choice= 'q') or (choice = 'Q');
 
      close(Persos);
    end; (* ajoute *)
 
 
procedure lecture;
    var number: integer;
    begin
      assign(Persos, Path);
      reset(Persos);   

      number:= 0;
      ClrScr;
       writeln('     ####  Voilà Vos Monstres  ####');
       writeln;
      while not eof(Persos) do
      begin
        read(Persos, a_monster);
          with a_monster do
            begin
          ClrScr;
          writeLn;
          writeLn('** Monstre: ',number,' : ' ,name,' **'); writeLn;
          writeln('    race  venin  niveau  arme1  arme2   def  argent   PtExp');
          write(race:7, carrier:7, level:7, weapon1:7, weapon2:7);
          writeLn(def:7, money:7, ptExp:7);
          writeLn;
          writeLn('      * Profil Principal *');
          writeLn('    cc   ct   fo   end  agi  int   fm  soc');
          write(' ');
          for i := 1 to 8 do write(caracP[i]:5);
          writeln;
          writeln;
          writeln('     * Profil secondaire *');
          writeln('    nA  pB  BF  BE  Mv  Mg  pD  pF');
          write(' ');
          for i:= 1to 8 do write(caracS[i]:4);
            end;
        number:= number+1;
        writeln;
        writeln;
        readkey;
 
      end;
 
      close(Persos);
end; (* lecture *)
 
 
procedure modifie;
    var number: integer;
        choice: char;
    begin
      assign(Persos, Path);
      reset(Persos);
 
      repeat
        write('  modifie la fiche numéro ? '); readln(number);
        seek(persos, number); read(persos, a_monster);
 
       with a_monster do
            Begin
        write('   ',name,' New name  ? '); readln(name);
        write('   ',race,' New race (0) ? '); readln(race);
        write('   ',carrier,' Veninous  ? '); readln(carrier);
        write('   ',level,' New level  ? '); readln(level);
        write('   ',weapon1,' New weapon1  ? '); readln(weapon1);
        write('   ',weapon2,' New weapon2  ? '); readln(weapon2);
        write('   ',def,' New def class  ? '); readln(def);
        write('   ',money,' New money  ? '); readln(money);
        write('   ',ptExp,' New Exp pts  ? '); readln(ptExp);
        write('   ',caracP[1],' New Capac combat  ? '); readln(caracP[1]);
        write('   ',caracP[2],' New Capac tir     ? '); readln(caracP[2]);
        write('   ',caracP[3],' New  Force        ? '); readln(caracP[3]);
        write('   ',caracP[4],' New Endurance     ? '); readln(caracP[4]);
        write('   ',caracP[5],' New Agility       ? '); readln(caracP[5]);
        write('   ',caracP[6],' New Intelligence  ? '); readln(caracP[6]);
        write('   ',caracP[7],' New mental force  ? '); readln(caracP[7]);
        write('   ',caracP[8],' New Sociability   ? '); readln(caracP[8]);
        write('   ',caracS[1],' New Attack Pts    ? '); readln(caracS[1]);
        write('   ',caracS[2],' New Life Pts(8-14)? '); readln(caracS[2]);
       caracS[3] := (caracP[3] div 10);
       caracS[4] := (caracP[4] div 10);
        write('   ',caracS[5],' New Movement(3-5) ? '); readln(caracS[5]);
       caracS[6] := 0;
        write('   ',caracS[7],' New Dest Pts(1-3) ? '); readln(caracS[7]);
       caracS[8] := 0;
        end;
        seek(persos, number); write(persos, a_monster);
        write('continuer, Quitter ? ');
        choice:= readkey; writeln(choice);
      until (choice= 'q') or (choice = 'Q');
    close(Persos);
    end; (* modifie *)
 
 
 
begin (* principal *)
    clrscr;
    writeln;
    writeln('       #######  Générateur  de  Monstres   #######');
    repeat
      writeln;
      write(' >  C)réer, A)jouter à la fin, L)ister, M)odifier, Q)uitter ? ');
      choix:= readkey; writeln(choix);
      case choix of
        'c' : cree;
        'a' : ajoute;
        'A' : ajoute;
        'l' : lecture;
        'L' : lecture;
        'm' : modifie;
        'M' : modifie;
      end;
    until (choix= 'q') or (choix = 'Q');
 
    write(#7);
end. (* principal *)

[maxiNoob]

chers amis je continue ce JDR textuel et je bute à présent sur le combat

pour info je m'inspire des règle du JDR warhammer

je m'explique:

nos personnages et monstres sont définis par une variable enregistrement, la même pour tout le monde

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
Type
    tPerso = record
     name : string[25];
     race : byte;
     carrier : byte;
     level : byte;
     weapon1 : byte;
     weapon2 : byte;
     def: byte;
     money : integer;
     ptExp: integer;
     CaracP : Array[1..8] of integer;  {Profil Principal: agilité est là dedans en indice 5}
     CaracS : Array[1..8] of integer;  {Profil Secondaire}
     stuff : array[1..6] of string[15];
     end;

pdt un combat, le critère agilité va servir de priorité, or je n'arrive pas à comprendre comment l'utiliser

elle est stockée dans le tableau de caractéristiques, indice 5: CaracP[5]

j'ai créé un tableau que j'utilise juste pour le combat que je remplis avec les protagonistes, les héros et les monstres, je le trie par un tri à bulle par agilité décroissante, mais après pouet, je ne peux rien en faire, car c'est un tableau différent et non pas mes personnages.

bref avez vous une idée pour faire intervenir les combattants selon leur agilité ?

dois je créer un tableau de pointeurs vers mes personnages ?

maxi plus noob que jamais

[Dr.Who]

agilité, force, intélligence, volonté sont généralement des "facteurs" à appliquer à l'action.

exemple du dé+bonus vulgaire:

arme 2D6+8 :

interval du coups 2..12 : 2 = echec, 12 = critique

addition du bonus : 10..12 conclusion echec impossible.



pour le jet d'action/caractéristique selon les regles du jeux:

maladresse = jet minimum possible (1D20 = 1, 2D20 = 2)
if Jet = MinJet then ...

echec = jet inférieur au jet moyen ou agilité inférieur au jet moyen
if (Jet < MoyJet) or (AGI < MoyJet) then ...

reussite = jet supérieur ou égal au jet moyen et agilité supérieur au jet moyen
if (Jet >= MoyJet) and (AGI > MoyJet) then ...

critique = jet égal au maximum possible (1D20 = 20, 2D20 = 40)
if Jet = JetMax then ...

on peu le traduire par :

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
type
  TDiceAct = (daClumsiness, daEchec, daSuccess, daCritical);
 
function DiceAct(const DiceResult, DiceCounts, DiceFaces, Trait : integer): TDiceAct;
var
  LMin, LMoy, LMax, LDif : integer;
begin
  LMin := DiceCounts;
  LMax := DiceFaces * DiceCounts;
  LMoy := (LMax-LMin) div 2;
 
  if DiceResult <= LMin then
  begin
    DiceAct := daClumsiness;
    exit;
  end;
 
  if DiceResult >= LMax then
  begin
    DiceAct := daCritical;
    exit;
  end;
 
  if (DiceResult < LMoy) and (Trait <= LMoy) then
  begin
    DiceAct := daEchec;
    exit;
  end;
 
  if ((DiceResult < LMoy) and (Trait > LMoy)) or ((DiceResult > LMoy) and ((Trait - LMoy) > 0) then
    DiceAct := daSuccess;
end;

utilisation :

jets d'agilité :

Code :

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

1
2
3
4
5
6
case DiceAct(Jet+BonusJet, 1, 20, Agility+BonusAgi) of
  daClumsiness :
  daEchec :
  daSuccess :
  daCritical :
end;

jets de force :

Code :

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

DiceAct(Jet+BonusJet, 1, 20, Strength+BonusStr);

jets d'attaque :

Code :

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

DiceAct(Jet+BonusJet, 2, 8, Attack+BonusAtk+BonusWeapon);

jets de defense :

Code :

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

DiceAct(Jet+BonusJet, 1, 20, Defense+BonusDef+CA);

[maxiNoob]

merci DOC, tj prompt à la rescousse, tu es un DOC du SAMU ?

houla ton code rentre à fond ds le détail du résultat du combat, j'en suis pas encore là, j'en suis juste à essayer de le faire commencer, et pour ça je veux définir un ordre du combat

j'ai 6 guerriers et par exemple 5 monstres, ils vont intervenir successivement selon leur agilité respective, le plus agile frappant le premier évidemment, or je n'arrive pas à le concevoir

quand j'aurai franchi ce premier pas, alors j'étudierai de prés ta fonction qui est baleze

heu pour warhammer c'est le D100 pour les test: force, agilité, intelligence, ...
et un D10 pour les dégats infligés

tu proposes un D20 si je comprend bien, c'est quel JDR ?

[Dr.Who]

en fait tu dois écrire les régles de ton jeux sans règles tu ne pourra rien faire.

exemple :

l'action hostile (attaque, sournoiserie) est une volonté (désir de tuer/faire le mal).

- les êtres qui suivent des préceptes immoraux (al. mauvais), possèdent un bonus de base de +2 aux jets hostile.
- les êtres qui suivent des préceptes pacifique (al. bon), possèdent un malus de base de -1 aux jets hostile.
- les personnages d'alignement chaotique/neutre n'ont ni malus ni bonus de base à ces jets, les misanthropes et les marginaux ne sont ni maléfique, ni pacifique.
- les barbares et guerriers possèdent naturellement un bonus de base de +1 (non cumulable) aux jets d'action hostile.

l'action défensive (esquive, défense de soi ou d'autrui) est une volonté (instinct de survie).

- les êtres qui suivent des préceptes immoraux (al. mauvais), possèdent un malus de base de -2 aux jets défensif.
- les êtres qui suivent des préceptes pacifique (al. bon), possèdent un bonus de base de +2 aux jets défensif.
- les personnages d'alignement chaotique/neutre n'ont ni malus ni bonus de base à ces jets, les misanthropes et les marginaux ne sont ni maléfique, ni pacifique.
- les elfes, homme-animaux et les gladiateurs possèdent naturellement un bonus de base de +1 (non cumulable) aux jets d'action défensives.

Jets de sauvegarde :

- Dés le niveau 15, du fait de sa longue expérience du combat, un personnage possède 2 jets de sauvegarde par jours contre les maladresses et coups critique pouvant entrainer la mort.

- Au niveau 30, du fait de sa maitrise du combat en tout genre et sa grande connaissance des technique de survie, un personnage possède 2 jets de sauvegarde supplémentaires par jours contre les maladresses. et coups critique pouvant entrainer la mort.

- Du fait de leurs bonus de base, les nains ne possèdent aucuns points de jets de sauvegarde, peu importe leur niveaux.

- Du fait qu'ils ont souvent leurs mains occupées, quand elles ne sont pas baladeuses, Les voleurs ne peuvent pas faire de jets de sauvegarde en cas d'échec critique pendant l'utilisation de la compétence de crochetage et la compétence de désamorçage.

[maxiNoob]

très intéressant ton exemple doc, et bien sur écrire ses propres règles serait l'idéal, le must du developpement, pour le moment je débute et je me borne donc à repomper, en simplifiant, les règles du JDR Warhammer (mon fils a tous les livres), ceci me permet de me concentrer sur la programmation qui est le but réel de cet exercice.

en fait cela permet une approche ludique et motivante pour le fiston et pour moi même, il accroche plus qu'avec des exercices sur les matchs ou les tris

voici les règles de warhammer:

les aptitudes des personnages sont au nombre de 16 reparties en 2 profils
le profil principal: 8 aptitudes
CC : capacité de Combat (armes de poing)
CT : capacité de Tir (armes à feu ou à flèches ou lances)
Force: utilisée pour le calcul des dégats infligés
Endurance: utilisée pour le calcul des dégats subis
Agilité: détermine l'ordre des actions
Intelligence: utilisable ds divers tests hors combat
Force mentale: test de magie, fuite, etc...
sociabilité: pour le commerce, les enquêtes, etc...

le profil secondaire: 8 autres aptitudes
nA: nombre d'action possibles à chaque tour de jeu, comme frapper 2 fois
pB: point de blessure, c'est la vie !
BF: bonus force utilisé pour le calcul des combats ...


lorsque les héros rencontrent un combat:

les joueurs font un jet de dés (D100) pour décider l'ordre du combat, c'est un test d'agilité, celui qui fait le plus gros score combat le premier, le maitre du jeu se charge du jet des monstres.

dans cet ordre chaque joueur fait un jet de combat ou un sort pour ceux qui disposent de points de magies. c'est le test , il est basé sur la capacité de combat

etc...


bref au niveau règles j'ai tout sous la main, il faut bien sur simplifier

c'est pourquoi je peux me concentrer sur l'apprentissage de la programmation

sans ce forum j'essaierai même pas

mes héros sont donc définis ds une variable record, comme les monstres et je n'arrive pas à comprendre comment écrire la boucle du combat, j'ai réussi avec 1 seul joueur face aux monstres, il tape le premier, mais je n'arrive pas avec plusieurs protagonistes, c'est à dire à changer d'ordre à chaque fois

l'agilité est stockée ds un champ caracP qui est un tableau de 8 cases
Perso.carac[5];

comment trier ces bougres pour qu'ils se frappent ?

[richard]

Bonjour,

1) Je n'y connais rien en jeu, je ne joue jamais et je n'ai jamais programmé de jeu donc je n'interviendrai pas sur la nécessité de définir les règles d'abord ce qui me semble cependant une évidence difficilement contestable même pour un ignare comme moi. Le fait d'avoir tes règles écrites même simplifiées te permettra d'y voir plus clair au niveau de la conception.
2) Pour ton problème, c'est un problème d'algo et de boucle. Le combat sera une procédure avec probablement des sous-procédures (différentes phases du combat). Je te conseille de les stocker dans une unité spécialisée.

Code :

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

1
2
3
4
  ALGO : IF agilité_personnage[i] > personnage[y] THEN
               BEGIN
                 PROCEDURE_Combat(personnage[i],personnage[j];
                END;

PROCEDURE_Combat(x,y) est une procédure avec deux paramètres (c'est le résultat du test agilité qui passe les paramètres à cette procédure) qui correspondent à deux personnages. Le premier paramètre est le personnage qui correspond à celui qui attaque en premier, le deuxième à celui qui se fait attaquer.

Cela peut répondre à ta question (encore une fois je n'y connais rien en jeux)

Note : très rapidement tu vas comprendre ce qu'on te disait au sujet de la programmation orientée objet ...

[maxiNoob]

merci Richard, ton conseil a réussi à me décoincer, grâce à vous tous, je ne rame pas seul

j'arrive donc à classer mes 2 groupes par agilité et comme ton exemple le suggere je compare 1 à 1 les protagonistes, l'agilité décide alors qui attaque

voilà l'adaptation de ton exemple:

showmonsters: procedure qui affiche la liste des monstres vivants
ip et im: indexPersonnage (ip) et indexMonstre(im)
caracP[5] c'est le champ tableau qui contient l'agilité
2 boucles intégrées jusqu'à l'extermination des monstres ou des héros

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
REPEAT
     Repeat
           ClrScr;
           ShowMonsters;
             if (perso[ip].caracP[5] >= monst[im].caracP[5]) or (im>NbMonsters)
                                  Then heroAttack
                                  Else monstAttack;
 
     Until ((ip = NbHeros) and (im = NbMonsters)) or
                ((NbMonsters=0) or (Nbheros=0));
        ip := 1;im :=1;   {fin d'un tour, réinitialise les indices}
UNTIL  (nbHeros = 0) or (nbMonsters = 0);

j'ai commencé donc à écrire les procédures de combat, c'est là que je vais étudier (repomper) le code du Doc

[richard]

OK, pas de problème.

1) Je te propose cependant de mettre tes boucles dans une procédure "Combat" qui permettra de rendre ton programme plus modulaire.
2) 'ip' et 'im' sont des noms de variables explicites ... pour l'instant. Quand tu voudras relire ton programme qui aura grossi dans quelques mois, ou quelques années, ce le sera beaucoup moins. Il existe une très bonne fonction Rechercher/Remplacer qui te permet de ne pas tout taper tout en ayant au final des noms explicites. dans ton cas il vaut mieux garder 'IndexMonst' et 'IndexPers' plutôt que "im" et "ip". En tout cas c'est cela que je ferais, ça améliore la lisibilité du programme qui est un des gros avantages du Pascal sur un certain nombre de ces concurrents...

@Alacâtiz : désolé pour l'oubli des balises CODE.

[Dr.Who]

Liste des joueurs (array of TPlayer)
Liste des monstres (array of TMonster)

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
 
function WhosPlayFirst(const Players: array of TPlayer; Dice: TDice): TPlayer;
var N, H, NDR, ODR : integer;
begin
  H := High(Players);
  ODR := -1;
  for N := 0 to H do
  begin
    // joueur lance son dé d'agilité
    NDR := Dice.Roll;
 
    // ex aequo
    if (NDR = ODR) and (result <> nil) then
    begin
      ODR := Dice.Roll;
      NDR := Dice.Roll;
    end;
 
    // le joueur N fait un meilleur score
    if NDR > ODR then
    begin
      ODR := NDR;
      result := Players[N];
    end;
  end;
end;

[maxiNoob]

richard > OKI j'ai mis IndexPerso et IndexMonster

doc> tu utilises des tableaux dynamiques, j'avais encore jamais essayé

je comprend que High() renvoie l'indice supérieur mais comment connaitre le nb d'éléments ?

je ne comprend pas NDR et ODR, pourquoi ODR = -1 ???

[M.Dlb]

ODR contient la valeur du plus haut score au dés. ODR = -1 au premier tour de boucle, car le premier joueur qui tire les dés fait forcément un score supérieur à -1 et devient forcément le premier joueur à jouer ( grâce à la comparaison NDR > ODR). Les autres joueurs doivent alors faire un tir de dé de valeur supérieure à ODR pour prendre la place du "premier à jouer"

La fonction donnée renvoie comme résultat l'objet TPlayer qui a fait le score de dés le plus haut.

[Dr.Who]

@wormful : bonne et exacte analyse!

@maxiNoob :

je commente le code plus, attention ce code ne peu peut être pas fonctionner sous TP ou une vieille version de FPC qui ne supporte pas les tableau dynamiques.

premièrement : la fonction necessite et precise l'orientation POO exigée de ton code.
comme on l'as dit, le modèle objet est un atout considérable pour ce genre de projet.

deuxiemement : cette méthode nous indique qu'il faut un objet TPlayer et un objet TDice!


précisions du code & CORRECTION de la fonction:

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
 
 
{
  utilisation :
  Player := WhosPlayFirst([Player1, Player2, Player3]);
 
  paramètres :
    Players [input] : array of TPlayer, tableau contenant tout les joueurs impliqués dans une action.
    Dice [input] : TDice, objet dé necessaire à l'action (1D6, 1D20...)
 
  retour :
    TPlayer, La fonction retourne le joueur qui aura fait le plus gros score.
}
 
function WhosPlayFirst(const Players: array of TPlayer; Dice: TDice): TPlayer;
var 
  N, // compteur pour la boucle for 
  H, // borne max de Players
  NDR, // New Dice Roll, valeur du nouveau jet du dé
  ODR : integer; // Old Dice Roll, valeur de l'ancien jet du dé
begin
  // récupère la borne max de Players
  // nombres de joueurs engagés dans l'action : H+1!
  // les tableaux dynamique sont indéxés à Zero donc le nombre de valeurs
  // qu'ils contiennent est BorneMax+1
  H := High(Players);
 
  // initialisation de ODR (Old Dice Roll)
  // puisque jusqu'ici aucun lancé n'a été fait, nous assignont
  // une valeur impossible à effectuer avec un jet de dé
  // soit 0 ou une valeur inférieure à zero!
  ODR := -1; // ou ODR := 0
 
  // début de la boucle, nous allons faire lancer le dé à chaque joueurs
  for N := 0 to H do
  begin
    // joueur lance le dé d'action, on stocke dans NDR (New Dice Roll)
    NDR := Dice.Roll;
 
    // tant que ex aequo entre jet précédent le plus fort et 
    // nouveau jet de dé 
    while NDR = ODR do
    begin
      // on ne peut arrivé ici à la première itération de la boucle
      // on relance les dé pour sortir de l'ex aequo.
 
      // chaque joueur relance le dé, car il n'est pas fairplay 
      // que seul le joueur suivant doivent relancer le siens.
      // on relance autant de fois que necessaire pour séparer
      // les deux scores.
      ODR := Dice.Roll;
      NDR := Dice.Roll;
    end;
 
    // le joueur (ancien ou nouveau à jouer) à fait un nouveau meilleur score
    // si ODR est toujours le plus fort, on ne change rien.
    // si NDR est maintenant le plus fort, on fait ce qu'il faut...
    if NDR > ODR then
    begin
      // NDR devient le score de référence
      ODR := NDR;
      // le joueur qui vas jouer en premier est celui qui à lancer le dé
      // dans l'actuelle itération de la boucle
      result := Players[N];
    end;
  end;
end;

l'avantage c'est que cette fonction s'adaptera pour savoir qui des TMonster vas riposter en premier.
Attention, un monstre n'attaque qui si :

- l'ennemis est hostile au groupe d'aventurier

- l'ennemis est hostile à la race d'un ou de plusieurs membres du groupe (syndrome du Barbare)

- l'ennemis est dément et attaque tout humain croisant son chemin (Troll berserk par exemple)

- l'action se déroule dans les "rencontres" lors du voyage

- l'action se déroule dans l'attaque ou l'intrusion par les joueurs d'une zone de guerre ou d'un lieu clos protégé (donjon, caserne, banque).

- les monstres ou ennemis défendant et dont leurs mission est de protéger/défendre la zone ou le lieu, attaqueront obligatoirement les aventuriers.

-excepetion : Les montres "gardien" non fourbe (cerbère, dragon, sphinx) n'attaquent pas systématiquement les aventuriers si ceux ci ne représente pas une menace directe contre le gardien ou le bien qu'il garde.

Le monstre gardien attaque dans le but de se nourrir s'il est affamé, les aventurier doivent lancé dans ce cas de la nourriture au monstre (ne fonctionne que pour les monstres gardien doué de raison (dragons)), ou offrir une nourriture (gros animal, troupe d'ogre ou de goblins poursuivant) plus conséquente (gardien animal).

note : Les "gardien" maltraités peuvent devenir allié des aventuriers (promesse de libération tenue à un dragon ou libération et nourrissage d'un cerbère). la libération d'un gardien est souvent considéré comme un acte altruiste et peu faire gagner aux aventuriers des points de mental (intélligence) ET des points d'experiences, facultativement le gardien peu donner le bien dont il avait la garde (souvent le cas des Dragons ou Sphinx protégeant une relique ancienne douée de pouvoir extraordinaire).
L'alliance d'un groupe avec un ancien gardien est benefique niveau puissance et terreur infligée aux groupes hostile, un groupe hostile faible prendra facilement la fuite en oubliant affaire et buttins derrère eux...



les ennemis et monstres n'attaque jamais en premier, on considère qu'ils chargent avant et que les joueurs ne sont pas trop idiot pour se mettre en position immediate de riposte.
il n'est donc pas necessaire de faire un lancer d'action pour les monstres, mais de savoir qui des joueurs vas riposter/défendre en premier.
les monstres riposterons à leurs tours dans l'ordre de frappe par les joueurs.

certains Boss ennemis, peuvent avoir la capacité d'attaquer à chaque tours n'importe quel joueur ou tout les joueur (Boss mage ou Boss geant ayant des compétence de dégâts de zone).





voila.


ps : j'ai fait quelques codes pour un moteurs de RPG (non visuel) qui montre une certaine implementation des choses et peu guider pour le developpement.
en pj.

[maxiNoob]

merci infiniment Doc, bien sûr que vos exemples, conseils, codes etc m'aident
je n'ai pas réussi à utiliser ton programme RPenGine, je suis vraiment un noob, c'est qd même pénible toutes ces versions de Pascal

pour ta fonction elle est très pédagogique sur la gestion du dé, mais elle ne correspond pas aux règles que nous souhaitons utiliser avec mon fils, elle est effectivement très claire avec vos explications.

en quoi Tplayer et TDice sont des objets ?

question de noob:
si j'aboutis à un code potable pour ce combat, sera t il facile d'adapter ça ds un EDI plus moderne comme Delphi ?

promis après ça je lache TPW