Discussion :

[Dr.Who]

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

cDf +B

Dés + bonus.

on aura plutot besoin de la fonction :

Code :

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

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 :

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

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

pour un nain :
1.0m + 2D10

Code :

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

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

dégat d'une dague rouillé ?

Code :

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

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

dégat d'une dague normale ?

Code :

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

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

dégat d'une dague d'argent ?

Code :

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

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

ou de façon générique :

Code :

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

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

qui peut être :

sorts :

Code :

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

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 :

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

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 :

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

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 :

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

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 :

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

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));

[maxiNoob]

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

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à:



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

[Dr.Who]

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 :

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
 
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 :

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

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

[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 :

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

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 :

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

1
2
resultat := DiceCombiner([Dice1D10, Dice1D10, Dice1D100, Dice1D100]);
// 4..220  -->   12..220

[maxiNoob]

Code :

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

1
2
3
 
type
  TDice = function(const Bonus: integer = 0): integer;

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

arf j'en ai à apprendre

Code :

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

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 ??

Code :

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

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
un tableau de TDice ? un tableau de fonctions ???


peut être utilisé de la sorte :

Code :

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

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 ??

je crois que je vais ressortir mes vrais dés

[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 :

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

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

[Dr.Who]

(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!

et j'aurais plutôt dit :

Code :

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

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 ?!

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

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

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 :

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

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 :

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

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.

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 :

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

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

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 :

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

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).

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 :

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

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

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

là tu te doutes que je ne comprend absolument rien
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 :

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

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 :

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

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.

enfin combiner 4 dés pour quoi faire ??

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.

[mick605]

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

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 :

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
  | 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 :

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
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 :

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

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

Pour que ca reste équiprobable, tu peux faire

Code :

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

Result:= random(98) mod 7

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

Code :

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

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

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

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
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 :

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

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 :

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

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 ?

[maxiNoob]

houla mollo les gars sur les maths

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

[mick605]

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 ...

[maxiNoob]

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 :

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

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;

[Dr.Who]

Code :

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

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.


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

Code :

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

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.

[mick605]

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

2 + random(19) est suffisant.

Nooooon !
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 ...

[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 ...

[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

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

en tout cas merci pour la leçon sur MessageDlgPos


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

[Dr.Who]

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



belle distributions non ?

le code :

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
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 ?

[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 :

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

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

est équivalent à

Code :

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

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 !

[darrylsite]

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.

[Dr.Who]

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é ?

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 ... )

Celui en commentaire ou pas ?

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

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

c'est clair!

[mick605]

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

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 :

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

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