Pen Settings

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

You're using npm packages, so we've auto-selected Babel for you here, which we require to process imports and make it all work. If you need to use a different JavaScript preprocessor, remove the packages in the npm tab.

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

Use npm Packages

We can make npm packages available for you to use in your JavaScript. We use webpack to prepare them and make them available to import. We'll also process your JavaScript with Babel.

⚠️ This feature can only be used by logged in users.

Code Indentation

     

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.

HTML Settings

Here you can Sed posuere consectetur est at lobortis. Donec ullamcorper nulla non metus auctor fringilla. Maecenas sed diam eget risus varius blandit sit amet non magna. Donec id elit non mi porta gravida at eget metus. Praesent commodo cursus magna, vel scelerisque nisl consectetur et.

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

C'est pourquoi je souhaite vous présenter le seul dé capable de remplacer des dés comme les d4, d6, d8, d10, d12 et 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é le dé ultime,
- comment le d120 peut être à lui seul utiliser pour faire office de d1 jusqu'au d119 en passant bien entendu par le symbolique d100 des jeux de rôle,
- les tables de correspondance associées des dés multiples de 120 et 
- les outils pour aligner votre d120 sur vos statistiques ou aligner vos statistiques sur votre d120.

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

> Si vous êtes développeur front-end et que vous cherchez des exemple d'utilisation de [Vue.js](https://vuejs.org/) à la volée (comme on utiliserait simplement jQuery), je peux vous conseiller de jeter un œil au code source de cet article derrière ce CodePen : http://codepen.io/Haeresis/pen/zBzWgQ





## 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 fait 7, 2 + 5 fait 7 et 3 + 4 fait 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

Car si on observe le dé depuis les sommets, on s'aperçoit que l'un des sommets touche les 3 plus petites faces (1, 2 et 3) et que son opposé touche les trois plus grosses faces (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 ; et donc, si on est doué, sortir des grands nombres.

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



### La solution du d120

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

<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 d'émuler 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 émuler 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.

### Créer un dé standard avec un d120

Accédez aux tables associatives ci-dessous pour créer le dé dont vous avez besoin. 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 de droite.

<ul>
    <li><a href="https://blog.lesieur.name/d120/#d1">Créer un d1 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d2">Créer un d2 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d3">Créer un d3 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d4">Créer un d4 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d5">Créer un d5 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d6">Créer un d6 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d8">Créer un d8 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d10">Créer un d10 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d12">Créer un d12 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d15">Créer un d15 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d20">Créer un d20 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d24">Créer un d24 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d30">Créer un d30 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d40">Créer un d40 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d60">Créer un d60 avec un d120</a></li>
    <li><a href="https://blog.lesieur.name/d120/#d120">Créer un d120 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">Créer 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 créer 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).



### Créer 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 créer ?
<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 supérieure à 0 et inférieure ou égale à {{ d120 }}.</em></span><span v-if="isNaN(customInt)"><em>La valeur doit être un nombre.</em></span>
</p>
</blockquote>

<div v-if="customInt && customInt <= d120 && customInt > 0">
<div class="h3" id="custom">Créer 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 d10, 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 d10 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 supérieure à 0 et inférieure ou égale à {{ 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 d10 !</span>
</td>
<td class="to"
v-if="!table.list">{{ table.to }}</td>
<td class="to info"
v-if="table.list">
{{ table.to }} ou {{ table.toPlus }} <small>[{{ table.list }}]</small>
<small class="plus">Si la valeur du d10 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>

<h2 id="convertir-vos-lancers-en-d120">Convertir vos lancers en d120</h2>
<p>Si vous faites du jeu de rôle, vous connaissez surement la notation <strong>AdX</strong>. Dans cette notation :</p>
<ul>
<li>A est le nombre de dés qu'il faut lancer (pouvant être omis s'il vaut 1, 
comme partout dans cet article),</li>
<li>X est le nombre de face pour chacun des dés.</li>
</ul>
<p>Ainsi s'il vous est demandé de faire un <strong>6d6</strong> 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 !</p>
<h3 id="convertisseur-de-d-s">Convertisseur de dés</h3>
<p>Voici un petit outil pour convertir tous les lancer en une suite de lancer de d120 avec un lien vers la table personnalisée pour chacun d'entre eux.</p>
<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> <a href="javascript: void(0);" class="dice-suite" v-on:click="goToTable">{{ diceSuite().A }}d{{ diceSuite().X }}</a>.</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>





## d100 en deux lancers

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



### Créer un d100 avec deux d120

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 d'extras critiques

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 tel quel et d'observer les résultats suivants pour un jeu de rôle.

- 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 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 critique (à vous d'appliquer ce que cela implique).

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>





## 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>
            
          
!
            
              .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
}
            
          
!
            
                  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; 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: ''
        },
        computed: {
            customInt: function () {
                return parseInt(this.custom, 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.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
🕑 One or more of the npm packages you are using needs to be built. You're the first person to ever need it! We're building it right now and your preview will start updating again when it's ready.

Console