Conception d'un Jeu de Rôle

Version imprimable

Voir 40 message(s) de cette discussion en une page

dans les warhammer, on les dés sont souvent :

cDf +B

Dés + bonus.

on aura plutot besoin de la fonction :

Code:

1
2
3
4
5
 
function Dice(const Dices, Faces, Bonus: ShortInt): integer;
begin
  result := Dices + Bonus + random((Faces * Dices + 1) - Dices - Bonus);
end;

par exemple, pour la taille d'un elf noir :

1.80m + 2D10

on fera :

Code:

1
2
TaillePerso := Dice(2, 10, 180);
// 182..202 cm

pour un nain :
1.0m + 2D10

Code:

1
2
TaillePerso := Dice(2, 10, 100);
// 102..122 cm

dégat d'une dague rouillé ?

Code:

1
2
Dmg := Dice(1, 4, -1);
// 0..3

dégat d'une dague normale ?

Code:

1
2
Dmg := Dice(1, 4, 0);
// 1..4

dégat d'une dague d'argent ?

Code:

1
2
Dmg := Dice(2, 4, 1);
// 3..9

ou de façon générique :

Code:

1
2
 
Resultat := Dice(Action.DicesCount, Action.DiceFaces, Action.DicesBonus);

qui peut être :

sorts :

Code:

1
2
3
4
5
6
7
SpellFire4.Name := 'Boule de feu IV';
SpellFire4.Level := 4;
SpellFire4.DicesCount := 2; // 2D
SpellFire4.DiceFaces := 8; // 2D8
SpellFire4.DicesBonus := ElementsFireBonus[4];
 
dégat := Dice(SpellFire4.DicesCount, SpellFire4.DiceFaces, SpellFire4.DicesBonus);

Code:

1
2
3
4
5
6
7
SpellIce3.Name := 'Lance givrée III';
SpellIce3.Level := 3;
SpellIce3.DicesCount := 1; // 1D
SpellIce3.DiceFaces := 8; // 1D8
SpellIce3.DicesBonus := ElementsIceBonus[3];
 
dégat := Dice(SpellIce3.DicesCount, SpellIce3.DiceFaces, SpellIce3.DicesBonus);

armes :

Code:

1
2
3
4
5
6
7
WeaponDager1.Name := 'Dague du novice';
WeaponDager1.Level := 0;
WeaponDager1.DicesCount := 1;
WeaponDager1.DiceFaces := 4;
WeaponDager1.DicesBonus := WeaponShortBladeBonus[0];
 
dégat := Dice(WeaponDager1.DicesCount, WeaponDager1.DiceFaces, WeaponDager1.DicesBonus);

armure :

Code:

1
2
3
4
5
6
7
ArmorPlate8.Name := 'Armure de plaque du grosbill';
ArmorPlate8.Level := 8;
ArmorPlate8.DicesCount := 4;
ArmorPlate8.DiceFaces := 12;
ArmorPlate8.DicesBonus := ArmorPlatesBonus[8];
 
défense := Dice(ArmorPlate8.DicesCount, ArmorPlate8.DiceFaces, ArmorPlate8.DicesBonus);

actions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
ActionDoor2.Name := 'Porte fermée II';
ActionDoor2.Level := 2;
ActionDoor2.DicesCount := 2;
ActionDoor2.DiceFaces := 4;
ActionDoor2.DiceBonus := ClosedDoorBonus[2];
ActionDoor2.Trap := SpellFire4;
 
if Dice(ActionDoor2.DicesCount, ActionDoor2.DiceFaces, ActionDoor2.DiceBonus) < Dice(1, 20, Player.Chance) then
  // reussite, porte ouverte //
else
  // echec, déclanchement du piège //
  SendDamage(Player, Dice(ActionDoor2.Trap.DicesCount, ActionDoor2.Trap.DiceFace, ActionDoor2.Trap.DicesBonus));

14/12/2009, 21h20
maxiNoob

Je crois qu'on parle pas des mêmes warhammer :mrgreen:

Nous connaissons ça depuis 2 ans et il s'agit surement de nouvelles règles
(c'est l'explication de mon fils, qui a lu tous les livres de cette collection)

> le voilà:

http://ecx.images-amazon.com/images/...9L._SS500_.jpg

ainsi la taille peut être calculée comme tu l'expliques pour rendre réaliste le personnage, mais ensuite elle n'intervient jamais ds le jeu, mais je comprend que tu donnes ça en exemple.

celui dont je parle utilise 2 dés différents:

un D10, donc valeur de 1 à 10
un D100 pour les dizaines (faces numérotées 10, 20, 30, ...00)
en combinant les 2 tu obtiens un résultat de 1 à 100

donc ni D6, D8 ou D4

Il y a 3 situations:

- jet d'1 D10 pour les dégats (1..10)
- jet de 2 D10 pour le calcul des caractéristiques au début du jeu (2..20)
- jet d'un D100 + 1D10 pour tous les tests (1..100)

pour les dégats on utilise tj un D10, son résultat est rajouté:

> la force du joueur (BF:bonus force), l'impact de l'arme et on déduit endurance et classe d'armure du monstre.

Dégats = D10 + BF + ValeurArme - BE - CA

mwala

par contre je vais suivre ton conseil et mettre 2 paramètres à la function :
le nombre de Dés et la plage de résultat

l'utilisation du D10 + D100 est un concept qui à été repiqué sur Vampire, les mecs de WH ont trouver cela plus pratique.
d'ailleur nombre de JDR s'appuis sur le D10 + D100

dans mes exemples, si j'utilisais des D6, D4 etc c'est le fait d'avoir trop jouer à SR au lycée et à l'armée ... y'a longtemps.
qui lui s'appuis sur plusieurs types de dés.

alors à ce moment ça nous facilite le travail :

Code:

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
 
type
  TDice = function(const Bonus: integer = 0): integer;
 
 
function _1D10(const Bonus: integer = 0): integer;
begin
  result := 1 + random(10-Bonus) + Bonus;
end;
var // alias
  DiceDamage : TDice = _1D10;
  Dice1D10 : TDice = _1D10;
 
function _2D10(const Bonus: integer = 0): integer;
begin
  result := 2 + random(19-Bonus) + Bonus;
end;
var // alias
  DiceTrait : TDice = _2D10;
  Dice2D10 : TDice = _2D10;
 
function _1D100(const Bonus: integer = 0): integer;
begin
  result := 1 + random(100) + Bonus;
end;
var // alias
  DiceTest : TDice = _1D100;
  DiceAction : TDice = _1D100;
  Dice1D100 : TDice = _1D100;
 
 
function DiceCombiner(const Dices: array of TDice): integer;
var N : integer;
begin
  result := 0;
  for N := 0 to High(Dices) do
    result := result + Dices[N];
end;

peut être utilisé de la sorte :

Code:

1
2
3
4
5
6
7
8
9
 
resultat := DiceAction;
 
resultat := DiceDamage;
 
resultat := DiceDamage(Player.Str + Player.W1.Dmg - Monster.En - Monster.CA); 
 
resultat := DiceCombiner([Dice1D10, Dice1D10, Dice1D100, Dice1D100]);
// 4..220

15/12/2009, 10h09
mick605
Salut

J'ai lu ton code très vite fait, et si j'ai bien compris, cette procedure simule le lancer de 2 dés à 10 faces :
Code:

1 2 3 4 function _2D10(const Bonus: integer = 0): integer; begin result := 2 + random(19-Bonus) + Bonus; end;
(Je n'ai pas bien compris a quoi sert le bonus ...)
Mais il faut faire attention car lors du lancer de 2 dés a 10 faces, il y a plus de chances de sortir un 11 que de sortir un 2 ...

et j'aurais plutôt dit :
Code:

1 2 resultat := DiceCombiner([Dice1D10, Dice1D10, Dice1D100, Dice1D100]); // 4..220 --> 12..220
15/12/2009, 13h30
maxiNoob
Citation:
Envoyé par Dr.Who

Code:

1 2 3 type TDice = function(const Bonus: integer = 0): integer;
- tu déclares un type qui est une function 8O
- et au lieu d'un paramètre qui est généralement une variable, tu mets une constante 8O

arf j'en ai à apprendre :mouarf:
Citation:
Envoyé par Dr.Who

Code:

1 2 3 4 5 6 7 8 function _1D10(const Bonus: integer = 0): integer; begin result := 1 + random(10-Bonus) + Bonus; end; var // alias DiceDamage : TDice = _1D10; Dice1D10 : TDice = _1D10;
bonus vaut 0 , il sert à quoi ???
et c'est quoi ces variables déclarées après end ?
c'est quoi alias ??
Citation:
Envoyé par Dr.Who

Code:

1 2 3 4 5 6 7 8 function DiceCombiner(const Dices: array of TDice): integer; var N : integer; begin result := 0; for N := 0 to High(Dices) do result := result + Dices[N]; end;
là tu te doutes que je ne comprend absolument rien :oops:
un tableau de TDice ? un tableau de fonctions ??? :?

peut être utilisé de la sorte :
Citation:
Envoyé par Dr.Who

Code:

1 2 3 4 5 6 resultat := DiceDamage(Player.Str + Player.W1.Dmg - Monster.En - Monster.CA); resultat := DiceCombiner([Dice1D10, Dice1D10, Dice1D100, Dice1D100]); // 4..220
enfin combiner 4 dés pour quoi faire ?? :aie:

je crois que je vais ressortir mes vrais dés :lol: ;)
15/12/2009, 13h46
mick605
Le type function existe bien, je ne m'en suis jamais servi ...

Par contre, le parametre N'EST PAS une constante. C'est un parametre dont la valeur est constante. C'est a dire que lors de l'appel de la fonction, le parametre fourni ne sera pas modifié. Il faut que tu recherches, tu trouvera plus d'infos.

Enfin, le =0 permet de donner une valeur par défaut au parametre. Ainsi, si on doit appeler une fonction tres souvent avec le même paramètre, mais parfois avec un autre, on peut définir une valeur par défaut au parametre. Dans ton exemple, on peut aussi bien faire :
Code:

1 2 3 DiceDamage; DiceDamage(0); DiceDamage(150);

Citation:

Envoyé par mick605

(Je n'ai pas bien compris a quoi sert le bonus ...)
Mais il faut faire attention car lors du lancer de 2 dés a 10 faces, il y a plus de chances de sortir un 11 que de sortir un 2 ...

le bonus sert uniquement si on en as besoin.
la plupart du temps on aura pas besoin du bonus, mais s'il faut l'ajouter, on peu le faire directement avec la fonction plutot que d'additionner la fonction
avec un bonus... (je sais pas si c'est trés clair) ...

non, il y'a autant de chance de sortir n'importe quel nombre de 2 à 20.
je ne vois pas d'explication physique et quantique qui permettrais d'avoir un nombre plutot qu'un autre dans un jet aléatoire.

si l'on retire le bonus qui vaux 0 :

result := 2 + random(19);

random génère des nombres entre 0 et 18 (19-1)
+2 permet d'être dans l'intervalle 2..20
il est impossible de prédire si l'on vas avoir un 11 ou tout autre nombre.
on pourrait même rendre plus chaotique le random en faisant :

2 + (random(100) mod 19);
2 + (random(1000) mod 19);

NOTE IMPORTANTE :
NE PAS OUBLIER D'APPELER RANDOMIZE AU DEBUT DU PROGRAMME!
Citation:
Envoyé par mick605
et j'aurais plutôt dit :
Code:

1 2 resultat := DiceCombiner([Dice1D10, Dice1D10, Dice1D100, Dice1D100]); // 4..220 --> 12..220
non, ici le combiner nous génère un dés don le resultat est entre 4 et 220.
jet mini : 1+1+1+1 = 4
jet maxi : 10+10+100+100 = 220

je ne vois pas d'ou tu sort le 12 ?! 8O

Note : le combiner ne prend pas en compte le bonus.

Citation:

Envoyé par maxiNoob

- tu déclares un type qui est une function 8O
- et au lieu d'un paramètre qui est généralement une variable, tu mets une constante 8O

alors, une fonction est tout simplement un pointer. on peut donc les typer.
Ici le but est d'avoir un type qui peut prendre n'importe qu'elle fonction donc la déclaration est :

Code:

function (const Bonus: integer= 0): integer;

ce qui permet, dans le record Perso, Monstre, Action, Spell etc
de definir un paramêtre de type TDice auquel on assignera la fonction du dés necessaire.

par exemple, si Perso et Monstre partage un champs communs (Attaque) par exemple, mais que le dés est différent pour les deux on pourra faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 TPerso = record Attack : TDice; end; TMonstre = record Attack : TDice; end; const MonstreDefault : TMonstre = (Attack : Dice1D10); PersoDefault : TPerso = (Attack: Dice1D100);
d'ailleur pour la fonction Combiner, tu vois que je peux passer les fonctions en paramètre facilement, grace au type TDice.
je peux donc lui injecter n'importe qu'elle fonctions compatible avec la déclaration TDice.

Citation:

Envoyé par maxiNoob

bonus vaut 0 , il sert à quoi ???

il sert uniquement si on en as besoin, comme on considère que l'on en aura besoin que dans quelque cas, je lui mets une valeur par défaut (à 0) pour qu'il ne soit pas pris en compte dans le calcul.
si j'appel la fonction sans paramètres, Bonus vaux 0
si j'appel la fonction avec un paramètre, Bonus sera égal à la valeur définie.
Code:

1 2 3 Resultat := Dice1D10; Resultat := Dice1D10(20); // bonus de 20 au jet
Citation:

Envoyé par maxiNoob

et c'est quoi ces variables déclarées après end ?

ce sont des alias de la fonction. attention suis bien :
j'ai déclarer un type TDice.
c'est un type fonction compatible avec les déclarations des fonctions des dés.
je peux donc créer des variables de type TDice dont la valeur est la fonction de dés que je veux.
cela permet de créer des alias de nom de fonction.
_1D10 est le nom par défaut
Dice1D10 est un alias de _1D10
DiceDamage est un alias de _1D10

exemple :
Code:

1 2 3 4 5 6 7 begin Damage1 := DiceDamage; Damage2 := DiceDamage(10); // dégat + 10 de bonus Protection := Dice1D10(20); // defense + 20 de bonus Total := Protection - (Damage1 + Damage2); end;
cela rend le code plus parlant encore une fois.
bien sur, DiceDamage et Dice1D10 sont exactement la même fonction (_1D10).

Citation:

Envoyé par maxiNoob

c'est quoi alias ??

comme pour les humains, un alias est un pseudonyme.

Frederic G. alias Dr.Who alias Deefaze alias Fobia alias f0xi.

les alias Dr.Who, Deefaze, Fobia et f0xi désigne tous la même personne, moi...

MaxiNoob est ton alias.

alias est, si je dis pas de bêtise, un dérivé de AKA (also known as : aussi connus sous le nom de)
d'ailleurs ce serait bien si AKA ou ALIAS pouvait être un mot réservé du pascal, ce qui permettrais de faire :

Code:

function Truc: boolean; alias Machin, Bidule, Chouette;

ce qui pourrait être pratique!
mais bon...

Citation:

Envoyé par maxiNoob

là tu te doutes que je ne comprend absolument rien :oops:
un tableau de TDice ? un tableau de fonctions ??? :?

oui est non.
comme je l'ai dis plus haut, une fonction est un pointeur (pour faire simple).
comme on peut créer des tableaux de pointeurs ...
on peut créér des tableaux de fonctions. :)
tout simplement.
génial non ?

la déclaration :

Code:

const ADices : array of TDice

est semblable à la déclaration de Format, la fonction ben pratique qui permet de formatter des valeurs de types différents dans une chaine.
la déclaration de format (simplifiée) est :

Code:

const FmtStr: string; const Args : array of const

note bien le array of Const!
t'es perdus ? normal ...

ici le array of const, accépte quasiment tout est n'importe quoi.
integer, byte, single, double, pointeur, fonction, chaine, caractère, objet, propriété ...

si mon combiner permet de passé en paramètres plusieurs fonction compatible TDice en arguments,
format, par sa déclaration permet de passer en arguments divers types.
regarde dans ma signature, le premier liens (codes et source de Dr.Who),
sur ma page tu trouvera un tuto complet sur Format.
cela t'eclairera surement.

Citation:

Envoyé par maxiNoob

enfin combiner 4 dés pour quoi faire ?? :aie:

au cas ou cela peut être utile.
inutile si ce n'est pas le cas.
pour la beauté de la chose.
et pour te montrer cette façon de faire.

Yep

Je pense que tu fais quelques erreurs dans ton raisonnement.
D'après maxiNoob (qui ne l'est plus pourtant), on joue soit avec un dé de 10, soit 2 dés de 10, soit un dé de 100.

le dé de 10 peut prendre : 1,2,3,4,5,6,7,8,9,10
le dé de 100 peut prendre :10,20,30,40,50,60,70,80,90,100

Citation:

non, il y'a autant de chance de sortir n'importe quel nombre de 2 à 20.
je ne vois pas d'explication physique et quantique qui permettrais d'avoir un nombre plutot qu'un autre dans un jet aléatoire.

Il y en a pourtant bien une :
2 dés de 10, chacun ayant une probabilité identique de sortir un nombre de 1 à 10.

Mettons les résultats dans un tableau pour mieux voir : chaque case est la somme du dé 1 (ligne du haut) et du dé 2 (colonne de gauche)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 --+---+---+---+---+---+---+---+---+---+--- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11 --+---+---+---+---+---+---+---+---+---+--- 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12 --+---+---+---+---+---+---+---+---+---+--- 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13 --+---+---+---+---+---+---+---+---+---+--- 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14 --+---+---+---+---+---+---+---+---+---+--- 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15 --+---+---+---+---+---+---+---+---+---+--- 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16 --+---+---+---+---+---+---+---+---+---+--- 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16| 17 --+---+---+---+---+---+---+---+---+---+--- 8 | 9 | 10| 11| 12| 13| 14| 15| 16| 17| 18 --+---+---+---+---+---+---+---+---+---+--- 9 | 10| 11| 12| 13| 14| 15| 16| 17| 18| 19 --+---+---+---+---+---+---+---+---+---+--- 10| 11| 12| 13| 14| 15| 16| 17| 18| 19| 20 --+---+---+---+---+---+---+---+---+---+---
Chaque case à la même probabilité de sortir, on remarque que le 11 est présent sur 10 cases, et le 2 sur une seule case ... On a donc 10 fois plus de chances de sortir un 11 qu'un 2 ...

C'est logique, pour faire 2, il faut obligatoirement 1 et 1
pour faire 11 on peut faire :
1 - 10
2 - 9
3 - 8
4 - 7
5 - 6
6 - 5
7 - 4
8 - 3
9 - 2
10 - 1

Ensuite :

Citation:

on pourrait même rendre plus chaotique le random en faisant :
2 + (random(100) mod 19);
2 + (random(1000) mod 19);

Et surtout plus faux ! Qu'est ce qu'il t'as fait ce pauvre 20 :lol:
Non, je plaisante, mais dans cet exemple, déja il se contredit avec l'exemple que je t'ai donné ci dessus, et en plus, il ne donne pas la meme probabilité de sortir un nombre de 0 à 20 :?

On va prendre a la place :

Code:

Result:= random(100) mod 7

Dans ce cas, les seules valeurs possibles sont : 0,1,2,3,4,5,6
Mais dans cet exemple, le 6 a une proba légerement moins forte d'être sorti que le 0.

Preuve :
Les restes sont
0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6, etc ... et fini par 0,1,2,3,4,5,6,0,1
Donc, le 6 aura été tiré n fois (exactement 14 fois), et le 0 n+1 fois (exactement 15)
Donc :
Proba de sortir 0 : 15/100
proba de sortir 6 : 14/100 :ccool:

Pour que ca reste équiprobable, tu peux faire

Code:

Result:= random(98) mod 7

ou plus généralement pour trouver un nombre entre [0..p-1],

Code:

Result:= random(n*p) mod p //pour tout n

Mais, ca ne deviendra pas plus chaotique que ca l'est déja ...

Citation:

non, ici le combiner nous génère un dés don le resultat est entre 4 et 220.
jet mini : 1+1+1+1 = 4
jet maxi : 10+10+100+100 = 220

je ne vois pas d'ou tu sort le 12 ?!

C'est vrai, j'ai fait une erreur sur le 12 ... C'EST 22 :P
Et non, le jet mini n'est pas 1+1+1+1, mais 1+1+10+10 car le dé de 100 ne peut pas descendre en dessous de 10 (incrémentation de 10 pour ce dé)

Perso, je ne serais pas parti aussi loin pour faire un truc si simple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 type TUnDe = record Faces, Increment : integer; end; function LancerDes (TabDes : array of TUnDe) : integer; var i : integer; begin Result:=0; for i:=Low(TabDes) to High(TabDes) do Result:=Result + (Random(TabDes[i].Faces)+1)*TabDes[i].Increment; end;
Pour appeler :
Code:

1 2 3 4 5 6 7 const De10 : TUnDe = (Faces : 10; Increment :1); De100 : TUnDe = (Faces : 10; Increment :10); LancerDes([De10]) //Lancer d'un dé 10 LancerDes([De10,De10]) //Lancer de 2 dés 10 LancerDes([De10,De100]) //Lancer d'un dé 10 et d'un dé 100
Voila ... Par contre, un lancer de dé de 10 et un lancer de dé 100 permet d'aller jusqu'a 110 ... C'est bien ce que tu veux ?

15/12/2009, 21h05
maxiNoob

houla mollo les gars sur les maths :lol:

votre débat est captivant, je n'avais pas pensé à tout ça

du coup en cherchant j'ai trouvé ça sur wikipédia:

http://fr.wikipedia.org/wiki/Probabi...u_de_r%C3%B4le

les dés sont numérotés de 0..9 ou 00..90

si il sort 0 + 00 ça vaut 100, donc zéro est impossible

chaque face ayant les mêmes chances de sortir, il n'y a qu'une seule possibilité de fair 13 ou 45 : 10+3 et 40+5 donc pour le D100, la function simple random(100)+1 suffit et convient, résultats de 1..100 et jamais au dessus de 100, donc surtout pas 110

il n'y a donc que pour les 2 D10 qu'il ne faut pas utiliser le D20

argh, débat Oh Combien salutaire

bon je vais aller chercher de l'aspirine et je retourne à notre projet
15/12/2009, 21h16
mick605

Citation:

Envoyé par maxiNoob

les dés sont numérotés de 0..9 ou 00..90

si il sort 0 + 00 ça vaut 100, donc zéro est impossible

Ah, j'avais pas compris ca (je crois que Dr n'avais pas compris ca non plus ...)
Alors ca change tout ... Je changerai tout des que j'aurais le temps ...

oui j'aurai du commencer par être clair, c'est à dire expliquer le système de dés

veuillez me pardonner, on croit tj que c'est évident alors que pas du tout en fait

je résume à la sortie des zéros en utilisant le D10 (0..9) et le D100 (00..90)

Ddizaine: 00 Dunité: 0 > valeur 100

Ddizaine: 00 Dunité: 3 > valeur 003 donc 3

Ddizaine: 10 Dunité: 0 > valeur 10

Je pense de toute façon que cette réflexion s'imposait, merci encore

voilà ce que je propose:
Code:

1 2 3 4 5 6 7 8 9 10 //*** simulation du lancer des Dés function LaunchDices(NbDices, sizeDice: integer): integer; begin case NbDices of 1: LaunchDices := random(SizeDice)+1; // utilisable pour 1D10 ou 1D100 1..100 2: LaunchDices := random(SizeDice)+random(SizeDice)+2; //pour 2D10 2..20 end; MessageDlgPos('Jet de Dés: '+IntToStr(NbDices)+' D'+IntToStr(sizeDice)+ ' > '+IntToStr(LaunchDices),mtInformation, [mbOK], 0,360,210); end;

Code:

1 2 MessageDlgPos(format('Jet de Dès : %dD%d = %d, [NbDices, SizeDice, Result]),mtInformation, [mbOK], 0,360,210);
tu n'est plus en TPW, tu peux utiliser Result pour le retour de fonction (plus pratique que d'utiliser l'identifiant).

la fonction n'est pas utile, utilise les modèles que je t'ai fournis.

utilise format pour formatter les chaines et evite les longues additions de fonction IntToStr ... trop fastidieux à ecrire et lire.

ecrire random(10) + random(10) + 2 pour 2D10 est tout à fait inutile.

2 + random(19) est suffisant.

par contre, quand on génére un couleur avec random, il est préférable d'écrire :
random(256) * random(256) * random(256)
ou
(128+random(127)) * (128+random(127)) * (128+random(127))

mais la c'est particulier.

donc pour en revenir aux dés :

1D10 :

result := 1 + random(10);

2D10 :

result := 2 + random(19);

1D100+1D10 :

result := 1 + random(100);

pour obtenir un vrai dés de cents il faudrait faire :

result := 10 * random(10); // 0, 10, 20 ... 70, 80, 90

mais ... c'est inutile ...

puisque le but du 1D10 est d'obtenir une valeur de 1 à 10 (1+random(10))
le but du 2D20 est d'obtenir une valeur de 2 à 20 (2+random(19))
le but du 1D100+1D10 est d'obtenir une valeur de 1 à 100 (1+random(100))

d'ailleur si nous avions des dés physique à 100 faces, nous n'aurions pas besoin d'un D10 pour les dizaines.
sauf qu'un dés à 100 face serait plus proche d'une boule et donc ... impossible de savoir sur quoi on tombe.

ainsi le dés 100 est un faux dés 10 (numéroté de 00 à 90)
le dés 50 est un faux dés 5 (numéroté de 00 à 40)
etc.

sauf qu'il faut oublier le dés physique quand on transcrit tout cela en informatique.
il faut penser langage de prog et pas modèle physique.

si dans le JDR on lance d'aborde D100 puis D10, qu'on additionne pour avoir le resultat, on ne doit pas forcement faire pareil en prog ...

faire :

result := (10*random(10)) + 1 + (1 + random(10)); ?

inutile :

result := 1 + random(100);

paf. :ccool:

et pour résumé, la formule que je donne depuis le début :
Code:

1 2 3 4 5 6 result := NombreDes + random((NombreFace*NombreDes)+1-NombreDes); // 1 + random(10*1+1-1) :: 1 + random(10) :: 1..10 // 2 + random(10*2+1-2) :: 2 + random(19) :: 2..20 // 1 + random(100*1+1-1) :: 1 + random(100) :: 1..100
est la bonne. générique, adaptées pour tout les dés et combinaisons de dés.

16/12/2009, 00h27
mick605

Citation:

Envoyé par Dr.Who

ecrire random(10) + random(10) + 2 pour 2D10 est tout à fait inutile.

2 + random(19) est suffisant.

Nooooon ! :mouarf:
Tu n'as lu ni mon post, ni le lien de maxiNoob alors ... Niveau probabilité ce n'est pas du tout la même chose !!

MaxiNoob, garde ton code je pense. Apres tout, pas besoin de sortir l'usine a gaz pour creer une fonction qui ne servira que sous 3 formes précises ...
16/12/2009, 02h45
Dr.Who

hehehe, sisi j'ai lus.

ce qui m'a intrigué et je me suis lancé dans quelques tests :

R = 10*random(10) + (random(10)+1)
distribution uniforme 0.99% .. 1.01%

R = 1+random(100)
distribution uniforme 0.99% à 1.01%

R = 2 + random(10) + random(10)
distribution chaotique : 1 à 10%
la probabilité se vérifié, 11 sort bien plus souvent que les autres (généralement dans les 9..11%).
réaliste!

R = 2 + random(19)
distribution uniforme 5.24% à 5.29%

par contre, les distributions du dés de D100 D10 ne sont pas trés cool.
puisque chaque valeur à 1% de chance de sortir au poil prés.

j'ai tester trois formules qui me semble pas mal et on un air de distribution gaussienne.

formule :
R = 1 + random(50) + random(51)
distribution parabolique sommet 50 (1.98%), 1 et 100 fréquent (~15 sur 1 000 000 de lancés)
plutôt bonne.

formule :
R = 1 + random(25) + random(26) + random(51)
distribution parabolique sommet 50, 1 et 100 rare (~3 sur 1 000 000 de lancés)
plutôt bonne.

formule :
R = 1 + random(34) + random(34) + random(34)
distribution parabolique sommet 49, 50, 51, 1 et 100 plutôt rare (~30 sur 1 000 000 de lancés)
plutôt bonne et assé réaliste ...
16/12/2009, 07h19
maxiNoob

Quel débat !!!

Mais c'est vrai que le jeu de rôle repose sur le suspense des dés, c'est donc très important, et c'est vrai qu'un bonne partie du jeu tourne autour de ses résultats attendus avec anxiété par les joueurs.

Doc> quand tu dis qu'en programmant on ne doit pas se soucier des Dés physiques, je ne suis pas d'accord, je pense au contraire que celà doit y ressembler le plus possible, d'ailleurs qd j'aurai progressé je me pencherai sur ton super programme de dés avec animation, mais j'en suis pas là.

Mais comme vous m'avez appris à coder modulairement, mon code DiceSimulator est dans une unité indépendante, et si j'ai bien tout compris je n'aurai pas de difficulté à changer de version

Avec le fiston on a envie d'avoir qq chose qui ressemble au vrai jeu et donc le tirage des dés est qq chose de capital, on doit ressentir la même ambiance et obtenir le même genre de résultats en terme de probabilité.

donc je suis convaincu que random(10) + random(10) colle plus au jeu réel que random(20) car effectivement tu fais plus souvent 7 ou 8 que 2 ou 20, c'est d'ailleurs plus logique car ainsi on obtient plus fréquemment des résultats moyens que les extrêmes, sinon l'ambiance devient très différente :lol:

doit on adapter l'informatique au réel ou le contraire ?

selon moi le PC reste un esclave qu'on fouette et qui doit faire ce qu'on demande :lol:

en tout cas merci pour la leçon sur MessageDlgPos :ccool:

mick>
c'est vrai que le doc propose des usines à gaz, mais c'est pour m'instruire en apportant moultes exemples et façons de programmer ;) je ne comprends pas la moitié de ce qu'il propose, mais chaque jour un peu plus, or c'est ça le but: apprendre à coder

1 pièce(s) jointe(s)

arf, en fait pour les dés, quand je dis qu'il faut pas s'en soucier, c'est d'un tout autre point de vue.

ce que je voulais dire par la, c'est qu'on ne pourra pas reproduire à l'identique, à moins d'un gros code enorme, le comportement d'un dés.

par exemple, un dés virtuel n'est jamais cassé !

un dés virtuel n'est pas soumis au paramètre de lancé physique (gravité, rebond, etc).

ou alors, il faudrait faire un modèle complexe en 3D avec gestion de tout ces paramètre ... houla.

as tu tester les formules que j'ai noté pour le D100 ?
celle avec les 34 me semble plutôt pas mal au niveau des resultats.

d'ailleur je pense qu'on pourrait ecrire le D10 sur le même modèle :
R = 1 + random(4) + random(4) + random(4);

regarde les resultats :

1D100 & 1D10 par R = 1 + ~33 + ~33 + ~33
2D10 par R = 2 + ~9 + ~9
1D10 par R = 1 + ~3 + ~3 + ~3

http://www.developpez.net/forums/att...1&d=1260973079

belle distributions non ?

le code :
Code:

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 unit Unit3; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm3 = class(TForm) ListBox1: TListBox; ListBox2: TListBox; Button1: TButton; Button2: TButton; ListBox3: TListBox; Button3: TButton; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); procedure Button3Click(Sender: TObject); private { Déclarations privées } public { Déclarations publiques } end; var Form3: TForm3; implementation {$R *.dfm} procedure TForm3.Button1Click(Sender: TObject); var N : integer; V : array[1..100] of integer; begin ListBox1.Clear; ZeroMemory(@V, SizeOf(V)); for N := 0 to 999999 do // inc(V[1 + random(20) + random(21) + random(21) + random(21) + random(21)]); // inc(V[1 + random(50) + random(51)]); inc(V[1 + random(34) + random(34) + random(34)]); for N := 1 to 100 do ListBox1.Items.Add(format('%3.d : %6.2f%% : %6.d',[N, V[N]/10000, V[N]])); end; procedure TForm3.Button2Click(Sender: TObject); var N : integer; V : array[2..20] of integer; begin ListBox2.Clear; ZeroMemory(@V, SizeOf(V)); for N := 0 to 999999 do inc(V[ 2 + random(10) + random(10) ]); for N := 2 to 20 do ListBox2.Items.Add(format('%3.d : %6.2f%% : %6.d',[N, V[N]/10000, V[N]])); end; procedure TForm3.Button3Click(Sender: TObject); var N : integer; V : array[1..10] of integer; begin ListBox3.Clear; ZeroMemory(@V, SizeOf(V)); for N := 0 to 999999 do //inc(V[ 1 + random(10) ]); inc(V[ 1 + random(4) + random(4) + random(4) ]); for N := 1 to 10 do ListBox3.Items.Add(format('%3.d : %6.2f%% : %6.d',[N, V[N]/10000, V[N]])); end; initialization Randomize; end.
oui j'ai tendance à te donner pleins d'exemple, ce qui n'est pas forcement une bonne chose, puisque trop d'information, tue l'information.
mais c'est le soucis de te montrer toute les pistes exploitable.

sinon en parlant de ça, j'ai un pack de portrait de pj tiré des baldur's gates et autres jeux du genre, ça t'intéresse ?

16/12/2009, 20h27
mick605

Salut

Alors, les distributions que tu donnes sont très étranges ... Pour un seul dé à 10 faces, il y a autant de chances pour que chaque face tombe ...

Déja, quel bouton est associé a quel code ... Je pense que c'est dans l'ordre, mais bon ... Ensuite, quel code est utilisé ? Celui en commentaire ou pas ?

Normalement, une équiprobabilité des résultats donnés par 2 dés est réalisée si on a Result := Random(n)+Random(p)*n;
Ainsi, dans ce cas,

Code:

Random(n)+Random(p)*n;

est équivalent à

Code:

Random(n*p);

Mais seulement dans ce cas ...

En fait, a partir du moment ou une valeur peut-être calculée de 2 manières différentes, la proba augmente. La probabilité d'obtenir une valeur est directement proportionnelle au nombre de combinaisons différentes pour calculer cette valeur.

Voila ! Je pense maintenant qu'on a tous compris les dés ... Codage NOW !
16/12/2009, 20h55
darrylsite

Citation:

Envoyé par mick605

Salut

En fait, a partir du moment ou une valeur peut-être calculée de 2 manières différentes, la proba augmente. La probabilité d'obtenir une valeur est directement proportionnelle au nombre de combinaisons différentes pour calculer cette valeur.

Voila ! Je pense maintenant qu'on a tous compris les dés ... Codage NOW !

Je n'est pas lu tous les posts, mais question probabilité je serais bien d'accord avec mick605.
17/12/2009, 00h26
Dr.Who

Citation:

Envoyé par mick605

Alors, les distributions que tu donnes sont très étranges ... Pour un seul dé à 10 faces, il y a autant de chances pour que chaque face tombe ...

coucou,
tu n'as pas vus mes nouvelles formules dans mon post précédent ?
et l'image que j'ai posté ?

Citation:

Envoyé par mick605

Déja, quel bouton est associé a quel code ... Je pense que c'est dans l'ordre, mais bon ... Ensuite, quel code est utilisé ?

suffit de lire, il sont dans l'ordre -> indice voir déclaration de V ;)
(j'aurais du nommer les boutons ... )

Citation:

Envoyé par mick605

Celui en commentaire ou pas ?

ben non ... comment veux tu qu'un code en com puisse être compilé ?

Citation:

Envoyé par mick605

Voila ! Je pense maintenant qu'on a tous compris les dés ... Codage NOW !

c'est clair!
17/12/2009, 00h59
mick605

Citation:

Envoyé par Dr.Who

coucou,
tu n'as pas vus mes nouvelles formules dans mon post précédent ?
et l'image que j'ai posté ?

Si, c'est sur cette image que j'ai vu cette répartition de 1D10

Citation:

Envoyé par Dr.Who

ben non ... comment veux tu qu'un code en com puisse être compilé ?

^^ ! Ce que je voulais dire, c'est que pour les tests, tu aurais pu mettre le code en comm pour ne pas le perdre, mais nous montrer les résultats qu'il produit ^^ !

Donc si j'ai bien compris, sur ton image, a droite, c'est les résultats pour 3 dés a 4 faces ?

Code:

inc(V[ 1 + random(4) + random(4) + random(4) ]); // voir Dr.Who

Voir 40 message(s) de cette discussion en une page