Athemis/ds4
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Make tests and implementation interact.

Browse source
This commit is contained in:
Oliver Rümpelein 2020-12-30 21:27:41 +01:00
parent 7089178a0d
commit e0b65ca061
7 changed files with 163 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

76
src/module/rolls/ds4rolls.ts
View file

@ -1,4 +1,4 @@
export function roll(testValue: number, rollOptions: RollOptions = new RollOptions()): Promise<RollResult> {
export function ds4test(testValue: number, rollOptions: RollOptions = new RollOptions()): RollResult {
const finalRollValue = testValue;
if (finalRollValue <= 20) {
return rollCheckSingleDie(finalRollValue, rollOptions);
@ -7,26 +7,45 @@ export function roll(testValue: number, rollOptions: RollOptions = new RollOptio
}
}
async function rollCheckSingleDie(testValue: number, rollOptions: RollOptions): Promise<RollResult> {
const roll = new Roll("1d20");
roll.roll();
export class DS4RollProvider {
getNextRoll(): number {
return new Roll("1d20").roll().total;
}
const pool = new DicePool({ rolls: [roll] });
getNextRolls(amount: number): Array<number> {
return Array(amount)
.fill(0)
.map(() => this.getNextRoll());
}
}
if (roll.total <= rollOptions.maxCritSucc) {
return createRollResultPromise(testValue, RollResultStatus.CRITICAL_SUCCESS, pool);
} else if (roll.total >= rollOptions.minCritFail) {
return createRollResultPromise(0, RollResultStatus.CRITICAL_FAILURE, pool);
export interface RollProvider {
getNextRoll(): number;
getNextRolls(number): Array<number>;
}
export function rollCheckSingleDie(
testValue: number,
rollOptions: RollOptions,
provider: RollProvider = new DS4RollProvider(),
): RollResult {
const roll = provider.getNextRoll();
const dice = [roll];
if (roll <= rollOptions.maxCritSucc) {
return createRollResult(testValue, RollResultStatus.CRITICAL_SUCCESS, dice);
} else if (roll >= rollOptions.minCritFail) {
return createRollResult(0, RollResultStatus.CRITICAL_FAILURE, dice);
} else {
if (roll.total <= testValue) {
return createRollResultPromise(roll.total, RollResultStatus.SUCCESS, pool);
if (roll <= testValue) {
return createRollResult(roll, RollResultStatus.SUCCESS, dice);
} else {
return createRollResultPromise(0, RollResultStatus.FAILURE, pool);
return createRollResult(0, RollResultStatus.FAILURE, dice);
}
}
}
async function rollCheckMultipleDice(testValue: number, rollOptions: RollOptions): Promise<RollResult> {
function rollCheckMultipleDice(testValue: number, rollOptions: RollOptions): RollResult {
const finalCheck = testValue % 20;
const numberOfDice = Math.ceil(testValue / 20);
const rolls = new Array<Roll>();
@ -35,23 +54,22 @@ async function rollCheckMultipleDice(testValue: number, rollOptions: RollOptions
roll.roll();
rolls.concat(roll);
}
const pool = new DicePool({ rolls: rolls });
const dice = rolls.map((r) => r.total);
const firstResult = rolls[1].total;
const firstResult = dice[1];
// TODO: Special stuff (Gnomes!)
if (firstResult == 20) {
createRollResultPromise(0, RollResultStatus.CRITICAL_FAILURE, pool);
createRollResult(0, RollResultStatus.CRITICAL_FAILURE, dice);
}
const [otherRolls, critSuccesses] = pool.rolls
.partition((r) => r.total <= rollOptions.maxCritSucc)
.map((a) => a.sort((r1, r2) => r2.total - r1.total));
const [otherRolls, critSuccesses] = dice
.partition((r) => r <= rollOptions.maxCritSucc)
.map((a) => a.sort((r1, r2) => r2 - r1));
const sortedRolls: DicePool = new DicePool({ rolls: critSuccesses.concat(otherRolls) });
const sortedRollResults: Array<number> = critSuccesses.concat(otherRolls);
const evaluationResult = sortedRolls.rolls
.map((r) => r.total)
const evaluationResult = sortedRollResults
.map((value, index) => {
if (index == numberOfDice - 1) {
if (value == 1) {
@ -69,15 +87,11 @@ async function rollCheckMultipleDice(testValue: number, rollOptions: RollOptions
})
.reduce((a, b) => a + b);
return createRollResultPromise(evaluationResult, RollResultStatus.SUCCESS, sortedRolls);
return createRollResult(evaluationResult, RollResultStatus.SUCCESS, sortedRollResults);
}
function createRollResultPromise(
totalValue: number,
rollResult: RollResultStatus,
dicePool: DicePool,
): Promise<RollResult> {
return new Promise((resolve) => resolve(new RollResult(totalValue, RollResultStatus.SUCCESS, dicePool)));
function createRollResult(totalValue: number, rollResult: RollResultStatus, dice: Array<number>): RollResult {
return new RollResult(totalValue, RollResultStatus.SUCCESS, dice);
}
export class RollOptions {
@ -85,10 +99,10 @@ export class RollOptions {
}
export class RollResult {
constructor(public value: number, public status: RollResultStatus, public dice: DicePool) {}
constructor(public value: number, public status: RollResultStatus, public dice: Array<number>) {}
}
enum RollResultStatus {
export enum RollResultStatus {
FAILURE,
SUCCESS,
CRITICAL_FAILURE,