Pen Settings

HTML

CSS

CSS Base

Vendor Prefixing

Add External Stylesheets/Pens

Any URL's added here will be added as <link>s in order, and before the CSS in the editor. If you link to another Pen, it will include the CSS from that Pen. If the preprocessor matches, it will attempt to combine them before processing.

+ add another resource

JavaScript

Babel is required to process package imports. If you need a different preprocessor remove all packages first.

Add External Scripts/Pens

Any URL's added here will be added as <script>s in order, and run before the JavaScript in the editor. You can use the URL of any other Pen and it will include the JavaScript from that Pen.

+ add another resource

Behavior

Save Automatically?

If active, Pens will autosave every 30 seconds after being saved once.

Auto-Updating Preview

If enabled, the preview panel updates automatically as you code. If disabled, use the "Run" button to update.

Format on Save

If enabled, your code will be formatted when you actively save your Pen. Note: your code becomes un-folded during formatting.

Editor Settings

Code Indentation

Want to change your Syntax Highlighting theme, Fonts and more?

Visit your global Editor Settings.

HTML

              
                <div class="article">
Si je vous parle de dés, immédiatement vous imaginez un petit cube à 6 faces numérotées de 1 à 6 : c'est ce que l'on appel un d6 dans le jargon des jeux de rôle. Mais le d6 n'est pas le seul, et surtout, le d6 plus performant en terme d'équilibre de hasard.

C'est pourquoi je souhaite vous présenter le seul dé capable de simuler à lui seul des dés comme les d4, d6, d8, d10, d12 ou d20 et j'en passe tout en étant le plus équilibré qu'il soit possible de l'être : j'ai nommé le d120 !

<figure>
<img width="288" height="232" src="https://blog.lesieur.name/media/images/upload/D120Amber.jpg" alt="Le dé ultime, le d120 !" style="max-width: 288px; width: 100%; height: auto;">
<figcaption><a href="http://thedicelab.com/" target="_blank">d120 de The Dice Lab</a></figcaption>
</figure>

Je vous propose de découvrir dans cet article :

- pourquoi le d120 est appelé (ici) le dé ultime,
- comment le d120 peut être à lui seul utilisé pour faire office de d1 jusqu'au d119 (en passant bien entendu par le très utile d100),
- les tables de correspondance associées des dés multiples de 120,
- les outils pour aligner votre d120 sur vos statistiques ou aligner vos statistiques sur votre d120.
- les idées originales pour profiter des 120 valeurs à votre disposition.

On finira bien entendu par le moyen de vous procurrer le d120 !

> Si vous êtes développeur JavaScript et que vous cherchez des exemples d'utilisation de [Vue.js](https://vuejs.org/) à la volée (comme on utiliserait simplement jQuery), ou que vou souhaitez vérifier les fonctions utilisées dans cet article, vous pouvez jeter un œil au code source de cet article derrière le CodePen suivant : https://codepen.io/Haeresis/pen/qGQLvp





## Pourquoi le d120 est le dé ultime ?

Saviez-vous que la sommes de chacun des côtés opposés d'un d6 fait 7 ? En effet `1 + 6 = 7`, `2 + 5 = 7` et `3 + 4 = 7` ! Intuitivement, on pourrait se dire que c'est une manière de répartir correctement les valeurs du dé pour que celui-ci ne soit pas pipé. Et bien en réalité, pas tout à fait.

### Le problème du d6

Si on observe le dé depuis les sommets, on s'aperçoit que l'un des sommets touche les 3 plus petites valeurs (1, 2 et 3) et que son opposé touche les trois plus grosses valeurs (4, 5 et 6). En d'autres termes, s'il semble difficile de faire tomber le dé exactement sur une face par chance, cela l'est moins en ce qui concerne de le faire tomber sur une partie plutôt qu'une autre plus souvent ; et donc, si on est doué, de jouer avec le hasard.

<figure>
<img width="260" height="220" src="https://blog.lesieur.name/media/images/upload/1-2-3-4-5-6.png" alt="Équilibre du dé 6" style="max-width: 260px; width: 100%; height: auto;">
<figcaption>Équilibre du dé 6</figcaption>
</figure>



### Des alternatives ?

Bien sûr, il est possible de répartir plus équitablement les valeurs autour des faces mais cela se fait alors au détriment de l'égalité de valeur sur les faces opposées et inversement. Ainsi il existe des dés bien plus équilibré que le d6 classique comme la collection de _The Dice Lab_ : les dés OptiDice™ avec ses d4, d6, d8, d10, d12 et d20 hautement équilibré mais... toujours imparfait.

<figure>
<img width="310" height="201" src="https://blog.lesieur.name/media/images/upload/OptiDiceSetBlue.jpg" alt="d4, d6, d8, d10 (d100), d12, d20" style="max-width: 310px; width: 100%; height: auto;">
<figcaption><a href="http://thedicelab.com/" target="_blank">OptiDices de The Dice Lab</a></figcaption>
</figure>

Imparfait car il semble impossible d'obtenir avec les dés OptiDice™ (ou tout autre dé similaire) un dé parfait dont :

- La somme des valeurs de chaque pair de faces opposés (si elles existent) soit identique ET
- La moyenne de la somme des valeurs des faces autour de chaque sommet soit identique.



### Le d120, la solution !

Alors la question se pause : est-il possible de créer un dé qui puisse à la fois avoir les sommes de tous ses côtés opposés identiques, des faces ayant absoluement la même forme et également une répartition des valeurs sur les faces autour de ces sommets de manière à ce que le dé soit équilibré ?

Et bien oui ! Le d120 (soit 120 faces identiques) répond à ces critères et constitue le plus petit dé équilibré que l'on puisse créer ! Tout y est :

- La somme des valeurs de chaque pair de faces opposés est égale à 121 ET
- La moyenne de la somme des valeurs des faces autour de chaqu'un de ses 62 sommets vaut toujours 60,5 (605 / 10 pour 12 sommets, 363 / 6 pour 20 sommets et 242 / 4 pour 30 sommets). Cela correspond également à la moyenne des 120 faces.

<figure>
<img width="360" height="283" src="https://blog.lesieur.name/media/images/upload/d120five0316.jpg" alt="d120" style="max-width: 260px; width: 100%; height: auto;">
<figcaption><a href="http://thedicelab.com/" target="_blank">Les d120 de The Dice Lab</a></figcaption>
</figure>

En plus de répondre à tous les critères précédents, il permet de simuler en un seul jet de dé les d1, d2, d3, d4, d5, d6, d8, d10, d12, d15, d20, d24, d30, d40, d60 et d120. Il peut également simuler les autres dés non nommés précédemment du d7 jusqu'au d119 en minimum un jet de dé ! C'est ce que nous allons voir plus loin.

Pour savoir plus en détail pourquoi le d120 est ultime, je vous laisse jeter un œil à la vidéo de Mickaël Launay de la chaine Mickmath sur le sujet :

<iframe style="display: block; width: 100%; max-width: 560px; height: 315px; margin-left:auto; margin-right: auto; margin-top: 16px" width="560" height="315" src="https://www.youtube.com/embed/N-DPQ7XOHnU" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>





## Tables standards

Tout d'abord commençons par les tables standards qui ne nécessitent qu'un seul jet de dé. Il s'agit de table dont le X de dX est un multiple de 120. Il en existe 16.

  
  
### Simuler des dés standards avec un d120

Accédez aux tables associatives ci-dessous pour simuler le dé dont vous avez besoin. Quand votre dé tombe sur une valeur comprise dans l'intervalle de la colonne de gauche, votre résultat est en réalité la valeur de la colonne de droite.

<ul>
    <li><a href="https://blog.lesieur.name/d120/#d1">Simuler un d1 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d2">Simuler un d2 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d3">Simuler un d3 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d4">Simuler un d4 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d5">Simuler un d5 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d6">Simuler un d6 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d8">Simuler un d8 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d10">Simuler un d10 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d12">Simuler un d12 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d15">Simuler un d15 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d20">Simuler un d20 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d24">Simuler un d24 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d30">Simuler un d30 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d40">Simuler un d40 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d60">Simuler un d60 avec un d120</a></li>
</ul>

<div class="standards">
<div
        v-for="dice in diceList()"
        :key="dice.value">
        <div class="h3" :id="'d' + dice.value">Simuler un d{{ dice.value }} avec un d{{ d120 }}</div>
        <table>
            <tr>
                <th>Si vous faites entre … et … (inclus)</th>
                <th>alors le résultat est …</th>
            </tr>
            <tr
                v-for="table in tableList(dice.value)"
                :key="table.to">
                <td>{{ table.fromLowerDisplay }} - {{ table.fromUpperDisplay }}</td>
                <td class="to">{{ table.to }}</td>
            </tr>
        </table>
    </div>
</div>





## Table personnalisée

Cependant, il est également possible de simuler des dés non standards comme le d7, d9, d11, d13, …, d118 et d119. Plus le dé sera petit, plus il y aura de chance que la résolution de la valeur dans la table ne se face qu'avec un seul jet de dé. Cependant, pour les valeurs limites, afin de trancher, il faudra relancer un dé (voir plus).



### Simuler un dé personnalisé avec un d120

Remplissez le champ ci-dessous pour choisir le dé que vous souhaitez utiliser.

<div class="custom">
<blockquote>
<p>
<strong><samp>OK</samp></strong>
Quel dé voulez-vous simuler ?
<input type="" name="" v-model="custom" placeholder="dé entre 1 et 120">
<span v-if="(customInt && customInt > d120) || (customInt && customInt < 1)"><em>La valeur doit être comprise entre 1 et {{ d120 }}.</em></span><span v-if="isNaN(customInt)"><em>La valeur doit être un nombre.</em></span>
</p>
</blockquote>
<blockquote v-if="customInt && customInt <= d120 && customInt > 0">
<p>
Multiplicateur de dé <input type="" name="" v-model="multiplicator" placeholder="nombre de d120">
<span v-if="multiplicatorInt && multiplicatorInt < 1"><em>La valeur doit être 1 ou plus.</em></span><span v-if="isNaN(multiplicatorInt)"><em>La valeur doit être un nombre.</em></span><span><em><a href="https://blog.lesieur.name/d120/#convertisseur-de-dés-multiples-équilibrés">Voir la section suivante pour comprendre l'utilité du multiplicateur</a></em></span>
</p>
<p></p>
</blockquote>

<div v-if="customInt && customInt <= d120 && customInt > 0 && multiplicatorInt && multiplicatorInt > 0">
<div class="h3" id="custom">Simuler un d{{ customInt }} avec un d{{ d120 }}</div>
<p>Quand votre dé tombe sur une valeur de la colonne de gauche, vous avez en réalité fait la valeur de la colonne de droite. Quand il vous est proposé de lancer un <a href="https://blog.lesieur.name/d120/#un-d10-avec-un-d120">d10</a>, le résultat de ce lancer va décider si votre résultat est la valeur basse ou la valeur haute. Si la valeur du <a href="https://blog.lesieur.name/d120/#un-d10-avec-un-d120">d10</a> est :</p>
<ul>
<li>inférieure au chiffre le plus à gauche de la liste entre « […] » alors le résultat est la valeur basse,</li>
<li>supérieur au chiffre le plus à gauche de la liste entre « […] » alors le résultat est la valeur haute,</li>
<li>égale au chiffre le plus à gauche de la liste entre « […] » alors recommencez avec le chiffre suivant le plus à gauche.</li>
</ul>
<p>Si vous arrivez au dernier chiffre, faire ce chiffre signifie que le résultat est la valeur basse.</p>
<blockquote>
<p>
Filtrez une valeur du dé <input type="" name="" v-model="customFilter" placeholder="valeur faites par votre d120">
<span v-if="(customFilterInt && customFilterInt > d120) || (customFilterInt && customFilterInt < 1)"><em>La valeur doit être comprise entre 0 et {{ d120 }}.</em></span><span v-if="isNaN(customFilterInt)"><em>La valeur doit être un nombre.</em></span>
</p>
</blockquote>
<table>
<tr>
<th>Si vous faites …</th>
<th>alors le résultat est …</th>
</tr>
<template
v-for="(table, index) in tableList(customInt)"
:key="table.from">
<tr>
<td>
{{ table.from }} <span v-if="table.list">puis lancer un <a href="https://blog.lesieur.name/d120/#un-d10-avec-un-d120">d10</a> !</span>
</td>
<td class="to"
v-if="!table.list">{{ table.to * multiplicatorInt }}</td>
<td class="to info"
v-if="table.list">
{{ table.to * multiplicatorInt }} ou {{ table.toPlus * multiplicatorInt }} <small>[{{ table.list }}]</small>
<small class="plus">Si la valeur du <a href="https://blog.lesieur.name/d120/#un-d10-avec-un-d120">d10</a> est :<br>- inférieure au chiffre le plus à gauche de la liste entre « […] » alors le résultat est un {{ table.to }},<br>- supérieur au chiffre le plus à gauche de la liste entre « […] » alors le résultat est un {{ table.toPlus }},<br>- égale au chiffre le plus à gauche de la liste entre « […] » alors recommencez avec le chiffre suivant le plus à gauche. Si vous arrivez au dernier chiffre, faire ce chiffre signifie que le résultat est un {{ table.to }}.</small>
</td>
</tr>
</template>
</table>
</div>

  
  
  
  
## Multiples lancers avec un d120
  
Si vous faites du jeu de rôle, vous connaissez surement la notation **AdX**. Dans cette notation :

- A est le nombre de dés qu'il faut lancer (pouvant être omis s'il vaut 1, 
comme partout dans cet article),
- X est le nombre de face pour chacun des dés.

Ainsi s'il vous est demandé de faire un **6d6** cela signifie que vous devez lancer 6 dés de six faces… ou 1d36 avec la table personnalisée du d120 pour créer un d36 !



### Limitations sans d120
  
> _`OK`_
> Dans un lancé **AdX** standard, il y a deux phénomènes inhérants au fait qu'on utilise plusieurs dés. Le premier est l'_inaccessibilité des valeurs basses_ et le second la _non équiprobabilité des résultats_.
> 
> #### L'inaccessibilité des valeurs basses
> 
> Si vous lancez 6d6, vous pourrez uniquement obtenir des résultats entre 6 et 36 car l'usage de 6 dés signifie qu'au minimum chaque dé tomberra sur 1 (`1 + 1 + 1 + 1 + 1 + 1 = 6`). Vous ne pourrez donc jamais atteindre la valeur 4.
> 
> #### La non équiprobabilité des résultats
> 
> Si je demande quelle est la probabilité d'obtenir plus de 90 lors d'un lancé de 6d20 (1d120), alors puisque 90 représente 3/4 de 120, on serait tenté de dire rapidement qu'elle est de 25%. Pour le dire autrement, une chance sur 4 de faire au moins 90 ou plus. Hors ce n'est absoluement pas le cas.
> 
> En réalité, il n'existe qu'une seule manière d'obtenir 120 (`20 + 20 + 20 + 20 + 20 + 20 = 120`), mais il existe 6 manière d'obtenir 119 (5 dé d'une valeur de 20 et un dé d'une valeur 19, c.-à-d. 6 possibilités différentes car chacun des dés peut être le 19 alors que tous les autres peuvent être le 20)), etc. Cela signifie qu'il y a 6 fois plus de chance d'obtenir 119 que d'obtenir 120. On comprend donc rapidement qu'il est compliqué pour notre cerveau d'estimer, même approximativement les probabilités d'apparition de chaque valeur. En réalité, dans notre exemple du 6d20, on a 2.97% de chance de faire une valeur supérieur à 90 (et non 25% !).
> 
> Vous pouvez jouer avec ces probabilités sur le site https://anydice.com/. Dans notre exemple, tapez `output 6d20`, puis cliquez sur `Calculate` et `At least` et lisez la ligne 90.



### Convertisseur de dés multiples équilibrés
  
Voici un petit outil pour convertir n'importe quel nombre de lancer de dé multiple en un unique lancer de d120 sans souffrir des limitations précédemment évoqués.

Un multiplicateur est utilisé quand la valeur maximale du lancer multiple de dé dépasse 120. Par exemple, dans le cas d'un 2d70 (équivalent à lancer un 7d20), la valeur maximale est 140. Hors, sur un d120 on ne peut gérer que 120 valeurs. On utilise alors la valeur de A comme multiplicateur de résultat. On peut ainsi couvrir sur un d70 des valeurs de 1 à 140 en perdant de la précison (valeur de 2 en 2 au lieu de 1 en 1). Vous pouvez toujours décider de réellement lancer deux d70 mais vous reviendrez sur les limitations expliqués plus haut.

<blockquote>
<p>
<strong><samp>OK</samp></strong>
Quelle valeur doit être convertie ?
<input type="" name="" v-model="valueA" placeholder="A" style="width: 24px;text-align: center"> d <input type="" name="" v-model="valueX" placeholder="X" style="width: 24px;text-align: center"><span v-if="customA > 0 && customX"><span v-if="diceSuite().A === customA && diceSuite().X === customX"> reste </span><span v-else> devient </span> <strong>{{ diceSuite().A }}d{{ diceSuite().X }}</strong>. Signifie qu'il faut utiliser un <span class="a dice-suite" v-on:click="goToTable">d{{ diceSuite().X }}</span> <span v-if="diceSuite().A > 1"> et multiplier la valeur obtenue par {{ diceSuite().A }}.</span><span v-else>.</span>
<span v-if="customA < 1"><em>La valeur A doit être supérieure à 0.</em></span><span v-if="isNaN(customA)"><em>La valeur A doit être un nombre.</em></span>
<span v-if="customX < 1"><em>La valeur X doit être supérieure à 0.</em></span><span v-if="isNaN(customX)"><em>La valeur X doit être un nombre.</em></span>
</p>
</blockquote>
</div>

  

### Conserver les limitations

Si vous souhaitez conserver l'_inaccessibilité des valeurs basses_ et le second la _non équiprobabilité des résultats_ avec un d120 voici la marche à suivre.

#### L'inaccessibilité des valeurs basses

- Vous pouvez simplement réellement simuler les dés d'origines autant de fois dans des lancer séparé. En d'autre terme, au lieu de lancer 1d24 pour simuler 4d6, lancez réellement 4 dé de 6 simuler avec un d120. La limitation ici est que vous aurez également la non équiprobabilité des résultats avec cette méthode.
  
- Pour ne reproduire que cette limitation sans l'autre, voici comment procéder. Imaginons que nous voulions reproduire un 4d6. La valeur de `A = 4` et la valeur de `X = 6`. Les résultats obtenables vont donc de 4 (`4 x 1`) à 24 (`4 x 6`). Le <a href="https://blog.lesieur.name/d120/#convertisseur-de-d%C3%A9s-multiples-%C3%A9quilibr%C3%A9s">convertisseur de dés multiples équilibrés</a> vous indiquera alors qu'un 4d6 se simule sur un d120 avec un d24 (ou 1d24). Il vous suffit donc de retrancher la valeur de A au d24 pour simuler un d20 (ou 1d20). Après votre jet de d20, une fois votre résultat obtenue, rajoutez simplement à celui-ci la valeur de A (si le résultat est de 1, vous avez en réalité fait 4 et si le résultat est de 20, vous avez en réalité fait 24).

#### La non équiprobabilité des résultats

Pour cette partie c'est un peu plus compliqué.

- Vous pouvez simplement réellement simuler les dés d'origines autant de fois dans des lancer séparé. En d'autre terme, au lieu de lancer 1d36 pour simuler 6d6, lancez réellement 6 dé de 6 simuler avec un d120. La limitation ici est que vous aurez également l'inaccessibilité des valeurs basses avec cette méthode.
  
- Une manière plus compliqué est de répartir sur les 120 valeurs du d120 la distribution de répartition que génèrerait le lancer de plusieurs dés. Vous pouvez utilisez le site https://anydice.com/ pour vous y aider en attendant qu'un outil soit disponible sur cette page !





## d6, d10 et d12 simple en un lancer

Il peut être compliquer de manipuler la table des 12 pour rammener ces valeurs à un chiffre sur 10. On peut cependant simuler un d10 de manière extrèmement simple. On peut également, tout en restant dans un confort de calcule simple, faire de même avec un d6.

### Un d10 avec un d120

Le chiffre des unités à autant de chance de sortir pour n'importe quel lancer. C'est à dire qu'il y a une équiprobabilité que le dernier chiffre du nombre soit 1, 2, 3, 4, 5, 6, 7, 8, 9 ou 0 (c-à-d. 10). Dans ce cas, vous n'avez qu'à interpréter cette dernière valeur pour automatiquement connaitre votre valeur de d10 et ignorer les dizaines.

### Un d12 avec un d120

Similaire à la technique précédente. L'idée consiste ici à ne regarder les nombres des dizaines (et d'ignorer les unités). Vous aurez alors une équiprobabilité d'obtenir 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ou 12. Dans ce cas, vous n'avez qu'à interpréter cette première valeur pour automatiquement connaitre votre valeur de d12 et ignorer les autres unités.

### Un d6 avec un d120

Ici on utilise la même technique que pour le d12 avec une petite gymnastique mentale supplémentaire. Il vous suffit alors de considérer les nombres 2 à 2 pour représenter les 6 valeurs possibles (ou diviser la valeur par 2 et prendre le premier entier supérieur comme valeur).

Donc :

- 1 et 2 seront un 1
- 3 et 4 seront un 2,
- 5 et 6 seront un 3,
- 7 et 8 seront un 4,
- 9 et 10 seront un 5 et
- 11 et 12 seront un 6.

  
  


## d100 en deux lancers

Il est possible de simuler un d100 en deux lancer de d120. Le premier lancer représente le nombre des dizaines. Le second lancer correspond au chiffre des unités.



### Simuler un d100 avec deux d120

Pour cela simuler deux <a href="https://blog.lesieur.name/d120/#un-d10-avec-un-d120">d10</a>. Quand votre dé tombe sur une valeur comprise dans l'intervalle de la colonne de gauche, vous avez en réalité fait la valeur de la colonne du milieu pour le premier lancer et la valeur de la colonne de droite pour le second lancer.

<table>
    <tbody>
        <tr>
            <th>Si vous faites entre … et … (inclus)</th>
            <th>alors au 1er lancer le résultat est …</th>
            <th>puis au 2nd lancer le résultat est …</th>
        </tr>
        <tr>
            <td>1 - 12</td>
            <td class="to">10</td>
            <td class="to">+1</td>
        </tr>
        <tr>
            <td>13 - 24</td>
            <td class="to">20</td>
            <td class="to">+2</td>
        </tr>
        <tr>
            <td>25 - 36</td>
            <td class="to">30</td>
            <td class="to">+3</td>
        </tr>
        <tr>
            <td>37 - 48</td>
            <td class="to">40</td>
            <td class="to">+4</td>
        </tr>
        <tr>
            <td>49 - 60</td>
            <td class="to">50</td>
            <td class="to">+5</td>
        </tr>
        <tr>
            <td>61 - 72</td>
            <td class="to">60</td>
            <td class="to">+6</td>
        </tr>
        <tr>
            <td>73 - 84</td>
            <td class="to">70</td>
            <td class="to">+7</td>
        </tr>
        <tr>
            <td>85 - 96</td>
            <td class="to">80</td>
            <td class="to">+8</td>
        </tr>
        <tr>
            <td>97 - 108</td>
            <td class="to">90</td>
            <td class="to">+9</td>
        </tr>
        <tr>
            <td>109 - 120</td>
            <td class="to">0</td>
            <td class="to">+10</td>
        </tr>
    </tbody>
</table>

  
  
  

## Utiliser un d120

Jusqu'à maintenant nous avons vu comment utiliser le d120 pour en faire un autre dé afin de l'adapter aux spécificités de vos statistiques. Cependant, l'utilité première d'un d120 est tout de même de faire un lancer parfaitement équilibré en terme de hasard sur 120 valeurs. Aussi voyons comment adapter vos statistiques pour qu'elles se jouent avec un d120 ! 



### Des stats de 1 à 120

La première utilisation est celle où vous adaptez les valeurs de vos statistiques pour qu'elles aillent de 1 à 120. Si par exemple dans votre jeu préféré les statistiques des personnages vont de 1 à 100 alors convertissez-les pour aller de 1 à 120. Voici un outil de conversion ou les valeurs sont adaptées (et arrondies le cas échéant).

Pour l'exemple avec des statistiques allant jusqu'à 100, il faut remplir le champ « Statistiques sur » avec __100__. Puis si, par exemple, vos réussites critiques vont jusqu'à 5, alors il faut remplir le champ « Si la valeur est de » avec __5__. Vous obtenez la nouvelle valeur de réussites critique sur 120 sur la ligne « elle devient ».

<div class="use-120">
    <table>
        <tr>
            <td>Statistiques sur <input type="" name="" v-model="base"></td>
            <td>converties sur <strong>{{ d120 }}</strong></td>
        </tr>
        <tr v-if="(base && base <= d120) && (base && base > 0)">
            <td>Si la valeur est de <input type="" name="" v-model="custom"></td>
            <td><span v-if="(custom && custom > 0)">elle devient <strong>{{ roundCustom }}</strong></span></td>
        </tr>
    </table>
    <p>
        <span v-if="(base && base > d120) || (base && base < 1)"><em>La valeur à convertir doit être supérieur à 0 et inférieure ou égale à {{ d120 }}.</em></span>
        <span v-if="isNaN(base)"><em>La valeur à convertir doit être un nombre.</em></span>
        <span v-if="(custom && custom < 1)"><em>La valeur à convertir doit être supérieur à 0.</em></span>
        <span v-if="isNaN(custom)"><em>La valeur à convertir doit être un nombre.</em></span>
    </p>
</div>



### Des stats de 1 à 100

Vous pourriez trouver que faire vos calcules sur des divisions par 120 est plutôt compliquée où du moins, pas aussi simple que de les faire sur 100. C'est pourquoi il est également possible d'utiliser son d120 en tant que d100 en un seul lancer (au détriment de l'équiprobabilité des résultats) et de se servir des valeurs restantes pour faire des actions spéciales (voir <a href="https://blog.lesieur.name/d120/#actions-supplémentaires">Actions supplémentaires</a>).

Pour l'exemple avec des statistiques allant jusqu'à 10, il faut remplir le champ « Statistiques sur » avec __10__. Puis si votre statistique de _Force_ est de 7, alors il faut remplir le champ « Si la valeur est de » avec __7__. Vous obtenez la nouvelle valeur sur la ligne « elle devient ».

<div class="use-100">
    <table>
        <tr>
            <td>Statistiques sur <input type="" name="" v-model="base"></td>
            <td>converties sur <strong>{{ 100 }}</strong></td>
        </tr>
        <tr v-if="(base && base <= 100) && (base && base > 0)">
            <td>Si la valeur est de <input type="" name="" v-model="custom"></td>
            <td><span v-if="(custom && custom > 0)">elle devient <strong>{{ roundCustom }}</strong></span></td>
        </tr>
    </table>
    <p>
        <span v-if="(base && base > 100) || (base && base < 1)"><em>La valeur à convertir doit être supérieur à 0 et inférieure ou égale à {{ 100 }}.</em></span>
        <span v-if="isNaN(base)"><em>La valeur à convertir doit être un nombre.</em></span>
        <span v-if="(custom && custom < 1)"><em>La valeur à convertir doit être supérieur à 0.</em></span>
        <span v-if="isNaN(custom)"><em>La valeur à convertir doit être un nombre.</em></span>
    </p>
</div>

#### Actions supplémentaires

Voici quelques idées d'utilisations.

##### Actions critiques

On peut introduire des plages de nombre dédiées aux actions critiques.  

- Si votre lancer est entre 1 et 100, alors vous aurez fait la valeur indiquée sans jamais qu'il ne soit possible que cette valeur soit une réussite ou un échec critique.
- Si votre lancer est entre 101 et 110, alors vous aurez fait entre 91 et 100 mais en version échec (ou inversement) critique (à vous d'appliquer ce que cela implique).
- Si votre lancer est entre 111 et 120, alors vous aurez fait entre 1 et 10 mais en version réussite (ou inversement) critique (à vous d'appliquer ce que cela implique).

##### Bouclier

Imaginons une valeur de bouclier de 4 sur un ennemi. Tant qu'il a son bouclier, il faut faire moins de 40 pour le toucher. Dès qu'il n'a plus de bouclier, il faut faire moins de 80 par exemple. Les valeurs de 1 à 100 sont des valeurs normales. Les valeurs de 101 à 110 brise 1 bouclier et celle de 111 à 120 en brise 2 (par exemple). Dans ce cas, la valeur des unités multipliées par 10 correspond à la valeur initiale sur 100 et on ajoute +5 si le chiffre des dizaines est un 0.

Exemple : faire 103, signifie que vous retirez 1 bouclier et que vous avez fait 35 (3x10 + 5). Faire 112 signifie que vous retirez par exemple 2 boucliers et que vous faites 20 (2x10 + 0).

##### Modificateur

Le chiffre des unités peut être utilisé pour obtenir la valeur réel entre 1 et 10 tandis que les 12 dizaines permettent d'appliquer des modificateurs.

- Modificateur complet : ajoute (ou retire si malus) jusqu'à 12 au résultat des unités.
- Modificateur moitié : ajoute (ou retire si malus) jusqu'à 6 au résultat des unités. Il faut prendre l'écart entre la valeur obtenue et 6 pour les nombres égaux ou inférieur à 6 OU prendre l'écart entre 7 et la valeur obtenue pour les nombres égaux ou supérieures à 7.
- Modificateur tier : etc…

##### Choix de résultat

On peut utiliser par exemple le chiffre des unités et celui des dizaines comme deux valeurs séparé. Ainsi le résultat 95 donnera 9 et 5. Dans une situation de bonus, on peu imaginer que le joueur fait 9. Dans une situation de malus, on peut imaginer que le joueur fait 5. On peut également utiliser l'écart entre les nombres comme valeur réel et décider ici que le résultat est 4, etc.





## Acheter un d120 parfaitement équilibré

Après tout cela, vous vous demandez peut-être où vous procurrez un tel dé ?

Vous pourrez l'obtenir sur [la boutique en ligne](https://www.mathartfun.com/DiceLabDice.html) de [The Dice Lab](http://thedicelab.com/). Il vous est proposer de les acheter à l'unité où par lot de 5.
</div>
              
            
!

CSS

              
                .article table, .article tr, .article th, .article td {
    border: 1px solid #e0e0e0;
    border-collapse: collapse;
    border-radius: .2857rem;
}
.article table {
    width: 100%;
}
.article .h3 {
    margin-top: 24px;
}
.article th {
    font-weight: normal;
}
.article td, .article th {
    padding: 4px 8px;
}
.article .to {
    text-align: center;
    position: relative;
}
.article .to small.plus {
    display: none;
    position: absolute;
    top: 0;
    left: 100%;
    width: 320px;
}
.article .to.info {
    cursor: help;
}
.article .dice-suite {
    cursor: pointer;
    font-weight: bold;
}
.article .to:hover small.plus {
    padding: 8px;
    text-align: left;
    background-color: #FFF;
    display: block;
    position: absolute;
    top: -1px;
    left: auto;
    right: 100%;
    border-radius: .2857rem;
    border: 1px solid #e0e0e0;
    box-shadow: 0 0 10px 2px #e0e0e0
}
.article .a {
  color: #48739e;
}
.article .a:hover {
  color: #c00;
}
              
            
!

JS

              
                    var d120 = 120;

    new Vue({
        el: ".standards",
        data: {
            d120: d120
        },
        methods: {
            isPure: function (value) {
                return this.d120 / value === Math.floor(this.d120 / value);
            },
            diceList: function() {
                var createD = [];

                for (var i = 0; i < this.d120 - 1; i++) {
                    obj = {}
                    obj.value = i + 1;
                    obj.pure = false;

                    if (this.isPure(i + 1)) {
                        obj.pure = true;
                    }

                    if (obj.pure) {
                        createD.push(obj);
                    }
                }

                return createD;
            },
            tableList: function(d) {
                var createD = [],
                    obj,
                    base,
                    temp = 0;

                for (var i = 1; i <= d; i++) {
                    base = ((this.d120) * i) / d;
                    obj = {}
                    obj.to = i;
                    obj.fromLower = temp;
                    obj.fromUpper = base;

                    obj.fromLowerDisplay = Math.floor(obj.fromLower) + 1;
                    obj.fromUpperDisplay = Math.floor(obj.fromUpper);

                    createD.push(obj);

                    temp = obj.fromUpper;
                }

                return createD;
            }
        }
    });

    new Vue({
        el: ".custom",
        data: {
            d120: d120,
            custom: '',
            customFilter: '',
            valueA: '',
            valueX: '',
            multiplicator: 1,
        },
        computed: {
            customInt: function () {
                return parseInt(this.custom, 10);
            },
            multiplicatorInt: function () {
                return parseInt(this.multiplicator, 10);
            },
            customFilterInt: function () {
                return parseInt(this.customFilter, 10);
            },
            customA: function () {
                return parseInt(this.valueA, 10);
            },
            customX: function () {
                return parseInt(this.valueX, 10);
            }
        },
        methods: {
            diceSuite: function () {
                var vm = this,
                    max = this.customA * this.customX,
                    listD120 = [];

                function addDice(max) {
                    var limit = max / d120,
                        number,
                        isTransformed = true;

                    if (limit > 1) {
                        number = Math.ceil(limit);
                        if (max / number === Math.floor(max / number)) {                        
                            return {
                                A: number,
                                X: max / number
                            };
                        } else {
                            return {
                                A: vm.customA,
                                X: vm.customX
                            };
                        }
                    } else {
                        return {
                            A: 1,
                            X: max
                        };
                    }
                }

                if (this.customA > 0 && this.customX) {
                    return addDice(this.customA * this.customX);
                }

                return "";

            },
            goToTable: function () {
                this.custom = this.diceSuite().X;
                this.multiplicator = this.diceSuite().A;
                this.customFilter = "";
                location.href = "https://blog.lesieur.name/d120/#créer-un-dé-personnalisé-avec-un-d120";
            },
            isPure: function (value) {
                return this.d120 / value === Math.floor(this.d120 / value);
            },
            tableList: function(d) {
                var vm = this,
                    createD = [],
                    offset = this.d120 / this.custom,
                    offsets = [],
                    indice = 0,
                    delta = this.isPure(this.customInt) ? 0 : 0.55555555555555,
                    to = 0,
                    list = "";

                for (var i = 0; i < this.custom; i++) {
                    offsets[i] = (((i + 1) * this.d120) / this.custom) + delta;
                }

                for (var i = 0; i < this.d120; i++) {
                    if (i + 2 <= offsets[indice]) {
                        to = indice + 1;
                        toPlus = undefined;
                        list = ""
                    } else {
                        to = parseInt(indice + 1, 10);
                        toPlus = parseInt(indice + 1 !== this.customInt ? indice + 2 : 1, 10);
                        list = ((offsets[indice] + "").split('.')[1] || '').split('').join('-');
                        indice++;
                    }
                    createD.push({ from: i + 1, to: to, toPlus: toPlus, list: list });
                }

                if (this.customFilterInt > 0 && this.customFilterInt <= this.d120) {
                    return createD.filter(function (a) {
                        return a.from === vm.customFilterInt;
                    });
                } else {
                    return createD;
                }

            }
        }
    });

    new Vue({
        el: '.use-120',
        data: {
            d120: d120,
            base: 100,
            custom: 5
        },
        computed: {
            roundCustom: function () {
                return Math.round((this.custom * this.d120) / this.base)
            }
        } 
    });

    new Vue({
        el: '.use-100',
        data: {
            base: 10,
            custom: 7
        },
        computed: {
            roundCustom: function () {
                return Math.round((this.custom * 100) / this.base)
            }
        } 
    });

/*var d120 = 120;
var dX = 7;
var offset = d120 / dX;
var offsets = [];
var indice = 0;
var input = [];
var output = [];
var delta = 0.55555555555555;
var result = 0;

for (var i = 0; i < dX; i++) {
    offsets[i] = (((i + 1) * d120) / dX) + delta;
}
console.log(offsets);

console.log(1, offsets[0] - delta, '=', offsets[0], ' - ', delta);
for (var k = 0; k < offsets.length - 1; k++) {
    console.log(k + 2, offsets[k + 1] - offsets[k], '=', offsets[k + 1], ' - ', offsets[k]);
}

for (var i = 0; i < d120; i++) {
    if (i + 2 < offsets[indice]) {
        result = indice + 1;
    } else {
        result = parseInt(indice + 1, 10) + " ou " + parseInt((indice + 1 !== dX) ? indice + 2 : 1, 10) + " [" + ((offsets[indice] + "").split('.')[1] || '').split('').join('-') + "]";
        indice++;
    }
    console.log(i + 1, result);
}*/
              
            
!
999px

Console