457 lines
13 KiB
TypeScript
457 lines
13 KiB
TypeScript
import { Evaluated } from "@league-of-foundry-developers/foundry-vtt-types/src/foundry/client/dice/roll";
|
|
import { M5Character } from "../actors/M5Character";
|
|
import { M5EwResult, M5ModOperation, M5ModType, M5RollData, M5RollResult, M5SkillUnlearned, M5Stats } from "../M5Base";
|
|
import { stat } from "fs";
|
|
|
|
export class M5Roll {
|
|
// extends Roll<M5RollData>
|
|
static readonly TEMPLATE_PATH = "systems/midgard5/templates/chat/roll-m5.hbs";
|
|
|
|
public _evaluated: boolean = false;
|
|
public _total: number = 0;
|
|
public pool: PoolTerm = null;
|
|
|
|
constructor(public data: M5RollData, public actor: any, public label: string, public id?: string) {
|
|
//super(null)
|
|
//this.data = rollData
|
|
}
|
|
|
|
// @ts-ignore
|
|
//override evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): Evaluated<Roll<M5RollData>> | Promise<Evaluated<Roll<M5RollData>>> {
|
|
evaluate() {
|
|
const indexMap = new Map<number, string>();
|
|
const rollNames = Object.keys(this.data.rolls);
|
|
const rolls = rollNames
|
|
.filter((rollName) => this.data.rolls[rollName].enabled)
|
|
.map((rollName, index) => {
|
|
indexMap.set(index, rollName);
|
|
const formula = this.data.rolls[rollName];
|
|
formula.formula = index === 0 && this.id !== "-1" ? formula.formula.replace(/(\d*d\d*)/, `{$1 + ${this.data.b.modifier}}`) : formula.formula;
|
|
const roll = new Roll(formula.formula, this.data);
|
|
return roll;
|
|
});
|
|
this.pool = PoolTerm.fromRolls(rolls);
|
|
console.log("evaluate", this._evaluated, this.pool);
|
|
return this.pool.evaluate({ async: true }).then((results) => {
|
|
this._total = 0;
|
|
|
|
results.rolls.forEach((roll, index) => {
|
|
const rollIndex = indexMap.get(index);
|
|
const rollResult = this.data.rolls[rollIndex] as M5RollResult;
|
|
|
|
rollResult.result = roll.result;
|
|
rollResult.total = roll.total;
|
|
rollResult.totalStr = roll.total.toString();
|
|
|
|
this._total += roll.total;
|
|
|
|
let rowRes = M5EwResult.TBD;
|
|
let face100 = -1;
|
|
|
|
roll.dice.forEach((d, dIndex) => {
|
|
rollResult.dice[dIndex.toString()] = d.total;
|
|
|
|
if (rowRes === M5EwResult.TBD && dIndex === 0) {
|
|
if (d.faces === 20) {
|
|
//if (rollResult.type === "ew") {
|
|
if (d.total === 1) rowRes = M5EwResult.FUMBLE;
|
|
else if (d.total === 20) rowRes = M5EwResult.CRITICAL;
|
|
else if (d.total >= 16) rowRes = M5EwResult.HIGH;
|
|
} else if (d.faces === 100) {
|
|
face100 = d.total as number;
|
|
}
|
|
}
|
|
});
|
|
|
|
const parseResult = M5Roll.parseDiceSides(rollResult.formula);
|
|
//console.log("evaluate roll", parseResult)
|
|
if (parseResult?.sides === 20) {
|
|
if (roll.total < this.data.b.difficulty) {
|
|
if (rowRes === M5EwResult.TBD || rowRes === M5EwResult.HIGH) rowRes = M5EwResult.FAIL;
|
|
} else {
|
|
if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.PASS;
|
|
}
|
|
} else if (face100 >= 0) {
|
|
const threshold100 = roll.total + face100;
|
|
const threshold = Math.floor(threshold100 / 10);
|
|
if (face100 === 100) {
|
|
if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.FUMBLE;
|
|
} else if (roll.total < 0) {
|
|
if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.FAIL;
|
|
} else if (face100 <= threshold) {
|
|
if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.CRITICAL;
|
|
} else {
|
|
if (rowRes === M5EwResult.TBD) rowRes = M5EwResult.PASS;
|
|
}
|
|
}
|
|
rollResult.css = rowRes;
|
|
});
|
|
|
|
this.data.res.label = this.label;
|
|
if ((game as Game).settings.get("midgard5", "automatedPP") && this.data.iType !== null) {
|
|
if ((this.data.i.type === "language" || this.data.i.type === "general") && this.data.rolls[0].dice[0] >= 16) {
|
|
this.actor.items.get(this.id).update({
|
|
system: {
|
|
pp: this.data.i.pp + 1,
|
|
},
|
|
});
|
|
} else if (this.data.rolls[0].dice[0] === 20) {
|
|
if (this.data.i.type === "combat") {
|
|
// Rolling through skill
|
|
this.actor.items.get(this.id).update({
|
|
system: {
|
|
pp: this.data.i.pp + 1,
|
|
},
|
|
});
|
|
} else if (this.data.iType === "weapon") {
|
|
// Rolling through Weapon Item
|
|
const skill = this.actor.items.get(this.data.i.skillId);
|
|
skill.update({
|
|
system: {
|
|
pp: skill.system.pp + 1,
|
|
},
|
|
});
|
|
} else if (this.data.iType === "defensiveWeapon") {
|
|
// Rolling through defensiveWeapon Item
|
|
const skill = this.actor.items.get(this.data.i.skillId);
|
|
skill.update({
|
|
system: {
|
|
pp: skill.system.pp + 1,
|
|
},
|
|
});
|
|
} else if (this.data.iType === "spell") {
|
|
// Rolling through Spell Item
|
|
const klasse = this.actor.items.find((x) => x.type === "class" && x.system.equipped);
|
|
klasse.update({
|
|
system: {
|
|
lernKostenZauber: {
|
|
[this.data.i.process]: { pp: klasse.system.lernKostenZauber[this.data.i.process].pp + 1 },
|
|
},
|
|
},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
this._evaluated = true;
|
|
return this;
|
|
});
|
|
}
|
|
|
|
async render(): Promise<string> {
|
|
return renderTemplate(M5Roll.TEMPLATE_PATH, this.data);
|
|
}
|
|
|
|
async toMessage(toggleAutomatedRoll = false) {
|
|
let automatedRoll = (game as Game).settings.get("midgard5", "automatedRoll");
|
|
automatedRoll = toggleAutomatedRoll ? !automatedRoll : automatedRoll;
|
|
const rMode = (game as Game).settings.get("core", "rollMode");
|
|
|
|
if (!automatedRoll) {
|
|
let checkOptions = await this.popUp({ isPW: this.data.rolls[0].label === (game as Game).i18n.localize("midgard5.pw") });
|
|
if (checkOptions["cancelled"]) {
|
|
return;
|
|
} else {
|
|
const rMode = checkOptions["rollMode"];
|
|
this.data.b = checkOptions;
|
|
}
|
|
} else {
|
|
this.data.b = { difficulty: 20, modifier: 0 };
|
|
}
|
|
|
|
if (!this._evaluated) await this.evaluate();
|
|
const faces = this.pool.dice.map((x) => x.faces);
|
|
|
|
const chatData = {
|
|
type: CONST.CHAT_MESSAGE_TYPES.ROLL,
|
|
content: await this.render(),
|
|
speaker: ChatMessage.getSpeaker({ actor: this.actor }),
|
|
sound: CONFIG.sounds.dice,
|
|
roll: Roll.fromTerms([this.pool]),
|
|
flags: { data: this.data, rerolled: false, faces: faces },
|
|
};
|
|
|
|
let foo = ChatMessage.applyRollMode(chatData, rMode);
|
|
return ChatMessage.implementation["create"](foo, { rollMode: rMode });
|
|
}
|
|
|
|
static fromAttributeValue(actor: any, attributeKey: string, attributeValue: number) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
const itemData = actor.items.filter((x) => x.type === "effect").map((y) => y.system.mods);
|
|
rollData.c = 0;
|
|
for (let effectKey in itemData) {
|
|
for (let modkey in itemData[effectKey])
|
|
if (itemData[effectKey][modkey].type === M5ModType.ATTRIBUTE && itemData[effectKey][modkey].operation === M5ModOperation.ROLL) {
|
|
rollData.c += itemData[effectKey][modkey].value;
|
|
}
|
|
}
|
|
|
|
rollData.i = attributeValue;
|
|
rollData.rolls["0"] = {
|
|
formula: "@i - 1d100 - @c",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.pw"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize(`midgard5.actor-${attributeKey}-long`));
|
|
}
|
|
|
|
static fromUnlearnedSkill(actor: any, skill: M5SkillUnlearned, skillName: string) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
rollData.i = {
|
|
fw: skill.fw,
|
|
bonus: actor.system.calc?.attributes[skill.attribute]?.bonus ?? 0,
|
|
};
|
|
rollData.iType = "skill";
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @i.fw + @i.bonus",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.pw"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize(`midgard5.${skillName}`));
|
|
}
|
|
|
|
static brawl(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
rollData.i = {
|
|
attackBonus: 0,
|
|
damageBonus: 0,
|
|
};
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @c.calc.stats.brawlFw",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.attack"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
rollData.rolls["1"] = {
|
|
formula: "1d6 - 4 + @c.calc.stats.damageBonus.value",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.damage"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.brawl"));
|
|
}
|
|
|
|
static deprivationCold(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "@c.calc.stats.deprivationCold.value -1D100",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.deprivationCold"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.deprivationCold"));
|
|
}
|
|
|
|
static deprivationHeat(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "@c.calc.stats.deprivationHeat.value -1D100",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.deprivationHeat"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.deprivationHeat"));
|
|
}
|
|
|
|
static deprivationFood(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "@c.calc.stats.deprivationFood.value -1D100",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.deprivationFood"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.deprivationFood"));
|
|
}
|
|
|
|
static cleanSpell(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @c.calc.stats.spellCasting.value",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.spellCasting"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.spellCasting"));
|
|
}
|
|
|
|
static defense(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
rollData.i = {
|
|
defenseBonus: 0,
|
|
};
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @c.calc.stats.defense.value + @c.calc.stats.defenseBonus.value",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.defense"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.defense"));
|
|
}
|
|
|
|
static resistanceMind(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
rollData.i = {
|
|
defenseBonus: 0,
|
|
};
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @c.calc.stats.resistanceMind.value",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.resistanceMind"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.resistanceMind"));
|
|
}
|
|
|
|
static resistanceBody(actor: any) {
|
|
const rollData = actor.getRollData() as M5RollData;
|
|
rollData.i = {
|
|
defenseBonus: 0,
|
|
};
|
|
|
|
rollData.rolls["0"] = {
|
|
formula: "1d20 + @c.calc.stats.resistanceBody.value",
|
|
enabled: true,
|
|
label: (game as Game).i18n.localize("midgard5.resistanceBody"),
|
|
result: "",
|
|
total: 0,
|
|
totalStr: "",
|
|
dice: {},
|
|
css: "",
|
|
} as M5RollResult;
|
|
|
|
return new M5Roll(rollData, actor, (game as Game).i18n.localize("midgard5.resistanceBody"));
|
|
}
|
|
|
|
static parseDiceSides(formula: string): FormulaParseResult {
|
|
const ewMatcher: RegExp = /\d*[dD]20/g;
|
|
const pwMatcher: RegExp = /(\d+)\s*\-\s*\d*[dD]100/g;
|
|
|
|
let res = formula.match(ewMatcher);
|
|
if (res && !!res[0]) {
|
|
return {
|
|
sides: 20,
|
|
type: "ew",
|
|
threshold: null,
|
|
};
|
|
}
|
|
|
|
res = formula.match(pwMatcher);
|
|
if (res && !!res[1]) {
|
|
return {
|
|
sides: 100,
|
|
type: "pw",
|
|
threshold: parseInt(res[1]),
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async popUp({
|
|
useFortune = false,
|
|
difficulty = 20,
|
|
modifier = 0,
|
|
rollModes = CONFIG.Dice.rollModes,
|
|
rollMode = "",
|
|
template = "systems/midgard5/templates/chat/task-check-dialog.hbs",
|
|
isPW = false,
|
|
} = {}) {
|
|
const html = await renderTemplate(template, { useFortune, difficulty, modifier, rollModes, rollMode, isPW });
|
|
return new Promise((resolve) => {
|
|
const data = {
|
|
title: (game as Game).i18n.localize("midgard5.chat.roll"),
|
|
content: html,
|
|
buttons: {
|
|
roll: {
|
|
label: (game as Game).i18n.localize("midgard5.chat.roll"),
|
|
callback: (html) => resolve(this._processTaskCheckOptions(html[0].querySelector("form"))),
|
|
},
|
|
cancel: {
|
|
label: (game as Game).i18n.localize("midgard5.chat.cancel"),
|
|
callback: (html) => resolve({ cancelled: true }),
|
|
},
|
|
},
|
|
default: "roll",
|
|
close: () => resolve({ cancelled: true }),
|
|
};
|
|
|
|
new Dialog(data, null).render(true);
|
|
});
|
|
}
|
|
|
|
_processTaskCheckOptions(form) {
|
|
return {
|
|
difficulty: parseInt(form.difficulty?.value),
|
|
modifier: parseInt(form.modifier?.value),
|
|
rollMode: form.rollMode?.value,
|
|
};
|
|
}
|
|
}
|
|
|
|
interface FormulaParseResult {
|
|
sides: number;
|
|
type: string;
|
|
threshold: number;
|
|
}
|