277 lines
11 KiB
TypeScript
277 lines
11 KiB
TypeScript
// SPDX-FileCopyrightText: 2021 Johannes Loher
|
|
// SPDX-FileCopyrightText: 2021 Oliver Rümpelein
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
import { DialogWithListeners } from "../apps/dialog-with-listeners";
|
|
import { DS4 } from "../config";
|
|
import { getGame } from "../utils/utils";
|
|
|
|
/**
|
|
* Provides default values for all arguments the `CheckFactory` expects.
|
|
*/
|
|
class DefaultCheckOptions implements DS4CheckFactoryOptions {
|
|
readonly maximumCoupResult = 1;
|
|
readonly minimumFumbleResult = 20;
|
|
readonly useSlayingDice = false;
|
|
readonly rollMode: keyof CONFIG.Dice.RollModes = "publicroll";
|
|
readonly flavor: undefined;
|
|
|
|
mergeWith(other: Partial<DS4CheckFactoryOptions>): DS4CheckFactoryOptions {
|
|
return { ...this, ...other };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Singleton reference for default value extraction.
|
|
*/
|
|
const defaultCheckOptions = new DefaultCheckOptions();
|
|
|
|
/**
|
|
* Most basic class responsible for generating the chat formula and passing it to the chat as roll.
|
|
*/
|
|
class CheckFactory {
|
|
constructor(
|
|
private checkTargetNumber: number,
|
|
private checkModifier: number,
|
|
options: Partial<DS4CheckFactoryOptions> = {},
|
|
) {
|
|
this.options = defaultCheckOptions.mergeWith(options);
|
|
}
|
|
|
|
private options: DS4CheckFactoryOptions;
|
|
|
|
async execute(): Promise<ChatMessage | undefined> {
|
|
const innerFormula = ["ds", this.createCheckTargetNumberModifier(), this.createCoupFumbleModifier()].filterJoin(
|
|
"",
|
|
);
|
|
const formula = this.options.useSlayingDice ? `{${innerFormula}}x` : innerFormula;
|
|
const roll = Roll.create(formula);
|
|
const speaker = this.options.speaker ?? ChatMessage.getSpeaker();
|
|
|
|
return roll.toMessage(
|
|
{
|
|
speaker,
|
|
flavor: this.options.flavor,
|
|
flags: this.options.flavorData ? { ds4: { flavorData: this.options.flavorData } } : undefined,
|
|
},
|
|
{ rollMode: this.options.rollMode, create: true },
|
|
);
|
|
}
|
|
|
|
createCheckTargetNumberModifier(): string {
|
|
const totalCheckTargetNumber = this.checkTargetNumber + this.checkModifier;
|
|
return totalCheckTargetNumber >= 0 ? `v${this.checkTargetNumber + this.checkModifier}` : "v0";
|
|
}
|
|
|
|
createCoupFumbleModifier(): string | null {
|
|
const isMinimumFumbleResultRequired =
|
|
this.options.minimumFumbleResult !== defaultCheckOptions.minimumFumbleResult;
|
|
const isMaximumCoupResultRequired = this.options.maximumCoupResult !== defaultCheckOptions.maximumCoupResult;
|
|
|
|
if (isMinimumFumbleResultRequired || isMaximumCoupResultRequired) {
|
|
return `c${this.options.maximumCoupResult ?? ""}:${this.options.minimumFumbleResult ?? ""}`;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Asks the user for all unknown/necessary information and passes them on to perform a roll.
|
|
* @param checkTargetNumber - The Check Target Number ("CTN")
|
|
* @param options - Options changing the behavior of the roll and message.
|
|
*/
|
|
export async function createCheckRoll(
|
|
checkTargetNumber: number,
|
|
options: Partial<DS4CheckFactoryOptions> = {},
|
|
): Promise<ChatMessage | unknown> {
|
|
// Ask for additional required data;
|
|
const interactiveRollData = await askForInteractiveRollData(checkTargetNumber, options);
|
|
|
|
const newTargetValue = interactiveRollData.checkTargetNumber ?? checkTargetNumber;
|
|
const checkModifier = interactiveRollData.checkModifier ?? 0;
|
|
const newOptions: Partial<DS4CheckFactoryOptions> = {
|
|
maximumCoupResult: interactiveRollData.maximumCoupResult ?? options.maximumCoupResult,
|
|
minimumFumbleResult: interactiveRollData.minimumFumbleResult ?? options.minimumFumbleResult,
|
|
useSlayingDice: getGame().settings.get("ds4", "useSlayingDiceForAutomatedChecks"),
|
|
rollMode: interactiveRollData.rollMode ?? options.rollMode,
|
|
flavor: options.flavor,
|
|
flavorData: options.flavorData,
|
|
speaker: options.speaker,
|
|
};
|
|
|
|
// Create Factory
|
|
const cf = new CheckFactory(newTargetValue, checkModifier, newOptions);
|
|
|
|
// Possibly additional processing
|
|
|
|
// Execute roll
|
|
return cf.execute();
|
|
}
|
|
|
|
/**
|
|
* Responsible for rendering the modal interface asking for the check modifier and (currently) additional
|
|
* data.
|
|
*
|
|
* @notes
|
|
* At the moment, this asks for more data than it will do after some iterations.
|
|
*
|
|
* @returns The data given by the user.
|
|
*/
|
|
async function askForInteractiveRollData(
|
|
checkTargetNumber: number,
|
|
options: Partial<DS4CheckFactoryOptions> = {},
|
|
{ template, title }: { template?: string; title?: string } = {},
|
|
): Promise<Partial<IntermediateInteractiveRollData>> {
|
|
const usedTemplate = template ?? "systems/ds4/templates/dialogs/roll-options.hbs";
|
|
const usedTitle = title ?? getGame().i18n.localize("DS4.DialogRollOptionsDefaultTitle");
|
|
const id = foundry.utils.randomID();
|
|
const templateData = {
|
|
title: usedTitle,
|
|
checkTargetNumber: checkTargetNumber,
|
|
maximumCoupResult: options.maximumCoupResult ?? defaultCheckOptions.maximumCoupResult,
|
|
minimumFumbleResult: options.minimumFumbleResult ?? defaultCheckOptions.minimumFumbleResult,
|
|
rollMode: options.rollMode ?? getGame().settings.get("core", "rollMode"),
|
|
rollModes: CONFIG.Dice.rollModes,
|
|
checkModifiers: Object.entries(DS4.i18n.checkModifiers).map(([key, translation]) => {
|
|
if (key in DS4.checkModifiers) {
|
|
const value = DS4.checkModifiers[key as keyof typeof DS4.checkModifiers];
|
|
const label = `${translation} (${value >= 0 ? `+${value}` : value})`;
|
|
return { value, label };
|
|
}
|
|
return { value: key, label: translation };
|
|
}),
|
|
id,
|
|
};
|
|
const renderedHtml = await renderTemplate(usedTemplate, templateData);
|
|
|
|
const dialogPromise = new Promise<HTMLFormElement>((resolve) => {
|
|
new DialogWithListeners(
|
|
{
|
|
title: usedTitle,
|
|
content: renderedHtml,
|
|
buttons: {
|
|
ok: {
|
|
icon: '<i class="fas fa-check"></i>',
|
|
label: getGame().i18n.localize("DS4.GenericOkButton"),
|
|
callback: (html) => {
|
|
if (!("jquery" in html)) {
|
|
throw new Error(
|
|
getGame().i18n.format("DS4.ErrorUnexpectedHtmlType", {
|
|
exType: "JQuery",
|
|
realType: "HTMLElement",
|
|
}),
|
|
);
|
|
} else {
|
|
const innerForm = html[0]?.querySelector("form");
|
|
if (!innerForm) {
|
|
throw new Error(
|
|
getGame().i18n.format("DS4.ErrorCouldNotFindHtmlElement", {
|
|
htmlElement: "form",
|
|
}),
|
|
);
|
|
}
|
|
resolve(innerForm);
|
|
}
|
|
},
|
|
},
|
|
cancel: {
|
|
icon: '<i class="fas fa-times"></i>',
|
|
label: getGame().i18n.localize("DS4.GenericCancelButton"),
|
|
},
|
|
},
|
|
default: "ok",
|
|
},
|
|
{
|
|
activateAdditionalListeners: (html, app) => {
|
|
const checkModifierCustomFormGroup = html
|
|
.find(`#check-modifier-custom-${id}`)
|
|
.parent(".form-group");
|
|
html.find(`#check-modifier-${id}`).on("change", (event) => {
|
|
if (
|
|
(event.currentTarget as HTMLSelectElement).value === "custom" &&
|
|
checkModifierCustomFormGroup.hasClass("ds4-hidden")
|
|
) {
|
|
checkModifierCustomFormGroup.removeClass("ds4-hidden");
|
|
app.setPosition({ height: "auto" });
|
|
} else if (!checkModifierCustomFormGroup.hasClass("ds4-hidden")) {
|
|
checkModifierCustomFormGroup.addClass("ds4-hidden");
|
|
app.setPosition({ height: "auto" });
|
|
}
|
|
});
|
|
},
|
|
id,
|
|
},
|
|
).render(true);
|
|
});
|
|
const dialogForm = await dialogPromise;
|
|
return parseDialogFormData(dialogForm);
|
|
}
|
|
|
|
/**
|
|
* Extracts Dialog data from the returned DOM element.
|
|
* @param formData - The filed dialog
|
|
*/
|
|
function parseDialogFormData(formData: HTMLFormElement): Partial<IntermediateInteractiveRollData> {
|
|
const chosenCheckTargetNumber = parseInt(formData["check-target-number"]?.value);
|
|
const chosenCheckModifier = formData["check-modifier"]?.value;
|
|
|
|
const chosenCheckModifierValue =
|
|
chosenCheckModifier === "custom"
|
|
? parseInt(formData["check-modifier-custom"]?.value)
|
|
: parseInt(chosenCheckModifier);
|
|
|
|
const chosenMaximumCoupResult = parseInt(formData["maximum-coup-result"]?.value);
|
|
const chosenMinimumFumbleResult = parseInt(formData["minimum-fumble-result"]?.value);
|
|
const chosenRollMode = formData["roll-mode"]?.value;
|
|
|
|
return {
|
|
checkTargetNumber: Number.isSafeInteger(chosenCheckTargetNumber) ? chosenCheckTargetNumber : undefined,
|
|
checkModifier: Number.isSafeInteger(chosenCheckModifierValue) ? chosenCheckModifierValue : undefined,
|
|
maximumCoupResult: Number.isSafeInteger(chosenMaximumCoupResult) ? chosenMaximumCoupResult : undefined,
|
|
minimumFumbleResult: Number.isSafeInteger(chosenMinimumFumbleResult) ? chosenMinimumFumbleResult : undefined,
|
|
rollMode: Object.keys(CONFIG.Dice.rollModes).includes(chosenRollMode) ? chosenRollMode : undefined,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Contains data that needs retrieval from an interactive Dialog.
|
|
*/
|
|
interface InteractiveRollData {
|
|
checkModifier: number;
|
|
rollMode: keyof CONFIG.Dice.RollModes;
|
|
}
|
|
|
|
/**
|
|
* Contains *CURRENTLY* necessary Data for drafting a roll.
|
|
*
|
|
* @deprecated
|
|
* Quite a lot of this information is requested due to a lack of automation:
|
|
* - maximumCoupResult
|
|
* - minimumFumbleResult
|
|
* - checkTargetNumber
|
|
*
|
|
* They will and should be removed once effects and data retrieval is in place.
|
|
* If a "raw" roll dialog is necessary, create another pre-processing Dialog
|
|
* class asking for the required information.
|
|
* This interface should then be replaced with the `InteractiveRollData`.
|
|
*/
|
|
interface IntermediateInteractiveRollData extends InteractiveRollData {
|
|
checkTargetNumber: number;
|
|
maximumCoupResult: number;
|
|
minimumFumbleResult: number;
|
|
}
|
|
|
|
/**
|
|
* The minimum behavioral options that need to be passed to the factory.
|
|
*/
|
|
export interface DS4CheckFactoryOptions {
|
|
maximumCoupResult: number;
|
|
minimumFumbleResult: number;
|
|
useSlayingDice: boolean;
|
|
rollMode: keyof CONFIG.Dice.RollModes;
|
|
flavor?: string;
|
|
flavorData?: Record<string, string | number | null>;
|
|
speaker?: ReturnType<typeof ChatMessage.getSpeaker>;
|
|
}
|