@dicelette/core 1.22.2 → 1.23.0

package/dist/index.mjs

@@ -1,17 +1,47 @@
 // src/dice.ts
 import { DiceRoller, NumberGenerator } from "@dice-roller/rpg-dice-roller";
 import { evaluate } from "mathjs";
-function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCrypto) {
-  if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))[><=!]+\d+\}?)|\{(.*)([><=!]+).*\}/))
+function isTrivialComparison(maxValue, minValue, compare) {
+  const canSucceed = canComparisonSucceed(maxValue, compare, minValue);
+  const canFail = canComparisonFail(maxValue, compare, minValue);
+  return !canSucceed || !canFail;
+}
+function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
+  switch (compare.sign) {
+    case ">":
+      return minRollValue <= compare.value;
+    // failure if roll <= value
+    case ">=":
+      return minRollValue < compare.value;
+    // failure if roll < value
+    case "<":
+      return maxRollValue >= compare.value;
+    // failure if roll >= value
+    case "<=":
+      return maxRollValue > compare.value;
+    // failure if roll > value
+    case "=":
+    case "==":
+      return minRollValue !== compare.value || maxRollValue !== compare.value;
+    // can differ
+    case "!=":
+      return minRollValue <= compare.value && compare.value <= maxRollValue;
+    // equality possible
+    default:
+      return true;
+  }
+}
+function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCrypto, pity) {
+  if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))([><=]|!=)+\d+\}?)|\{(.*)(([><=]|!=)+).*\}/))
     return { dice, compare: void 0 };
   dice = dice.replace(SIGN_REGEX_SPACE, "");
   let compare;
-  const calc = compareRegex[1];
+  const calc = compareRegex[2];
   const sign = calc.match(/[+-/*^]/)?.[0];
   const compareSign = compareRegex[0].match(SIGN_REGEX)?.[0];
   if (sign) {
     const toCalc = calc.replace(SIGN_REGEX, "").replace(/\s/g, "").replace(/;(.*)/, "");
-    const rCompare = rollCompare(toCalc, engine);
+    const rCompare = rollCompare(toCalc, engine, pity);
     const total = evaluate(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
@@ -21,7 +51,7 @@ function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCry
       rollValue: rCompare.diceResult
     };
   } else {
-    const rcompare = rollCompare(calc, engine);
+    const rcompare = rollCompare(calc, engine, pity);
     compare = {
       sign: compareSign,
       value: rcompare.value,
@@ -31,11 +61,19 @@ function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCry
   }
   return { dice, compare };
 }
-function rollCompare(value, engine = NumberGenerator.engines.nodeCrypto) {
+function rollCompare(value, engine = NumberGenerator.engines.nodeCrypto, pity) {
   if (isNumber(value)) return { value: Number.parseInt(value, 10) };
-  const rollComp = roll(value, engine);
-  if (!rollComp?.total)
-    return { value: evaluate(value), diceResult: value };
+  if (!value || typeof value === "string" && value.trim() === "") {
+    return { value: 0, diceResult: value };
+  }
+  const rollComp = roll(value, engine, pity);
+  if (!rollComp?.total) {
+    try {
+      return { value: evaluate(value), diceResult: value };
+    } catch (error) {
+      return { value: 0, diceResult: value };
+    }
+  }
   return {
     dice: value,
     value: rollComp.total,
@@ -74,20 +112,20 @@ function getModifier(dice) {
   }
   return modificator;
 }
-function roll(dice, engine = NumberGenerator.engines.nodeCrypto) {
+function roll(dice, engine = NumberGenerator.engines.nodeCrypto, pity) {
   dice = standardizeDice(replaceFormulaInDice(dice)).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
   if (!dice.includes("d")) return void 0;
   dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let compare;
   if (dice.includes(";")) return sharedRolls(dice, engine);
+  dice = fixParenthesis(dice);
+  const modificator = getModifier(dice);
   if (compareRegex) {
-    const compareResult = getCompare(dice, compareRegex, engine);
+    const compareResult = getCompare(dice, compareRegex, engine, pity);
     dice = compareResult.dice;
     compare = compareResult.compare;
   }
-  dice = fixParenthesis(dice);
-  const modificator = getModifier(dice);
   if (dice.match(/\d+?#(.*)/)) {
     const diceArray = dice.split("#");
     const numberOfDice = Number.parseInt(diceArray[0], 10);
@@ -115,22 +153,85 @@ function roll(dice, engine = NumberGenerator.engines.nodeCrypto) {
   const roller = new DiceRoller();
   NumberGenerator.generator.engine = engine;
   const diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
+  let diceRoll;
   try {
-    roller.roll(diceWithoutComment);
+    diceRoll = roller.roll(diceWithoutComment);
   } catch (error) {
     throw new DiceTypeError(diceWithoutComment, "roll", error);
   }
+  if (compare && diceRoll) {
+    const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
+    const maxDiceValue = currentRoll.maxTotal;
+    const minDiceValue = currentRoll.minTotal;
+    const trivial = isTrivialComparison(maxDiceValue, minDiceValue, compare);
+    compare.trivial = trivial ? true : void 0;
+  }
   const commentMatch = dice.match(COMMENT_REGEX);
   const comment = commentMatch ? commentMatch[2] : void 0;
+  let rerollCount = 0;
+  let res;
+  if (pity && compare) {
+    const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
+    const maxPossible = currentRoll ? currentRoll.maxTotal : null;
+    const isComparisonPossible = maxPossible === null || canComparisonSucceed(maxPossible, compare);
+    if (isComparisonPossible) {
+      let isFail = evaluate(`${roller.total}${compare.sign}${compare.value}`);
+      if (!isFail) {
+        const maxReroll = 100;
+        while (!isFail && rerollCount < maxReroll) {
+          try {
+            res = roll(diceWithoutComment, engine, false);
+          } catch (error) {
+            throw new DiceTypeError(diceWithoutComment, "roll", error);
+          }
+          rerollCount++;
+          if (res && res.total !== void 0)
+            isFail = evaluate(`${res.total}${compare.sign}${compare.value}`);
+        }
+        if (res) {
+          return {
+            ...res,
+            dice,
+            comment,
+            compare,
+            modifier: modificator,
+            pityLogs: rerollCount
+          };
+        }
+      }
+    } else ;
+  }
   return {
     dice,
     result: roller.output,
     comment,
     compare: compare ? compare : void 0,
     modifier: modificator,
-    total: roller.total
+    total: roller.total,
+    pityLogs: rerollCount > 0 ? rerollCount : void 0
   };
 }
+function canComparisonSucceed(maxRollValue, compare, minRollValue) {
+  switch (compare.sign) {
+    case ">":
+      return maxRollValue > compare.value;
+    case ">=":
+      return maxRollValue >= compare.value;
+    case "<":
+      return compare.value > (minRollValue ?? 1);
+    // Au moins minRollValue possible
+    case "<=":
+      return compare.value >= (minRollValue ?? 1);
+    // Au moins minRollValue possible
+    case "=":
+    case "==":
+      return maxRollValue >= compare.value && compare.value >= (minRollValue ?? 1);
+    case "!=":
+      return maxRollValue !== compare.value || (minRollValue ?? 1) !== compare.value;
+    default:
+      return true;
+  }
+}
 function fixParenthesis(dice) {
   const parenthesisRegex = /d\((\d+)\)/g;
   return dice.replaceAll(parenthesisRegex, (_match, p1) => `d${p1}`);
@@ -157,7 +258,7 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = NumberGenerator.engines.nodeCrypto) {
+function replaceInFormula(element, diceResult, compareResult, res, engine = NumberGenerator.engines.nodeCrypto, pity) {
   const { formule, diceAll } = replaceText(
     element,
     diceResult.total ?? 0,
@@ -170,13 +271,13 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = Numb
     evaluateRoll = evaluate(compareResult.dice);
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
   } catch (error) {
-    const evaluateRoll2 = roll(compareResult.dice, engine);
+    const evaluateRoll2 = roll(compareResult.dice, engine, pity);
     if (evaluateRoll2)
       return `${validSign} ${diceAll}: ${evaluateRoll2.result.split(":").splice(1).join(":")}`;
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
   }
 }
-function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = NumberGenerator.engines.nodeCrypto) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = NumberGenerator.engines.nodeCrypto, pity) {
   let results = "";
   const compareResult = getCompare(toRoll, compareRegex, engine);
   const toCompare = `${compareResult.dice}${compareResult.compare?.sign}${compareResult.compare?.value}`;
@@ -184,10 +285,10 @@ function compareSignFormule(toRoll, compareRegex, element, diceResult, engine =
   try {
     res = evaluate(toCompare);
   } catch (error) {
-    res = roll(toCompare, engine);
+    res = roll(toCompare, engine, pity);
   }
   if (typeof res === "boolean") {
-    results = replaceInFormula(element, diceResult, compareResult, res, engine);
+    results = replaceInFormula(element, diceResult, compareResult, res, engine, pity);
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
@@ -211,17 +312,18 @@ function replaceText(element, total, dice) {
 function formatComment(dice) {
   const commentsRegex = /\[(?<comments>.*?)\]/;
   const commentsMatch = commentsRegex.exec(dice);
-  const optionalComments = OPTIONAL_COMMENT.exec(dice);
   const comments = commentsMatch?.groups?.comments ? `${commentsMatch.groups.comments}` : "";
+  const diceWithoutBrackets = dice.replace(commentsRegex, "");
+  const optionalCommentsRegex = /\s+(#|\/\/)(?<comment>.*)/;
+  const optionalComments = optionalCommentsRegex.exec(diceWithoutBrackets);
   const optional = optionalComments?.groups?.comment ? `${optionalComments.groups.comment.trim()}` : "";
   let finalComment = "";
-  if (comments && optional)
-    finalComment = `__${commentsMatch?.groups?.comments} ${optionalComments?.groups?.comment.trim()}__ \u2014 `;
+  if (comments && optional) finalComment = `__${comments} ${optional}__ \u2014 `;
   else if (comments) finalComment = `__${comments}__ \u2014 `;
   else if (optional) finalComment = `__${optional}__ \u2014 `;
   return finalComment;
 }
-function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto) {
+function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto, pity) {
   if (dice.match(/\d+?#(.*?)/))
     throw new DiceTypeError(
       dice,
@@ -232,8 +334,11 @@ function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto) {
   const mainComment = /\s+#(?<comment>.*)/.exec(dice)?.groups?.comment?.trimEnd() ?? void 0;
   const split = dice.split(";");
   let diceMain = fixParenthesis(split[0]);
-  const toHideRegex = /(?<!\[[^\]]*)\((?<dice>[^)]+)\)/;
-  const toHide = toHideRegex.exec(diceMain)?.groups;
+  const commentsRegex = /\[(?<comments>.*?)\]/gi;
+  const comments = formatComment(diceMain);
+  const diceMainWithoutComments = diceMain.replace(commentsRegex, "").trim();
+  const toHideRegex = /\((?<dice>[^)]+)\)/;
+  const toHide = toHideRegex.exec(diceMainWithoutComments)?.groups;
   let hidden = false;
   if (toHide?.dice) {
     diceMain = toHide.dice;
@@ -241,14 +346,13 @@ function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto) {
   } else if (toHide) {
     diceMain = "1d1";
     hidden = true;
+  } else {
+    diceMain = diceMainWithoutComments;
   }
-  const commentsRegex = /\[(?<comments>.*?)\]/gi;
-  const comments = formatComment(diceMain);
-  diceMain = diceMain.replace(commentsRegex, "").trim();
-  let diceResult = roll(diceMain, engine);
+  let diceResult = roll(diceMain, engine, pity);
   if (!diceResult || !diceResult.total) {
     if (hidden) {
-      diceResult = roll(fixParenthesis(split[0]));
+      diceResult = roll(fixParenthesis(split[0]), engine, pity);
       hidden = false;
     } else return void 0;
   }
@@ -283,7 +387,7 @@ function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto) {
         results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
         total += Number.parseInt(evaluated, 10);
       } catch (error) {
-        const evaluated = roll(toRoll, engine);
+        const evaluated = roll(toRoll, engine, pity);
         if (evaluated)
           results.push(
             `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
@@ -372,10 +476,10 @@ var NoStatisticsError = class extends Error {
 
 // src/interfaces/constant.ts
 var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/gi;
-var SIGN_REGEX = /[><=!]+/;
-var SIGN_REGEX_SPACE = /[><=!]+(\S+)/;
+var SIGN_REGEX = /==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=/;
+var SIGN_REGEX_SPACE = /(==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=)(\S+)/;
 var SYMBOL_DICE = "&";
-var DETECT_CRITICAL = /\{\*?c[fs]:[<>=!]+(.+?)}/gim;
+var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
 var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
 
 // src/interfaces/zod.ts
@@ -595,7 +699,7 @@ import { evaluate as evaluate3 } from "mathjs";
 import { Random as Random2 } from "random-js";
 import "uniformize";
 import { NumberGenerator as NumberGenerator3 } from "@dice-roller/rpg-dice-roller";
-function evalStatsDice(testDice, allStats, engine = NumberGenerator3.engines.nodeCrypto) {
+function evalStatsDice(testDice, allStats, engine = NumberGenerator3.engines.nodeCrypto, pity) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
     const names = Object.keys(allStats);
@@ -608,7 +712,7 @@ function evalStatsDice(testDice, allStats, engine = NumberGenerator3.engines.nod
     }
   }
   try {
-    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine))
+    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine, pity))
       throw new DiceTypeError(dice, "evalStatsDice", "no roll result");
     return testDice;
   } catch (error) {