ds4/src/module/rolls/check-factory.ts

// TODO: Rename to something sane.

/**
 * Provides default values for all arguments the `CheckFactory` expects.
 */
class DefaultCheckOptions implements DS4CheckFactoryOptions {
    maxCritSuccess = 1;
    minCritFailure = 20;
    useSlayingDice = false;
    rollMode: DS4RollMode = "roll";

    mergeWith(other: Partial<DS4CheckFactoryOptions>): DS4CheckFactoryOptions {
        return { ...this, ...other } as DS4CheckFactoryOptions;
    }
}

/**
 * Most basic class responsible for generating the chat formula and passing it to the chat as roll.
 */
class CheckFactory {
    constructor(
        private checkTargetValue: number,
        private gmModifier: number,
        passedOptions: Partial<DS4CheckFactoryOptions> = {},
    ) {
        this.checkOptions = new DefaultCheckOptions().mergeWith(passedOptions);
    }

    private checkOptions: DS4CheckFactoryOptions;

    async execute(): Promise<void> {
        const rollCls: typeof Roll = CONFIG.Dice.rolls[0];

        const formula = [
            "ds",
            this.createTargetValueTerm(),
            this.createCritTerm(),
            this.createSlayingDiceTerm(),
        ].filterJoin("");
        const roll = new rollCls(formula);

        const rollModeTemplate = this.checkOptions.rollMode;
        return roll.toMessage({}, { rollMode: rollModeTemplate, create: true });
    }

    // Term generators
    createTargetValueTerm(): string {
        if (this.checkTargetValue != null) {
            return "v" + this.checkTargetValue;
        } else {
            return null;
        }
    }

    createCritTerm(): string {
        const minCritRequired = this.checkOptions.minCritFailure !== CheckFactory.defaultCheckOptions.minCritFailure;
        const maxCritRequired = this.checkOptions.maxCritSuccess !== CheckFactory.defaultCheckOptions.maxCritSuccess;

        if (minCritRequired || maxCritRequired) {
            return "c" + (this.checkOptions.maxCritSuccess ?? "") + "," + (this.checkOptions.minCritFailure ?? "");
        } else {
            return null;
        }
    }

    createSlayingDiceTerm(): string {
        return this.checkOptions.useSlayingDice ? "x" : null;
    }

    static defaultCheckOptions = new DefaultCheckOptions();
}

// TODO: Figure out return of roll (void should be Ok, tough?)
/**
 * Asks the user for all unknown/necessary information and passes them on to perform a roll.
 * @param targetValue {number} The Check Target Number ("CTN")
 * @param options {Partial<DS4CheckFactoryOptions>} Options changing the behaviour of the roll and message.
 */
export async function createCheckRoll(targetValue: number, options: Partial<DS4CheckFactoryOptions>): Promise<void> {
    // Ask for additional required data;
    const gmModifier = await askGmModifier();

    // Create Factory
    const cf = new CheckFactory(targetValue, gmModifier, options);

    // Possibly additional processing

    // Execute roll
    await cf.execute();
}

/**
 * Responsible for rendering the modal interface asking for the modifier specified by GM.
 *
 * @returns {Promise<number>} The number by the user.
 */
async function askGmModifier(): Promise<number> {
    // Render model interface and return value
    return 0;
}

export interface DS4CheckFactoryOptions {
    maxCritSuccess: number;
    minCritFailure: number;
    useSlayingDice: boolean;
    rollMode: DS4RollMode;
}

export type DS4RollMode = "roll" | "gmroll" | "blindroll" | "selfroll";