@dicelette/core 1.0.0

package/core/dice.ts

@@ -0,0 +1,104 @@
+/* eslint-disable no-useless-escape */
+import { DiceRoller } from "@dice-roller/rpg-dice-roller";
+import { evaluate } from "mathjs";
+
+import { Compare, Modifier, Resultat, Sign } from ".";
+
+export const COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(.*)/;
+const SIGN_REGEX =/[><=!]+/;
+const SIGN_REGEX_SPACE = /[><=!]+(\S+)/;
+
+/**
+ * Parse the string provided and turn it as a readable dice for dice parser
+ * @param dice {string}
+ */
+export function roll(dice: string): Resultat | undefined{
+	//parse dice string
+	if (!dice.includes("d")) return undefined;
+	const compareRegex = dice.match(SIGN_REGEX_SPACE);
+	let compare : Compare | undefined;
+	if (compareRegex) {
+		dice = dice.replace(SIGN_REGEX_SPACE, "");
+		const calc = compareRegex[1];
+		const sign = calc.match(/[+-\/\*\^]/)?.[0];
+		const compareSign = compareRegex[0].match(SIGN_REGEX)?.[0];
+		if (sign) {
+			const toCalc = calc.replace(SIGN_REGEX, "").replace(/\s/g, "");
+			const total = evaluate(toCalc);
+			dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
+			compare = {
+				sign: compareSign as "<" | ">" | ">=" | "<=" | "=" | "!=" | "==",
+				value: total,
+			};
+		} else compare = {
+			sign: compareSign as "<" | ">" | ">=" | "<=" | "=" | "!=" | "==",
+			value: parseInt(calc, 10),
+		};
+	}
+	const modifier = dice.matchAll(/(\+|\-|%|\/|\^|\*|\*{2})(\d+)/gi);
+	let modificator : Modifier | undefined;
+	for (const mod of modifier) {
+		//calculate the modifier if multiple
+		if (modificator) {
+			const sign = modificator.sign;
+			let value = modificator.value;
+			if (sign)
+				value = calculator(sign, value, parseInt(mod[2], 10));
+			modificator = {
+				sign: mod[1] as Sign,
+				value,
+			};
+		} else {
+			modificator = {
+				sign: mod[1] as Sign,
+				value: parseInt(mod[2], 10),
+			};
+		}
+	} 
+	
+	if (dice.match(/\d+?#(.*)/)) {
+		const diceArray = dice.split("#");
+		const numberOfDice = parseInt(diceArray[0], 10);
+		const diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
+		const commentsMatch = diceArray[1].match(COMMENT_REGEX);
+		const comments = commentsMatch ? commentsMatch[2] : undefined;
+		const roller = new DiceRoller();
+		//remove comments if any
+		for (let i = 0; i < numberOfDice; i++) {
+			roller.roll(diceToRoll);
+		}
+		return {
+			dice: diceToRoll,
+			result: roller.output,
+			comment: comments,
+			compare: compare ? compare : undefined,
+			modifier: modificator,
+		};
+	}
+	const roller = new DiceRoller();
+	const diceWithoutComment = dice.replace(COMMENT_REGEX, "");
+	roller.roll(diceWithoutComment);
+	const commentMatch = dice.match(COMMENT_REGEX);
+	const comment = commentMatch ? commentMatch[2] : undefined;
+	return {
+		dice,
+		result: roller.output,
+		comment,
+		compare: compare ? compare : undefined,
+		modifier: modificator,
+	};
+}
+/**
+ * Evaluate a formula and replace "^" by "**" if any
+ * @param {Sign} sign
+ * @param {number} value 
+ * @param {number} total 
+ * @returns 
+ */
+export function calculator(sign: Sign, value: number, total: number): number {
+	if (sign === "^") sign = "**";
+	return evaluate(`${total} ${sign} ${value}`);
+}
+
+
+

package/core/index.d.ts

@@ -0,0 +1,71 @@
+export interface Resultat {
+	dice: string;
+	result: string;
+	comment?: string;
+	compare?: Compare | undefined;
+	modifier?: Modifier;
+}
+
+
+export interface Compare {
+	sign: "<" | ">" | ">=" | "<=" | "=" | "!=" | "==";
+	value: number;
+}
+
+export type Sign = "+" | "-" | "*" | "/" | "%" | "^" | "**";
+
+export interface Modifier {
+	sign?: Sign;
+	value: number;
+}
+
+export type Statistic = {
+	[name: string] : {
+		max?: number;
+		min?: number;
+		combinaison?: string;
+	}
+}
+
+/**
+ * @example
+ * diceType: 1d20
+ * comparator: {
+ * 	sign: ">="
+ * 	value: 20
+ * 	formula: +$
+ * }
+ * The dice throw will be 1d20 + statistique that must be >= 20
+ * @example
+ * diceType: 1d20
+ * comparator: {
+ * 	sign: "<="
+ * }
+ * The dice throw will be 1d20 that must be <= statistique
+ */
+export interface StatisticalTemplate {
+	/** Allow to force the user to choose a name for them characters */
+	charName?: boolean 
+	statistics?: Statistic
+	/**
+	 * A total can be set, it allows to calculate the total value of a future register member
+	 * If the sum of the value > total, the bot will send a message to the user to inform him that the total is exceeded and an error will be thrown
+	 * @note statistique that have a formula will be ignored from the total
+	 */
+	total?: number
+	/** A dice type in the notation supported by the bot */
+	diceType?: string;
+	/**
+	 * How the success/echec will be done 
+	 */
+	critical?: Critical;
+	/** Special dice for damage */
+	damage?: {
+		[name: string]: string;
+	}
+}
+
+export interface Critical {
+		success?: number,
+		failure?: number,
+}

package/core/utils.ts

@@ -0,0 +1,65 @@
+import { evaluate } from "mathjs";
+import removeAccents from "remove-accents";
+
+/**
+ * Escape regex string
+ * @param string {string}
+ */
+export function escapeRegex(string: string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+
+/**
+ * Replace the stat name by their value using stat and after evaluate any formula using `replaceFormulaInDice`
+ * @param originalDice {dice}
+ * @param stats {[name: string]: number}
+ */
+export function generateStatsDice(originalDice: string, stats?: {[name: string]: number}) {
+	let dice = originalDice;
+	if (stats && Object.keys(stats).length > 0) {
+		//damage field support adding statistic, like : 1d6 + strength
+		//check if the value contains a statistic & calculate if it's okay
+		//the dice will be converted before roll 
+		const allStats = Object.keys(stats);
+		for (const stat of allStats) {
+			const regex = new RegExp(escapeRegex(removeAccents(stat)), "gi");
+			if (dice.match(regex)) {
+				const statValue = stats[stat];
+				dice = dice.replace(regex, statValue.toString());
+			}
+		}
+	}
+	return replaceFormulaInDice(dice);
+	
+}
+
+/**
+ * Replace the {{}} in the dice string and evaluate the interior if any
+ * @param dice {string}
+ */
+export function replaceFormulaInDice(dice: string) {
+	const formula = /(?<formula>\{{2}(.+?)\}{2})/gmi;
+	const formulaMatch = formula.exec(dice);
+	if (formulaMatch?.groups?.formula) {
+		const formula = formulaMatch.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
+		try {
+			const result = evaluate(formula);
+			return cleanedDice(dice.replace(formulaMatch.groups.formula, result.toString()));
+		} catch (error) {
+			throw new Error(`[error.invalidFormula, common.space]: ${formulaMatch.groups.formula}`);
+		}
+	}
+	return cleanedDice(dice);
+}
+
+/**
+ * Replace the ++ +- -- by their proper value:
+ * - `++` = `+`
+ * - `+-` = `-`
+ * - `--` = `+`
+ * @param dice {string}
+ */
+export function cleanedDice(dice: string) {
+	return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+");
+}

package/core/verify_template.ts

@@ -0,0 +1,263 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { evaluate } from "mathjs";
+import {Random } from "random-js";
+import removeAccents from "remove-accents";
+
+import { Statistic, StatisticalTemplate } from ".";
+import { roll } from "./dice";
+import { escapeRegex, replaceFormulaInDice } from "./utils";
+
+/**
+ * Verify if the provided dice work with random value
+ * @param testDice {string}
+ * @param stats {[name: string]: number}
+ */
+export function evalStatsDice(testDice: string, stats?: {[name: string]: number}) {
+	let dice = testDice;
+	if (stats && Object.keys(stats).length > 0) {
+		const allStats = Object.keys(stats);
+		for (const stat of allStats) {
+			const regex = new RegExp(escapeRegex(removeAccents(stat)), "gi");
+			if (testDice.match(regex)) {
+				const statValue = stats[stat];
+				dice = testDice.replace(regex, statValue.toString());
+			}
+		}
+	}	
+	try {
+		if (!roll(replaceFormulaInDice(dice))) throw new Error(`[error.invalidDice.withoutDice, common.space] ${dice}`);
+		return testDice;
+	} catch (error) {
+		throw new Error(`[error.invalidDice.withoutDice, common.space]: ${testDice}\n${(error as Error).message}`);
+	}
+}
+
+/**
+ * Generate a random dice and remove the formula (+ evaluate it)
+ * Used for diceDamage only
+ * @param value {string}
+ * @param template {StatisticalTemplate}
+ * @returns 
+ */
+export function diceRandomParse(value: string, template: StatisticalTemplate) {
+	if (!template.statistics) return value;
+	value = removeAccents(value);
+	const allStats = Object.keys(template.statistics).map(stat => removeAccents(stat).toLowerCase());
+	let newDice = value;
+	for (const stat of allStats) {
+		const regex = new RegExp(escapeRegex(stat), "gi");
+		if (value.match(regex)) {
+			let max: undefined | number = undefined;
+			let min: undefined | number = undefined;
+			const stats = template.statistics?.[stat];
+			if (stats) {
+				max = template.statistics[removeAccents(stat).toLowerCase()].max;
+				min = template.statistics[removeAccents(stat).toLowerCase()].min;
+			}
+			const total = template.total || 100;
+			const randomStatValue = generateRandomStat(total, max, min);
+			newDice = value.replace(regex, randomStatValue.toString());
+		}
+	}
+	return replaceFormulaInDice(newDice);
+}
+
+/**
+ * Same as damageDice but for DiceType
+ * @param dice {string}
+ * @param template {StatisticalTemplate}
+ */
+export function diceTypeRandomParse(dice: string, template: StatisticalTemplate) {
+	if (!template.statistics) return dice;
+	const firstStatNotCombinaison = Object.keys(template.statistics).find(stat => !template.statistics?.[stat].combinaison);
+	if (!firstStatNotCombinaison) return dice;
+	const stats = template.statistics[firstStatNotCombinaison];
+	const {min, max} = stats;
+	const total = template.total || 100;
+	const randomStatValue = generateRandomStat(total, max, min);
+	return replaceFormulaInDice(dice.replace("$", randomStatValue.toString()));
+}
+
+/**
+ * Random the combinaison and evaluate it to check if everything is valid
+ * @param combinaison {[name: string]: string}
+ * @param stats {[name: string]: string|number}
+ */
+export function evalCombinaison(combinaison: {[name: string]: string}, stats: {[name: string]: string | number}) {
+	const newStats: {[name: string]: number} = {};
+	for (const [stat, combin] of Object.entries(combinaison)) {
+		//replace the stats in formula
+		let formula = removeAccents(combin);
+		for (const [statName, value] of Object.entries(stats)) {
+			const regex = new RegExp(removeAccents(statName), "gi");
+			formula = formula.replace(regex, value.toString());
+		}
+		try {
+			const result = evaluate(formula);
+			newStats[stat] = result;
+		} catch (error) {
+			throw new Error(`[error.invalidFormula, common.space]: ${stat}`);
+		}
+	}
+	return newStats;
+}
+
+/**
+ * Evaluate one selected combinaison
+ * @param combinaison {string}
+ * @param stats {[name: string]: string|number}
+ */
+export function evalOneCombinaison(combinaison: string, stats: {[name: string]: string | number}) {
+	let formula = removeAccents(combinaison);
+	for (const [statName, value] of Object.entries(stats)) {
+		const regex = new RegExp(removeAccents(statName), "gi");
+		formula = formula.replace(regex, value.toString());
+	}
+	try {
+		return evaluate(formula);
+	} catch (error) {
+		throw new Error(`[error.invalidFormula, common.space]: ${combinaison}`);
+	}
+}
+
+/**
+ * Parse the provided JSON and verify each field to check if everything could work when rolling
+ * @param {any} template 
+ * @returns {StatisticalTemplate}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function verifyTemplateValue(template: any): StatisticalTemplate {
+	const statistiqueTemplate: StatisticalTemplate = {
+		diceType: "",
+		statistics: {} as Statistic
+	};
+	if (!template.statistics) statistiqueTemplate.statistics = undefined;
+	else if (template.statistics && Object.keys(template.statistics).length > 0) {
+		for (const [key, value] of Object.entries(template.statistics)) {
+			const dataValue = value as { max?: number, min?: number, combinaison?: string };
+			if (dataValue.max && dataValue.min && dataValue.max <= dataValue.min)
+				throw new Error("[error.maxGreater]");				
+			if (dataValue.max && dataValue.max <= 0 ) dataValue.max = undefined;
+			if (dataValue.min && dataValue.min <= 0 ) dataValue.min = undefined;
+			let formula = dataValue.combinaison ? removeAccents(dataValue.combinaison).toLowerCase() : undefined;
+			formula = formula && formula.trim().length > 0 ? formula : undefined;
+			if (!statistiqueTemplate.statistics) {
+				statistiqueTemplate.statistics = {} as Statistic;
+			}
+			statistiqueTemplate.statistics[key] = {
+				max: dataValue.max,
+				min: dataValue.min,
+				combinaison: formula || undefined,
+			};
+		}
+	}
+	if (template.diceType) {
+		try {
+			statistiqueTemplate.diceType = template.diceType;
+			diceTypeRandomParse(template.diceType, statistiqueTemplate);
+		} catch (e) {
+			throw new Error((e as Error).message);
+		}
+	}
+
+	
+	if (template.critical && Object.keys(template.critical).length > 0){
+		statistiqueTemplate.critical = {
+			failure: template.critical.failure ?? undefined,
+			success: template.critical.success ?? undefined
+		};
+
+	}
+	if (template.total) {
+		if (template.total <= 0)
+			template.total = undefined;
+		statistiqueTemplate.total = template.total;
+	}
+	if (template.charName) statistiqueTemplate.charName = template.charName;
+	if (template.damage) statistiqueTemplate.damage = template.damage;
+	try {
+		testDamageRoll(statistiqueTemplate);
+		testCombinaison(statistiqueTemplate);
+	} catch (error) {
+		throw new Error((error as Error).message);
+	}
+	return statistiqueTemplate;
+}
+
+/**
+ * Test each damage roll from the template.damage
+ * @param {StatisticalTemplate} template 
+ */
+export function testDamageRoll(template: StatisticalTemplate) {
+	if (!template.damage) return;
+	if (Object.keys(template.damage).length === 0) throw new Error("[error.emptyObject]");
+	if (Object.keys(template.damage).length > 25) throw new Error("[error.tooManyDice]");
+	for (const [name, dice] of Object.entries(template.damage)) {
+		if (!dice) continue;
+		const randomDiceParsed = diceRandomParse(dice, template);
+		try {
+			roll(randomDiceParsed);
+		} catch (error) {
+			throw new Error(`[error.invalidDice, common.space] ${name}`);
+		}
+	}
+}
+
+
+
+/**
+ * Test all combinaison with generated random value
+ * @param {StatisticalTemplate} template 
+ */
+export function testCombinaison(template: StatisticalTemplate) {
+	if (!template.statistics) return;
+	const onlyCombinaisonStats = Object.fromEntries(Object.entries(template.statistics).filter(([_, value]) => value.combinaison !== undefined));
+	const allOtherStats = Object.fromEntries(Object.entries(template.statistics).filter(([_, value]) => !value.combinaison));	
+	if (Object.keys(onlyCombinaisonStats).length===0) return;
+	const allStats = Object.keys(template.statistics).filter(stat => !template.statistics![stat].combinaison);
+	if (allStats.length === 0) 
+		throw new Error("[error.noStat]");
+	const error= [];
+	for (const [stat, value] of Object.entries(onlyCombinaisonStats)) {
+		let formula = value.combinaison as string;
+		for (const [other, data] of Object.entries(allOtherStats)) {
+			const {max, min} = data;
+			const total = template.total || 100;
+			const randomStatValue = generateRandomStat(total, max, min);
+			const regex = new RegExp(other, "gi");
+			formula = formula.replace(regex, randomStatValue.toString());
+		}
+		try {
+			evaluate(formula);
+		} catch (e) {
+			error.push(stat);
+		}
+	}
+	if (error.length > 0) 
+		throw new Error(`[error.invalidFormula, common.space] ${error.join(", ")}`);
+	return;
+}
+
+/**
+ * Generate a random stat based on the template and the statistical min and max
+ * @param {number|undefined} total
+ * @param {number | undefined} max 
+ * @param {number | undefined} min 
+ * @returns 
+ */
+export function generateRandomStat(total: number | undefined = 100, max?: number, min?: number) {
+	let randomStatValue = total + 1;
+	while (randomStatValue >= total) {
+		const random = new Random();
+		if (max && min)
+			randomStatValue = random.integer(min, max);
+		else if (max)
+			randomStatValue = random.integer(0, max);
+		else if (min)
+			randomStatValue = random.integer(min, total);
+		else
+			randomStatValue = random.integer(0, total);
+	}
+	return randomStatValue;
+}
+

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+	preset: "ts-jest",
+	testEnvironment: "node",
+	verbose: true,
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@dicelette/core",
+  "version": "1.0.0",
+  "description": "Core library for the Dicelette Discord bot",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dicelette/core.git"
+  },
+  "types": "index.d.ts",
+  "keywords": [
+    "discord",
+    "roll",
+    "library",
+    "bot",
+    "typescript"
+  ],
+  "author": "Mara-Li",
+  "license": "GPL-3.0-only",
+  "dependencies": {
+    "@dice-roller/rpg-dice-roller": "^5.5.0",
+    "@lisandra-dev/eslint-config": "^1.1.4",
+    "@types/jest": "^29.5.12",
+    "eslint": "^8.57.0",
+    "mathjs": "^12.4.1",
+    "moment": "^2.30.1",
+    "random-js": "^2.1.0",
+    "remove-accents": "^0.5.0",
+    "ts-dedent": "^2.2.0"
+  },
+  "scripts": {
+    "test": "jest"
+  }
+}