323 lines
13 KiB
JavaScript
323 lines
13 KiB
JavaScript
import { HtmlUtility } from "./html-utility.js";
|
|
import { RdDItemCompetence } from "./item-competence.js";
|
|
import { RdDItemSort } from "./item-sort.js";
|
|
import { Misc } from "./misc.js";
|
|
import { RdDBonus } from "./rdd-bonus.js";
|
|
import { RdDResolutionTable } from "./rdd-resolution-table.js";
|
|
|
|
/**
|
|
* Extend the base Dialog entity to select roll parameters
|
|
* @extends {Dialog}
|
|
*/
|
|
/* -------------------------------------------- */
|
|
export class RdDRoll extends Dialog {
|
|
|
|
/* -------------------------------------------- */
|
|
static async create(actor, rollData, dialogConfig, ...actions) {
|
|
|
|
RdDRoll._ensureCorrectActions(actions);
|
|
RdDRoll._setDefaultOptions(actor, rollData);
|
|
|
|
const html = await renderTemplate(dialogConfig.html, rollData);
|
|
|
|
let options = { classes: ["rdddialog"], width: 600, height: 500, 'z-index': 99999 };
|
|
if (dialogConfig.options) {
|
|
mergeObject(options, dialogConfig.options, { overwrite: true })
|
|
}
|
|
return new RdDRoll(actor, rollData, html, options, actions, dialogConfig.close );
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _setDefaultOptions(actor, rollData) {
|
|
|
|
let defaultRollData = {
|
|
alias: actor.name,
|
|
ajustementsConditions: CONFIG.RDD.ajustementsConditions,
|
|
difficultesLibres: CONFIG.RDD.difficultesLibres,
|
|
etat: actor.data.data.compteurs.etat.value,
|
|
moral: actor.isPersonnage() ? actor.data.data.compteurs.moral.value : 0,
|
|
carac: actor.data.data.carac,
|
|
finalLevel: 0,
|
|
diffConditions: rollData.arme ? RdDBonus.bonusAttaque(rollData.surpriseDefenseur) :0,
|
|
diffLibre: rollData.competence?.data.default_diffLibre ?? 0,
|
|
editLibre: true,
|
|
editConditions: true,
|
|
forceValue: actor.getForceValue(),
|
|
malusArmureValue: (actor.isPersonnage() && actor.data.data.attributs && actor.data.data.attributs.malusarmure) ? actor.data.data.attributs.malusarmure.value : 0,
|
|
surencMalusFlag: actor.isPersonnage() ? (actor.data.data.compteurs.surenc.value < 0) : false,
|
|
surencMalusValue: actor.isPersonnage() ? actor.data.data.compteurs.surenc.value : 0,
|
|
surencMalusApply: false,
|
|
isMalusEncombrementTotal: RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
|
|
useMalusEncTotal: false,
|
|
encTotal: actor.getEncombrementTotal(),
|
|
ajustementAstrologique: actor.ajustementAstrologique(),
|
|
surprise: actor.getSurprise()
|
|
}
|
|
mergeObject(rollData, defaultRollData, { overwrite: false });
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
static _ensureCorrectActions(actions) {
|
|
if (actions.length == 0) {
|
|
throw 'No action defined';
|
|
}
|
|
actions.forEach(action => {
|
|
if (action.callbacks == undefined) {
|
|
action.callbacks = [{ action: r => console.log(action.name, r) }];
|
|
}
|
|
});
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
constructor(actor, rollData, html, options, actions, close = undefined) {
|
|
let conf = {
|
|
title: actions[0].label,
|
|
content: html,
|
|
buttons: {},
|
|
default: actions[0].name,
|
|
close: close
|
|
};
|
|
for (let action of actions) {
|
|
conf.buttons[action.name] = { label: action.label, callback: html => this.onAction(action, html) };
|
|
}
|
|
|
|
super(conf, options);
|
|
|
|
this.actor = actor;
|
|
this.rollData = rollData;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async onAction(action, html) {
|
|
await RdDResolutionTable.rollData(this.rollData);
|
|
console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);
|
|
|
|
if (action.callbacks)
|
|
for (let callback of action.callbacks) {
|
|
if (callback.condition == undefined || callback.condition(this.rollData)) {
|
|
callback.action(this.rollData);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
activateListeners(html) {
|
|
super.activateListeners(html);
|
|
|
|
this.bringToTop();
|
|
|
|
var rollData = this.rollData;
|
|
var actor = this.actor;
|
|
var dialog = this;
|
|
|
|
function updateRollResult(rollData) {
|
|
rollData.dmg = rollData.attackerRoll ? rollData.attackerRoll.dmg : RdDBonus.dmg(rollData, actor.getBonusDegat());
|
|
rollData.finalLevel = dialog._computeFinalLevel(rollData);
|
|
rollData.caracValue = parseInt(rollData.selectedCarac.value);
|
|
rollData.coupsNonMortels = (rollData.attackerRoll ? rollData.attackerRoll.dmg.mortalite : rollData.dmg.mortalite) == 'non-mortel';
|
|
let dmgText = Misc.toSignedString(rollData.dmg.total);
|
|
if (rollData.coupsNonMortels) {
|
|
dmgText = '(' + dmgText + ')';
|
|
}
|
|
|
|
HtmlUtility._showControlWhen($(".diffMoral"), rollData.selectedCarac == actor.data.data.carac.volonte);
|
|
|
|
HtmlUtility._showControlWhen($("#etat-general"), !dialog._isIgnoreEtatGeneral(rollData));
|
|
HtmlUtility._showControlWhen($("#ajust-astrologique"), RdDResolutionTable.isAjustementAstrologique(rollData));
|
|
|
|
// Sort management
|
|
if (rollData.selectedSort) {
|
|
rollData.bonus = RdDItemSort.getCaseBonus(rollData.selectedSort, rollData.coord),
|
|
//console.log("Toggle show/hide", rollData.selectedSort);
|
|
HtmlUtility._showControlWhen($("#div-sort-difficulte"), RdDItemSort.isDifficulteVariable(rollData.selectedSort))
|
|
HtmlUtility._showControlWhen($("#div-sort-ptreve"), RdDItemSort.isCoutVariable(rollData.selectedSort))
|
|
}
|
|
|
|
// Mise à jour valeurs
|
|
$("#roll-param").text(rollData.selectedCarac.value + " / " + Misc.toSignedString(rollData.finalLevel));
|
|
$("#compdialogTitle").text(dialog._getTitle(rollData));
|
|
$('#coupsNonMortels').prop('checked', rollData.coupsNonMortels);
|
|
$("#dmg-arme-actor").text(dmgText);
|
|
$("#defenseur-surprise").text(RdDBonus.description(rollData.surpriseDefenseur));
|
|
$(".table-resolution").remove();
|
|
$("#resolutionTable").append(RdDResolutionTable.buildHTMLTableExtract(rollData.caracValue, rollData.finalLevel));
|
|
$(".span-valeur").remove();
|
|
$("#resolutionValeurs").append(RdDResolutionTable.buildHTMLResults(rollData.caracValue, rollData.finalLevel));
|
|
}
|
|
|
|
// Setup everything onload
|
|
$(function () {
|
|
// Update html, according to data
|
|
if (rollData.competence) {
|
|
// Set the default carac from the competence item
|
|
rollData.selectedCarac = rollData.carac[rollData.competence.data.defaut_carac];
|
|
$("#carac").val(rollData.competence.data.defaut_carac);
|
|
}
|
|
RdDItemSort.setCoutReveReel(rollData.selectedSort);
|
|
$("#diffLibre").val(Misc.toInt(rollData.diffLibre));
|
|
$("#diffConditions").val(Misc.toInt(rollData.diffConditions));
|
|
updateRollResult(rollData);
|
|
});
|
|
|
|
// Update !
|
|
html.find('#diffLibre').change((event) => {
|
|
rollData.diffLibre = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
|
|
//console.log("RdDRollSelectDialog","BM CLICKED !!!", rollData);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#diffConditions').change((event) => {
|
|
rollData.diffConditions = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
|
|
//console.log("RdDRollSelectDialog","BM CLICKED !!!", rollData);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#carac').change((event) => {
|
|
let caracKey = event.currentTarget.value;
|
|
this.rollData.selectedCarac = rollData.carac[caracKey]; // Update the selectedCarac
|
|
//console.log("RdDRollSelectDialog","CARAC CLICKED !!!", rollData);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#draconic').change((event) => {
|
|
let draconicKey = Misc.toInt(event.currentTarget.value);
|
|
this.rollData.competence = rollData.draconicList[draconicKey]; // Update the selectedCarac
|
|
//console.log("RdDRollSelectDialog","CARAC CLICKED !!!", rollData);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#sort').change((event) => {
|
|
let sortKey = Misc.toInt(event.currentTarget.value);
|
|
this.rollData.selectedSort = rollData.sortList[sortKey]; // Update the selectedCarac
|
|
this.rollData.bonus = RdDItemSort.getCaseBonus(rollData.selectedSort, rollData.coord);
|
|
RdDItemSort.setCoutReveReel(rollData.selectedSort);
|
|
//console.log("RdDRollSelectDialog - Sort selection", rollData.selectedSort);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#ptreve-variable').change((event) => {
|
|
let ptreve = Misc.toInt(event.currentTarget.value);
|
|
this.rollData.selectedSort.data.ptreve_reel = ptreve;
|
|
console.log("RdDRollSelectDialog - Cout reve", ptreve);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#ptreve-variable').change((event) => {
|
|
let ptreve = Misc.toInt(event.currentTarget.value);
|
|
this.rollData.selectedSort.data.ptreve_reel = ptreve; // Update the selectedCarac
|
|
console.log("RdDRollSelectDialog - Cout reve", ptreve);
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#coupsNonMortels').change((event) => {
|
|
this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#tactique-combat').change((event) => {
|
|
this.rollData.tactique = event.currentTarget.value;
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#surencMalusApply').change((event) => {
|
|
this.rollData.surencMalusApply = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#useMalusEncTotal').change((event) => {
|
|
this.rollData.useMalusEncTotal = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
// Section Méditation
|
|
html.find('#isHeure').change((event) => {
|
|
this.rollData.isHeure = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#isPurification').change((event) => {
|
|
this.rollData.isPurification = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#isVeture').change((event) => {
|
|
this.rollData.isVeture = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
html.find('#isComportement').change((event) => {
|
|
this.rollData.isComportement = event.currentTarget.checked;
|
|
updateRollResult(rollData);
|
|
});
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_isIgnoreEtatGeneral(rollData) {
|
|
return rollData.selectedCarac.ignoreEtatGeneral;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeDiffMeditation( rollData ) {
|
|
let diff = 0;
|
|
if ( rollData.meditation ) {
|
|
diff = (!rollData.isHeure) ? diff - 2 : diff;
|
|
diff = (!rollData.isVeture) ? diff - 2 : diff;
|
|
diff = (!rollData.isComportement) ? diff - 2 : diff;
|
|
diff = (!rollData.isisPuritication) ? diff - 2 : diff;
|
|
diff = diff - rollData.meditation.data.malus; // Malus permanent éventuel
|
|
}
|
|
return diff;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeFinalLevel(rollData) {
|
|
const etat = this._isIgnoreEtatGeneral(rollData) ? 0 : Misc.toInt(rollData.etat);
|
|
const diffConditions = Misc.toInt(rollData.diffConditions);
|
|
const malusEnc = (rollData.surencMalusApply) ? rollData.surencMalusValue : 0;
|
|
const bonusTactique = RdDBonus.bonusAttaque(rollData.tactique);
|
|
const malusEncTotal = (rollData.useMalusEncTotal) ? -rollData.encTotal : 0;
|
|
const ajustementChance = RdDResolutionTable.isAjustementAstrologique(rollData) ? rollData.ajustementAstrologique : 0;
|
|
// Gestion malus armure
|
|
const malusArmureValue = this._computeMalusArmure(rollData);
|
|
|
|
const diffMeditation = this._computeDiffMeditation( rollData );
|
|
const diffLibre = this._computeDiffLibre(rollData);
|
|
const diffCompetence = this._computeDiffCompetence(rollData);
|
|
const diffMoral = rollData.selectedCarac == this.actor.data.data.carac.volonte ? rollData.moral : 0;
|
|
|
|
return etat + diffCompetence + diffLibre + diffMoral + diffConditions + malusEnc + malusEncTotal + malusArmureValue + diffMeditation + ajustementChance + bonusTactique;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeDiffCompetence(rollData) {
|
|
if (rollData.competence) {
|
|
return Misc.toInt(rollData.competence.data.niveau);
|
|
}
|
|
if (rollData.draconicList) {
|
|
return Misc.toInt(rollData.competence.data.niveau);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_computeDiffLibre(rollData) {
|
|
let diffLibre = Misc.toInt(rollData.diffLibre);
|
|
if (rollData.draconicList && rollData.selectedSort) {
|
|
return RdDItemSort.getDifficulte(rollData.selectedSort, diffLibre);
|
|
}
|
|
return diffLibre;
|
|
}
|
|
|
|
_computeMalusArmure(rollData) {
|
|
let malusArmureValue = 0;
|
|
if (rollData.malusArmureValue != 0 && (rollData.selectedCarac.label == "Agilité" || rollData.selectedCarac.label == "Dérobée")) {
|
|
$("#addon-message").text("Malus armure appliqué : " + rollData.malusArmureValue);
|
|
malusArmureValue = rollData.malusArmureValue;
|
|
} else {
|
|
$("#addon-message").text("");
|
|
}
|
|
return malusArmureValue;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_getTitle(rollData) {
|
|
if (rollData.competence) {
|
|
// If a weapon is there, add it in the title
|
|
let armeTitle = (rollData.arme) ? " (" + rollData.arme.name + ") " : "";
|
|
let niveau = Misc.toSignedString(rollData.competence.data.niveau);
|
|
return rollData.selectedCarac.label + "/" + rollData.competence.name + armeTitle + " " + niveau
|
|
}
|
|
if (rollData.draconicList) {
|
|
return rollData.competence.name + " - " + rollData.selectedSort.name;
|
|
}
|
|
return rollData.selectedCarac.label;
|
|
}
|
|
}
|