ddd0a1f1c0
Possibilité de saisir pour les compétences une difficulté libre par défaut, qui sera automatiquement sélectionnée pour les jets de cette compétence faits par l'acteur. Ceci permet de simplifier le travail du MJ, qui peut préconfigurer les difficultés d'attaque des PNJs.
288 lines
12 KiB
JavaScript
288 lines
12 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);
|
|
});
|
|
}
|
|
|
|
_isIgnoreEtatGeneral(rollData) {
|
|
return rollData.selectedCarac.ignoreEtatGeneral;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_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 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 + 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;
|
|
}
|
|
}
|