118 lines
4.9 KiB
TypeScript
118 lines
4.9 KiB
TypeScript
import { DefaultRollOptions, RollOptions, RollResult, RollResultStatus } from "./roll-data";
|
|
import { DS4RollProvider } from "./roll-provider";
|
|
import { calculateRollResult, isDiceSwapNecessary, isSlayingDiceRepetition, separateCriticalHits } from "./roll-utils";
|
|
|
|
/**
|
|
* Performs a roll against a check target number, e.g. for usage in battle, but not for herbs.
|
|
* @param {number} checkTargetValue the final CTN, including all static modifiers.
|
|
* @param {Partial<RollOptions>} rollOptions optional, final option override that affect the checks outcome, e.g. different values for crits or whether slaying dice are used.
|
|
* @param {Array<number>} dice optional, pass already thrown dice that are used instead of rolling new ones.
|
|
*/
|
|
export function ds4roll(
|
|
checkTargetValue: number,
|
|
rollOptions: Partial<RollOptions> = {},
|
|
dice: Array<number> = null,
|
|
): RollResult {
|
|
if (checkTargetValue <= 20) {
|
|
return rollCheckSingleDie(checkTargetValue, rollOptions, dice);
|
|
} else {
|
|
return rollCheckMultipleDice(checkTargetValue, rollOptions, dice);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Performs a roll against a single die (CTN less than or equal 20).
|
|
*
|
|
* @internal
|
|
* This is not intended for direct usage. Use
|
|
* {@link ds4roll | the function that is not bound to an amount of Dice} instead.
|
|
*
|
|
* @param {number} checkTargetValue - The target value to check against.
|
|
* @param {RollOptions} rollOptions - Options that affect the checks outcome, e.g. different values for crits or whether slaying dice are used.
|
|
* @param {Array<number>} dice optional, pass already thrown dice that are used instead of rolling new ones.
|
|
*
|
|
* @returns {RollResult} An object containing detailed information on the roll result.
|
|
*/
|
|
export function rollCheckSingleDie(
|
|
checkTargetValue: number,
|
|
rollOptions: Partial<RollOptions>,
|
|
dice: Array<number> = null,
|
|
): RollResult {
|
|
const usedOptions = new DefaultRollOptions().mergeWith(rollOptions);
|
|
|
|
if (dice?.length != 1) {
|
|
dice = [new DS4RollProvider().getNextRoll()];
|
|
}
|
|
const usedDice = dice;
|
|
const rolledDie = usedDice[0];
|
|
|
|
if (rolledDie <= usedOptions.maxCritSuccess) {
|
|
return new RollResult(checkTargetValue, RollResultStatus.CRITICAL_SUCCESS, usedDice, true);
|
|
} else if (rolledDie >= usedOptions.minCritFailure && !isSlayingDiceRepetition(usedOptions)) {
|
|
return new RollResult(0, RollResultStatus.CRITICAL_FAILURE, usedDice, true);
|
|
} else {
|
|
if (rolledDie <= checkTargetValue) {
|
|
return new RollResult(rolledDie, RollResultStatus.SUCCESS, usedDice, true);
|
|
} else {
|
|
return new RollResult(0, RollResultStatus.FAILURE, usedDice, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Performs a roll against a multitude of die (CTN greater than 20).
|
|
*
|
|
* @internal
|
|
* This is not intended for direct usage. Use
|
|
* {@link ds4roll | the function that is not bound to an amount of Dice} instead.
|
|
*
|
|
* @param {number} targetValue- - The target value to check against.
|
|
* @param {RollOptions} rollOptions - Options that affect the checks outcome, e.g. different values for crits or whether slaying dice are used.
|
|
* @param {Array<number>} dice - Optional array of dice values to consider instead of rolling new ones.
|
|
*
|
|
* @returns {RollResult} An object containing detailed information on the roll result.
|
|
*/
|
|
export function rollCheckMultipleDice(
|
|
targetValue: number,
|
|
rollOptions: Partial<RollOptions>,
|
|
dice: Array<number> = null,
|
|
): RollResult {
|
|
const usedOptions = new DefaultRollOptions().mergeWith(rollOptions);
|
|
const remainderTargetValue = targetValue % 20;
|
|
const numberOfDice = Math.ceil(targetValue / 20);
|
|
|
|
if (!dice || dice.length != numberOfDice) {
|
|
dice = new DS4RollProvider().getNextRolls(numberOfDice);
|
|
}
|
|
const usedDice = dice;
|
|
|
|
const firstResult = usedDice[0];
|
|
const slayingDiceRepetition = isSlayingDiceRepetition(usedOptions);
|
|
|
|
// Slaying Dice require a different handling.
|
|
if (firstResult >= usedOptions.minCritFailure && !slayingDiceRepetition) {
|
|
return new RollResult(0, RollResultStatus.CRITICAL_FAILURE, usedDice, true);
|
|
}
|
|
|
|
const [critSuccesses, otherRolls] = separateCriticalHits(usedDice, usedOptions);
|
|
|
|
const swapLastWithCrit: boolean = isDiceSwapNecessary([critSuccesses, otherRolls], remainderTargetValue);
|
|
|
|
let sortedRollResults: Array<number>;
|
|
|
|
if (swapLastWithCrit) {
|
|
const diceToMove = critSuccesses[0];
|
|
const remainingSuccesses = critSuccesses.slice(1);
|
|
sortedRollResults = remainingSuccesses.concat(otherRolls).concat([diceToMove]);
|
|
} else {
|
|
sortedRollResults = critSuccesses.concat(otherRolls);
|
|
}
|
|
|
|
const evaluationResult = calculateRollResult(sortedRollResults, remainderTargetValue, usedOptions);
|
|
|
|
if (firstResult <= usedOptions.maxCritSuccess) {
|
|
return new RollResult(evaluationResult, RollResultStatus.CRITICAL_SUCCESS, usedDice, true);
|
|
} else {
|
|
return new RollResult(evaluationResult, RollResultStatus.SUCCESS, usedDice, true);
|
|
}
|
|
}
|