diff --git a/module/actor-sheet.js b/module/actor-sheet.js
index 29170dc2..c14aee91 100644
--- a/module/actor-sheet.js
+++ b/module/actor-sheet.js
@@ -62,7 +62,7 @@ export class RdDActorSheet extends ActorSheet {
if (this.actor.data.type == 'creature') return formData; // Shortcut
- formData.competenceByCategory = Misc.classify(formData.data.competences, item => item.data.categorie);
+ formData.competenceByCategory = Misc.classify(formData.data.competences, it => it.data.categorie);
formData.calc = {
comptageArchetype: RdDItemCompetence.computeResumeArchetype(formData.data.competences),
@@ -453,9 +453,7 @@ export class RdDActorSheet extends ActorSheet {
// On pts de reve change
html.find('.pointsreve-value').change((event) => {
let reveValue = event.currentTarget.value;
- let reve = duplicate(this.actor.data.data.reve.reve);
- reve.value = reveValue;
- this.actor.update({ "data.reve.reve": reve });
+ this.actor.update({ "data.reve.reve.value": reveValue });
});
// On seuil de reve change
@@ -465,7 +463,7 @@ export class RdDActorSheet extends ActorSheet {
});
html.find('#attribut-protection-edit').change((event) => {
- this.actor.updateProtectionValue(event.currentTarget.attributes.name.value, parseInt(event.target.value));
+ this.actor.updateAttributeValue(event.currentTarget.attributes.name.value, parseInt(event.target.value));
});
// On stress change
diff --git a/module/actor.js b/module/actor.js
index 68bf750e..8097e01c 100644
--- a/module/actor.js
+++ b/module/actor.js
@@ -160,65 +160,66 @@ export class RdDActor extends Actor {
if (!this.isPersonnage()) {
return 0;
}
- return Misc.toInt(this.data.data.sante.fatigue?.value);
+ return Misc.toInt(Misc.templateData(this).sante.fatigue?.value);
}
/* -------------------------------------------- */
getFatigueMax() {
if (!this.isPersonnage()) {
return 1;
}
- return Misc.toInt(this.data.data.sante.fatigue?.max);
+ return Misc.toInt(Misc.templateData(this).sante.fatigue?.max);
}
/* -------------------------------------------- */
getReveActuel() {
- return Misc.toInt(this.data.data.reve?.reve?.value ?? this.data.data.carac.reve.value);
+ const actorData = Misc.data(this);
+ return Misc.toInt(actorData.data.reve?.reve?.value ?? actorData.data.carac.reve.value);
}
/* -------------------------------------------- */
getChanceActuel() {
- return Misc.toInt(this.data.data.compteurs.chance?.value ?? 10);
+ return Misc.toInt(Misc.templateData(this).compteurs.chance?.value ?? 10);
}
/* -------------------------------------------- */
getTaille() {
- return Misc.toInt(this.data.data.carac.taille?.value);
+ return Misc.toInt(Misc.templateData(this).carac.taille?.value);
}
/* -------------------------------------------- */
getForce() {
if (this.isEntiteCauchemar()) {
- return Misc.toInt(this.data.data.carac.reve?.value);
+ return Misc.toInt(Misc.templateData(this).carac.reve?.value);
}
- return Misc.toInt(this.data.data.carac.force?.value);
+ return Misc.toInt(Misc.templateData(this).carac.force?.value);
}
/* -------------------------------------------- */
getAgilite() {
switch (this.data.type) {
- case 'personnage': return Misc.toInt(this.data.data.carac.agilite?.value);
- case 'creature': return Misc.toInt(this.data.data.carac.force?.value);
- case 'entite': return Misc.toInt(this.data.data.carac.reve?.value);
+ case 'personnage': return Misc.toInt(Misc.templateData(this).carac.agilite?.value);
+ case 'creature': return Misc.toInt(Misc.templateData(this).carac.force?.value);
+ case 'entite': return Misc.toInt(Misc.templateData(this).carac.reve?.value);
}
return 10;
}
/* -------------------------------------------- */
getChance() {
- return Misc.toInt(this.data.data.carac.chance?.value ?? 10);
+ return Misc.toInt(Misc.templateData(this).carac.chance?.value ?? 10);
}
getMoralTotal() {
- return Misc.toInt(this.data.data.compteurs.moral?.value);
+ return Misc.toInt(Misc.templateData(this).compteurs.moral?.value);
}
/* -------------------------------------------- */
getBonusDegat() {
// TODO: gérer séparation et +dom créature/entité indépendament de la compétence
- return Misc.toInt(this.data.data.attributs.plusdom.value);
+ return Misc.toInt(Misc.templateData(this).attributs.plusdom.value);
}
/* -------------------------------------------- */
getProtectionNaturelle() {
- return Misc.toInt(this.data.data.attributs.protection.value);
+ return Misc.toInt(Misc.templateData(this).attributs.protection.value);
}
/* -------------------------------------------- */
getEtatGeneral() {
- return Misc.toInt(this.data.data.compteurs.etat?.value);
+ return Misc.toInt(Misc.templateData(this).compteurs.etat?.value);
}
getMalusArmure() {
- return Misc.toInt(this.data.data.attributs?.malusarmure?.value);
+ return Misc.toInt(Misc.templateData(this).attributs?.malusarmure?.value);
}
getEncTotal() {
return Math.floor(this.encTotal ?? 0);
@@ -227,11 +228,11 @@ export class RdDActor extends Actor {
return Math.floor(this.prixTotalEquipement ?? 0);
}
getSurenc() {
- return Misc.toInt(this.data.data.compteurs.surenc?.value);
+ return Misc.toInt(Misc.templateData(this).compteurs.surenc?.value);
}
/* -------------------------------------------- */
loadCompendiumNames() {
- return this.data.items.filter((item) => item.type == 'competence');
+ return this.data.items.filter(item => item.type == 'competence');
}
/* -------------------------------------------- */
getCompetence(name) {
@@ -271,11 +272,11 @@ export class RdDActor extends Actor {
return duplicate(list[0]);
}
getDemiReve() {
- return this.data.data.reve.tmrpos.coord;
+ return Misc.templateData(this).reve.tmrpos.coord;
}
/* -------------------------------------------- */
async deleteSortReserve(sortReserve) {
- let reserve = duplicate(this.data.data.reve.reserve);
+ let reserve = duplicate(Misc.templateData(this).reve.reserve);
let tmr = TMRUtility.getTMR(sortReserve.coord);
let index = reserve.list.findIndex(tmr.type == 'fleuve'
? sort => (TMRUtility.getTMR(sort.coord).type == 'fleuve' && sort.sort.name == sortReserve.sort.name)
@@ -308,7 +309,7 @@ export class RdDActor extends Actor {
content: ""
};
- const blessures = duplicate(this.data.data.blessures);
+ const blessures = duplicate(Misc.templateData(this).blessures);
await this._recupererBlessures(message, "legere", blessures.legeres.liste.filter(b => b.active), []);
await this._recupererBlessures(message, "grave", blessures.graves.liste.filter(b => b.active), blessures.legeres.liste);
await this._recupererBlessures(message, "critique", blessures.critiques.liste.filter(b => b.active), blessures.graves.liste);
@@ -381,9 +382,10 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _recupererVie(message) {
- let blessures = [].concat(this.data.data.blessures.legeres.liste).concat(this.data.data.blessures.graves.liste).concat(this.data.data.blessures.critiques.liste);
+ const tData = Misc.templateData(this);
+ let blessures = [].concat(tData.blessures.legeres.liste).concat(tData.blessures.graves.liste).concat(tData.blessures.critiques.liste);
let nbBlessures = blessures.filter(b => b.active);
- let vieManquante = this.data.data.sante.vie.max - this.data.data.sante.vie.value;
+ let vieManquante = tData.sante.vie.max - tData.sante.vie.value;
if (nbBlessures == 0 && vieManquante > 0) {
let bonusSoins = 0;
for (let b of blessures) {
@@ -407,8 +409,9 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _jetRecuperationConstitution(bonusSoins, message = undefined) {
- let difficulte = Misc.toInt(bonusSoins) + Math.min(0, this.data.data.sante.vie.value - this.data.data.sante.vie.max);
- let rolled = await RdDResolutionTable.roll(this.data.data.carac.constitution.value, difficulte);
+ const tData = Misc.templateData(this);
+ let difficulte = Misc.toInt(bonusSoins) + Math.min(0, tData.sante.vie.value - tData.sante.vie.max);
+ let rolled = await RdDResolutionTable.roll(tData.carac.constitution.value, difficulte);
if (message) {
message.content += RdDResolutionTable.explain(rolled).replace(/Jet :/, "Constitution :");
}
@@ -421,13 +424,14 @@ export class RdDActor extends Actor {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
content: "Remise à neuf de " + this.name
};
+ const actorData = Misc.data(this);
if (this.isEntiteCauchemar()) {
- await this.santeIncDec("endurance", this.data.data.sante.endurance.max - this.data.data.sante.endurance.value);
+ await this.santeIncDec("endurance", actorData.data.sante.endurance.max - actorData.data.sante.endurance.value);
}
else {
- if (this.data.data.blessures) {
- const blessures = duplicate(this.data.data.blessures);
+ if (actorData.data.blessures) {
+ const blessures = duplicate(actorData.data.blessures);
for (let listeBlessures of [blessures.legeres.liste, blessures.graves.liste, blessures.critiques.liste]) {
for (let blessure of listeBlessures) {
this._supprimerBlessure(blessure);
@@ -439,9 +443,9 @@ export class RdDActor extends Actor {
await this.setEthylisme(1);
}
- await this.santeIncDec("vie", this.data.data.sante.vie.max - this.data.data.sante.vie.value);
- await this.santeIncDec("endurance", this.data.data.sante.endurance.max - this.data.data.sante.endurance.value);
- if (this.data.data.sante.fatigue) {
+ await this.santeIncDec("vie", actorData.data.sante.vie.max - actorData.data.sante.vie.value);
+ await this.santeIncDec("endurance", actorData.data.sante.endurance.max - actorData.data.sante.endurance.value);
+ if (actorData.data.sante.fatigue) {
await this.update({ "data.sante.fatigue.value": 0 });
}
}
@@ -469,7 +473,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _recupererEthylisme(message) {
- let ethylisme = duplicate(this.data.data.compteurs.ethylisme);
+ let ethylisme = duplicate(Misc.templateData(this).compteurs.ethylisme);
ethylisme.nb_doses = 0;
ethylisme.jet_moral = false;
if (ethylisme.value < 1) {
@@ -483,7 +487,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recupereEndurance(message) {
- const manquant = this._computeEnduranceMax() - this.data.data.sante.endurance.value;
+ const manquant = this._computeEnduranceMax() - Misc.templateData(this).sante.endurance.value;
if (manquant > 0) {
await this.santeIncDec("endurance", manquant);
message.content += "Vous récuperez " + manquant + " points d'endurance. ";
@@ -492,7 +496,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recupererFatigue(message) {
- let fatigue = this.data.data.sante.fatigue.value;
+ let fatigue = Misc.templateData(this).sante.fatigue.value;
const fatigueMin = this._computeFatigueMin();
if (fatigue <= fatigueMin) {
message.content += "Vous êtes déjà reposé. ";
@@ -508,7 +512,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
_calculRecuperationSegment(actuel) {
- const segments = RdDUtility.getSegmentsFatigue(this.data.data.sante.endurance.max);
+ const segments = RdDUtility.getSegmentsFatigue(Misc.templateData(this).sante.endurance.max);
let cumul = 0;
let i;
for (i = 0; i < 11; i++) {
@@ -528,7 +532,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recuperationReve(message) {
- const seuil = this.data.data.reve.seuil.value;
+ const seuil = Misc.templateData(this).reve.seuil.value;
const reveActuel = this.getReveActuel();
if (reveActuel >= seuil) {
message.content += `Vous avez suffisament rêvé, au delà de votre seuil. `;
@@ -550,7 +554,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async retourSeuilDeReve(message) {
- const seuil = this.data.data.reve.seuil.value;
+ const seuil = Misc.templateData(this).reve.seuil.value;
const reveActuel = this.getReveActuel();
if (reveActuel > seuil) {
message.content += `
Votre rêve redescend vers son seuil naturel (${seuil}, nouveau rêve actuel ${(reveActuel - 1)})`;
@@ -640,7 +644,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async sortMisEnReserve(rollData, sort) {
- let reserve = duplicate(this.data.data.reve.reserve.list);
+ let reserve = duplicate(Misc.templateData(this).reve.reserve.list);
reserve.push({ coord: rollData.tmr.coord, sort: sort, draconic: duplicate(rollData.competence) });
await this.update({ "data.reve.reserve.list": reserve });
this.currentTMR.updateTokens();
@@ -648,24 +652,24 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async updateCarac(caracName, caracValue) {
- let caracpath = "data.carac." + caracName + ".value"
if (caracName == "force") {
if (Number(caracValue) > this.getTaille() + 4) {
ui.notifications.warn("Votre FORCE doit être au maximum de TAILLE+4");
return;
}
}
+ const actorData = Misc.data(this);
if (caracName == "reve") {
- if (caracValue > Misc.toInt(this.data.data.reve.seuil.value)) {
+ if (caracValue > Misc.toInt(actorData.data.reve.seuil.value)) {
this.setPointsDeSeuil(caracValue);
}
}
if (caracName == "chance") {
- if (caracValue > Misc.toInt(this.data.data.compteurs.chance.value)) {
+ if (caracValue > Misc.toInt(actorData.data.compteurs.chance.value)) {
this.setPointsDeChance(caracValue);
}
}
- await this.update({ [caracpath]: caracValue });
+ await this.update({ [`data.carac.${caracName}.value`]: caracValue });
}
/* -------------------------------------------- */
@@ -673,8 +677,7 @@ export class RdDActor extends Actor {
if (caracName == 'Taille') {
return;
}
- let caracpath = "data.carac." + caracName + ".xp";
- await this.update({ [caracpath]: caracXP ?? 0 });
+ await this.update({ [`data.carac.${caracName}.xp`]: caracXP ?? 0 });
this.checkCaracXP(caracName);
}
@@ -758,16 +761,12 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async updateCompteurValue(fieldName, fieldValue) {
- let compteurs = duplicate(this.data.data.compteurs);
- compteurs[fieldName].value = fieldValue;
- await this.update({ "data.compteurs": compteurs });
+ await this.update({ [`data.compteurs.${fieldName}.value`]: fieldValue });
}
/* -------------------------------------------- */
- async updateProtectionValue(fieldName, fieldValue) {
- let attributs = duplicate(this.data.data.attributs);
- attributs[fieldName].value = fieldValue;
- await this.update({ "data.attributs": attributs });
+ async updateAttributeValue(fieldName, fieldValue) {
+ await this.update({ [`data.attributs.${fieldName}.value`]: fieldValue });
}
/* -------------------------------------------- */
@@ -941,9 +940,9 @@ export class RdDActor extends Actor {
detectSurEncombrement() {
let maxEnc = 0;
if (this.data.type == 'vehicule')
- maxEnc = this.data.data.capacite_encombrement;
+ maxEnc = Misc.templateData(this).capacite_encombrement;
else
- maxEnc = this.data.data.attributs.encombrement.value;
+ maxEnc = Misc.templateData(this).attributs.encombrement.value;
let diffEnc = Number(this.encTotal) - Number(maxEnc);
return Math.max(0, Math.ceil(diffEnc));
}
@@ -952,20 +951,19 @@ export class RdDActor extends Actor {
async computeEncombrementTotalEtMalusArmure() {
let encTotal = 0;
let newMalusArmure = 0;
- for (const item of this.data.items) {
- if (item.type == 'armure' && item.data.equipe) { // Armure équipée, intégration du malus armure total
- newMalusArmure += item.data.malus;
+ for (const itemData of this.data.items) {
+ if (itemData.type == 'armure' && itemData.data.equipe) { // Armure équipée, intégration du malus armure total
+ newMalusArmure += itemData.data.malus;
}
// Calcul encombrement
- if (item.data && item.data.encombrement != undefined) {
- if (!Number(item.data.encombrement)) item.data.encombrement = 0; // Auto-fix
- if (item.data.quantite == undefined) item.data.quantite = 1; // Auto-fix
- if (item.data.quantite < 0) item.data.quantite = 0; // Auto-fix
- item.data.encTotal = Number(item.data.encombrement) * Number(item.data.quantite);
- //console.log("Enc:", item.name, item.data.encombrement, item.data.quantite, item.data.encTotal);
- encTotal += item.data.encTotal;
+ if (itemData.data && itemData.data.encombrement != undefined) {
+ if (!Number(itemData.data.encombrement)) itemData.data.encombrement = 0; // Auto-fix
+ if (itemData.data.quantite == undefined) itemData.data.quantite = 1; // Auto-fix
+ if (itemData.data.quantite < 0) itemData.data.quantite = 0; // Auto-fix
+ itemData.data.encTotal = Number(itemData.data.encombrement) * Number(itemData.data.quantite);
+ encTotal += itemData.data.encTotal;
} else {
- item.data.encTotal = 0; // Force default enc
+ itemData.data.encTotal = 0; // Force default enc
}
}
// Mise à jour valeur totale et états
@@ -973,8 +971,8 @@ export class RdDActor extends Actor {
this.detectSurEncombrement();
// Mise à jour éventuelle du malus armure
- if (this.data.data.attributs?.malusarmure && newMalusArmure != this.data.data.attributs.malusarmure.value) {
- await this.update({ "data.attributs.malusarmure.value ": newMalusArmure });
+ if (newMalusArmure && Misc.templateData(this).attributs?.malusarmure?.value != newMalusArmure) {
+ await this.updateAttributeValue("malusarmure", newMalusArmure);
}
return this.encTotal;
}
@@ -984,12 +982,12 @@ export class RdDActor extends Actor {
let prixTotalEquipement = 0;
// prix total de l'équipement est la somme du cout de chaque équipement multiplié par sa quantité.
- for (const item of this.data.items) {
- if (item.data && item.data.cout != undefined) {
- if (!Number(item.data.cout)) item.data.cout = 0; // Auto-fix
- if (item.data.quantite == undefined) item.data.quantite = 1; // Auto-fix
- if (item.data.cout < 0) item.data.cout = 0; // Auto-fix
- prixTotalEquipement += Number(item.data.cout) * Number(item.data.quantite);
+ for (const itemData of this.data.items) {
+ if (itemData.data && itemData.data.cout != undefined) {
+ if (!Number(itemData.data.cout)) itemData.data.cout = 0; // Auto-fix
+ if (itemData.data.quantite == undefined) itemData.data.quantite = 1; // Auto-fix
+ if (itemData.data.cout < 0) itemData.data.cout = 0; // Auto-fix
+ prixTotalEquipement += Number(itemData.data.cout) * Number(itemData.data.quantite);
}
}
// Mise à jour valeur totale de l'équipement
@@ -998,7 +996,8 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
- computeResumeBlessure(blessures = this.data.data.blessures) {
+ computeResumeBlessure(blessures = undefined) {
+ blessures = blessures ?? Misc.templateData(this).blessures;
let nbLegeres = this.countBlessures(blessures.legeres.liste);
let nbGraves = this.countBlessures(blessures.graves.liste);
let nbCritiques = this.countBlessures(blessures.critiques.liste);
@@ -1027,30 +1026,32 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
computeEtatGeneral() {
- let data = this.data.data;
+ const actorData = Misc.data(this);
+ console.info("computeEtatGeneral", actorData)
+
// Pas d'état général pour les entités forçage à 0
if (this.data.type == 'entite') {
- data.compteurs.etat.value = 0;
+ actorData.data.compteurs.etat.value = 0;
return;
}
// Pour les autres
- let state = - (data.sante.vie.max - data.sante.vie.value);
- if (data.sante.fatigue) {
+ let state = - (actorData.data.sante.vie.max - actorData.data.sante.vie.value);
+ if (actorData.data.sante.fatigue) {
// Creatures n'ont pas de fatigue
- state += RdDUtility.currentFatigueMalus(data.sante.fatigue.value, data.sante.endurance.max);
+ state += RdDUtility.currentFatigueMalus(actorData.data.sante.fatigue.value, actorData.data.sante.endurance.max);
}
// Ajout de l'éthylisme
- state += Math.min(0, (data.compteurs.ethylisme?.value ?? 0));
+ state += Math.min(0, (actorData.data.compteurs.ethylisme?.value ?? 0));
- data.compteurs.etat.value = state;
- if (data.compteurs && data.compteurs.surenc) {
- data.compteurs.surenc.value = - this.detectSurEncombrement();
+ actorData.data.compteurs.etat.value = state;
+ if (actorData.data.compteurs && actorData.data.compteurs.surenc) {
+ actorData.data.compteurs.surenc.value = - this.detectSurEncombrement();
}
}
/* -------------------------------------------- */
async ajouterRefoulement(value = 1) {
- let refoulement = this.data.data.reve.refoulement.value + value;
+ let refoulement = Misc.templateData(this).reve.refoulement.value + value;
let total = new Roll("1d20").roll().total;
if (total <= refoulement) {
refoulement = 0;
@@ -1076,7 +1077,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ajouterQueue(options = { chat: false }) {
let queue;
- if (this.data.data.reve.reve.thanatosused) {
+ if (Misc.templateData(this).reve.reve.thanatosused) {
queue = await RdDRollTables.getOmbre();
await this.update({ "data.reve.reve.thanatosused": false });
}
@@ -1113,7 +1114,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
getTMRRencontres() {
- return this.data.data.reve.rencontre.list;
+ return Misc.templateData(this).reve.rencontre.list;
}
/* -------------------------------------------- */
@@ -1137,7 +1138,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async deleteTMRRencontre(rencontreKey) {
- let list = duplicate(this.data.data.reve.rencontre.list);
+ let list = duplicate(Misc.templateData(this).reve.rencontre.list);
let newList = [];
for (let i = 0; i < list.length; i++) {
if (i != rencontreKey)
@@ -1153,14 +1154,14 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async reveActuelIncDec(value) {
- let reve = Math.max(this.data.data.reve.reve.value + value, 0);
+ let reve = Math.max(Misc.templateData(this).reve.reve.value + value, 0);
await this.update({ "data.reve.reve.value": reve });
}
/* -------------------------------------------- */
async updatePointDeSeuil(value = 1) {
- const seuil = Misc.toInt(this.data.data.reve.seuil.value);
- const reve = Misc.toInt(this.data.data.carac.reve.value);
+ const seuil = Misc.toInt(Misc.templateData(this).reve.seuil.value);
+ const reve = Misc.toInt(Misc.templateData(this).carac.reve.value);
if (seuil < reve) {
await this.setPointsDeSeuil(Math.min(seuil + value, reve));
}
@@ -1173,17 +1174,17 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setPointsDeChance(chance) {
- await this.update({ "data.compteurs.chance.value": chance });
+ await this.updateCompteurValue("chance", chance);
}
/* -------------------------------------------- */
getSonne() {
- return !this.isEntiteCauchemar() && (this.data.data.sante.sonne?.value ?? false);
+ return !this.isEntiteCauchemar() && (Misc.templateData(this).sante.sonne?.value ?? false);
}
/* -------------------------------------------- */
getSonneRound() {
- return !this.isEntiteCauchemar() && (this.data.data.sante.sonne?.round ?? false);
+ return !this.isEntiteCauchemar() && (Misc.templateData(this).sante.sonne?.round ?? false);
}
/* -------------------------------------------- */
@@ -1211,7 +1212,7 @@ export class RdDActor extends Actor {
if (this.isEntiteCauchemar()) {
return;
}
- let sonneData = duplicate(this.data.data.sante.sonne);
+ let sonneData = duplicate(Misc.templateData(this).sante.sonne);
sonneData.value = sonne;
sonneData.round = round;
await this.update({ "data.sante.sonne": sonneData });
@@ -1222,7 +1223,7 @@ export class RdDActor extends Actor {
if (this.isEntiteCauchemar()) {
return 0;
}
- return RdDCarac.calculSConst(this.data.data.carac.constitution.value);
+ return RdDCarac.calculSConst(Misc.templateData(this).carac.constitution.value);
}
/* -------------------------------------------- */
@@ -1246,7 +1247,7 @@ export class RdDActor extends Actor {
}
async ajoutXpConstitution(xp) {
- await this.update({ "data.carac.constitution.xp": Misc.toInt(this.data.data.carac.constitution.xp) + xp });
+ await this.update({ "data.carac.constitution.xp": Misc.toInt(Misc.templateData(this).carac.constitution.xp) + xp });
}
/* -------------------------------------------- */
@@ -1255,7 +1256,7 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
countBlessuresByName(name) {
- return this.countBlessures(this.data.data.blessures[name].liste);
+ return this.countBlessures(Misc.templateData(this).blessures[name].liste);
}
/* -------------------------------------------- */
@@ -1264,8 +1265,9 @@ export class RdDActor extends Actor {
myRoll.showDice = true;
await RdDDice.show(myRoll);
- let msgText = "Jet d'Endurance : " + myRoll.total + " / " + this.data.data.sante.endurance.value + "
";
- if (myRoll.total == 1 || (myRoll.total != 20 && myRoll.total <= this.data.data.sante.endurance.value)) {
+ const actorData = Misc.data(this);
+ let msgText = "Jet d'Endurance : " + myRoll.total + " / " + actorData.data.sante.endurance.value + "
";
+ if (myRoll.total == 1 || (myRoll.total != 20 && myRoll.total <= actorData.data.sante.endurance.value)) {
msgText += `${this.name} a réussi son Jet d'Endurance !`;
if (myRoll.total == 1) {
await this.ajoutXpConstitution();
@@ -1288,8 +1290,9 @@ export class RdDActor extends Actor {
myRoll.showDice = true;
await RdDDice.show(myRoll);
- let msgText = "Jet de Vie : " + myRoll.total + " / " + this.data.data.sante.vie.value + "
";
- if (myRoll.total <= this.data.data.sante.vie.value) {
+ const actorData = Misc.data(this);
+ let msgText = "Jet de Vie : " + myRoll.total + " / " + actorData.data.sante.vie.value + "
";
+ if (myRoll.total <= actorData.data.sante.vie.value) {
msgText += "Jet réussi, pas de perte de point de vie (prochain jet dans 1 round pour 1 critique, SC minutes pour une grave)";
if (myRoll.total == 1) {
msgText += "La durée entre 2 jets de vie est multipliée par 20 (20 rounds pour une critique, SCx20 minutes pour une grave)";
@@ -1311,7 +1314,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async santeIncDec(name, inc, isCritique = false) {
- const sante = duplicate(this.data.data.sante);
+ const sante = duplicate(Misc.templateData(this).sante);
let compteur = sante[name];
if (!compteur) {
return;
@@ -1361,29 +1364,30 @@ export class RdDActor extends Actor {
}
isDead() {
- return !this.isEntiteCauchemar() && this.data.data.sante.vie.value < -this.getSConst()
+ return !this.isEntiteCauchemar() && Misc.templateData(this).sante.vie.value < -this.getSConst()
}
/* -------------------------------------------- */
_computeFatigueMin() {
- return this.data.data.sante.endurance.max - this.data.data.sante.endurance.value;
+ return Misc.templateData(this).sante.endurance.max - Misc.templateData(this).sante.endurance.value;
}
/* -------------------------------------------- */
_computeEnduranceMax() {
- let blessures = this.data.data.blessures;
- let diffVie = this.data.data.sante.vie.max - this.data.data.sante.vie.value;
- let maxEndVie = this.data.data.sante.endurance.max - (diffVie * 2);
+ const actorData = Misc.data(this);
+ let blessures = actorData.data.blessures;
+ let diffVie = actorData.data.sante.vie.max - actorData.data.sante.vie.value;
+ let maxEndVie = actorData.data.sante.endurance.max - (diffVie * 2);
let nbGraves = this.countBlessures(blessures.graves.liste);
let nbCritiques = this.countBlessures(blessures.critiques.liste);
- let maxEndGraves = Math.floor(this.data.data.sante.endurance.max / (2 * nbGraves));
- let maxEndCritiques = nbCritiques > 0 ? 1 : this.data.data.sante.endurance.max;
+ let maxEndGraves = Math.floor(actorData.data.sante.endurance.max / (2 * nbGraves));
+ let maxEndCritiques = nbCritiques > 0 ? 1 : actorData.data.sante.endurance.max;
return Math.max(0, Math.min(maxEndVie, maxEndGraves, maxEndCritiques));
}
/* -------------------------------------------- */
async manageBlessureFromSheet(gravite, index) {
- let listBlessures = duplicate(this.data.data.blessures);
+ let listBlessures = duplicate(Misc.templateData(this).blessures);
let blessure = listBlessures[gravite + "s"].liste[index];
blessure.active = !blessure.active;
if (!blessure.active) {
@@ -1394,7 +1398,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setDataBlessureFromSheet(gravite, index, psoins, pcomplets, jours, loc) {
- let listBlessures = duplicate(this.data.data.blessures);
+ let listBlessures = duplicate(Misc.templateData(this).blessures);
let blessure = listBlessures[gravite + "s"].liste[index];
blessure.premiers_soins = psoins;
blessure.soins_complets = pcomplets;
@@ -1407,7 +1411,7 @@ export class RdDActor extends Actor {
async jetDeMoral(situation) {
let jetMoral = new Roll("1d20").roll();
RdDDice.show(jetMoral);
- let moralActuel = Misc.toInt(this.data.data.compteurs.moral.value);
+ let moralActuel = Misc.toInt(Misc.templateData(this).compteurs.moral.value);
const difficulte = 10 + moralActuel;
const succes = jetMoral.total <= difficulte;
@@ -1425,19 +1429,20 @@ export class RdDActor extends Actor {
async moralIncDec(ajustementMoral) {
if (ajustementMoral != 0) {
- let moral = Misc.toInt(this.data.data.compteurs.moral.value) + ajustementMoral
+ const actorData = Misc.data(this);
+ let moral = Misc.toInt(actorData.data.compteurs.moral.value) + ajustementMoral
if (moral > 3) { // exaltation
- const exaltation = Misc.toInt(this.data.data.compteurs.exaltation.value) + moral - 3;
- await this.update({ 'data.compteurs.exaltation.value': exaltation });
+ const exaltation = Misc.toInt(actorData.data.compteurs.exaltation.value) + moral - 3;
+ await this.updateCompteurValue('exaltation', exaltation);
}
if (moral < -3) { // dissolution
- const dissolution = Misc.toInt(this.data.data.compteurs.dissolution.value) + 3 - moral;
- await this.update({ 'data.compteurs.dissolution.value': dissolution });
+ const dissolution = Misc.toInt(actorData.data.compteurs.dissolution.value) + 3 - moral;
+ await this.updateCompteurValue('dissolution', dissolution);
}
moral = Math.max(-3, Math.min(moral, 3));
- await this.update({ 'data.compteurs.moral.value': moral });
+ await this.updateCompteurValue('moral', moral);
}
- return this.data.data.compteurs.moral.value;
+ return actorData.data.compteurs.moral.value;
}
/* -------------------------------------------- */
@@ -1454,7 +1459,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setEthylisme(degre) {
- let ethylisme = duplicate(this.data.data.compteurs.ethylisme);
+ let ethylisme = duplicate(Misc.templateData(this).compteurs.ethylisme);
ethylisme.value = degre;
ethylisme.nb_doses = 0;
if (degre == 1) {
@@ -1465,10 +1470,11 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ethylismeTest() {
+ const actorData = Misc.data(this);
let rollData = {
- vieValue: this.data.data.sante.vie.value,
- etat: this.getEtatGeneral() - Math.min(0, this.data.data.compteurs.ethylisme.value), // Pour les jets d'Ethylisme, on ignore le degré d'éthylisme (p.162)
- diffNbDoses: -Number(this.data.data.compteurs.ethylisme.nb_doses || 0),
+ vieValue: actorData.data.sante.vie.value,
+ etat: this.getEtatGeneral() - Math.min(0, actorData.data.compteurs.ethylisme.value), // Pour les jets d'Ethylisme, on ignore le degré d'éthylisme (p.162)
+ diffNbDoses: -Number(actorData.data.compteurs.ethylisme.nb_doses || 0),
finalLevel: 0,
diffConditions: 0,
ajustementsConditions: CONFIG.RDD.ajustementsConditions,
@@ -1480,7 +1486,8 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async performEthylisme(rollData) {
- let ethylisme = duplicate(this.data.data.compteurs.ethylisme);
+ const actorData = Misc.data(this);
+ let ethylisme = duplicate(actorData.data.compteurs.ethylisme);
// Je d'ethylisme
let rollEthylisme = await RdDResolutionTable.roll(rollData.vieValue, rollData.finalLevel);
@@ -1496,7 +1503,7 @@ export class RdDActor extends Actor {
await this.santeIncDec("endurance", -enduranceLost);
const ajustementEthylique = ethylisme.value;
// Qui a bu boira (p 164)
- let rollVolonte = await RdDResolutionTable.roll(this.data.data.carac.volonte.value, Math.min(ajustementEthylique, 0) + this.data.data.compteurs.moral.value);
+ let rollVolonte = await RdDResolutionTable.roll(actorData.data.carac.volonte.value, Math.min(ajustementEthylique, 0) + actorData.data.compteurs.moral.value);
const quiABuBoira = (rollVolonte.isSuccess
? "vous êtes libre de continuer à boire ou pas."
: "vous avez une envie irrépréssible de reprendre un verre.");
@@ -1538,7 +1545,8 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async transformerStress() {
- const stress = Misc.toInt(this.data.data.compteurs.stress.value);
+ const actorData = Misc.data(this);
+ const stress = Misc.toInt(actorData.data.compteurs.stress.value);
if (stress <= 0) {
return;
}
@@ -1546,8 +1554,8 @@ export class RdDActor extends Actor {
const stressRoll = await this._stressRoll(this.getReveActuel());
const conversion = Math.floor(stress * stressRoll.factor / 100);
- let dissolution = Math.max(0, Misc.toInt(this.data.data.compteurs.dissolution.value));
- let exaltation = Math.max(0, Misc.toInt(this.data.data.compteurs.exaltation.value));
+ let dissolution = Math.max(0, Misc.toInt(actorData.data.compteurs.dissolution.value));
+ let exaltation = Math.max(0, Misc.toInt(actorData.data.compteurs.exaltation.value));
const annule = Math.min(dissolution, exaltation);
dissolution -= annule;
exaltation -= annule;
@@ -1555,7 +1563,7 @@ export class RdDActor extends Actor {
let stressRollData = {
alias: this.name,
- selectedCarac: this.data.data.carac.reve,
+ selectedCarac: actorData.data.carac.reve,
rolled: stressRoll,
stress: stress,
perte: Math.min(conversion, stress),
@@ -1570,7 +1578,7 @@ export class RdDActor extends Actor {
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.html`, stressRollData)
});
- let compteurs = duplicate(this.data.data.compteurs);
+ let compteurs = duplicate(actorData.data.compteurs);
compteurs.stress.value = Math.max(stress - stressRollData.perte - 1, 0);
compteurs.experience.value += stressRollData.xp;
compteurs.dissolution.value = dissolution - perteDissolution;
@@ -1623,7 +1631,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async checkCaracXP(caracName) {
- let carac = this.data.data.carac[caracName];
+ let carac = Misc.templateData(this).carac[caracName];
if (carac && carac.xp > 0) {
let xpNeeded = RdDCarac.getCaracNextXp(carac.value + 1);
if (carac.xp >= xpNeeded) {
@@ -1731,7 +1739,7 @@ export class RdDActor extends Actor {
let bestDraconic = this.getBestDraconic();
for (let sort of sortList) {
let voie = sort.data.draconic.toLowerCase();
- let draconic = draconicList.find(item => item.data.categorie == 'draconic' && item.name.toLowerCase().includes(voie));
+ let draconic = draconicList.find(it => it.data.categorie == 'draconic' && it.name.toLowerCase().includes(voie));
if (sort.name.toLowerCase().includes('aura')) {
draconic = bestDraconic;
}
@@ -1765,17 +1773,18 @@ export class RdDActor extends Actor {
if (this.currentTMR) this.currentTMR.minimize(); // Hide
let draconicList = this.filterDraconicList(sortList);
+ const actorData = Misc.data(this);
let rollData = {
- forceCarac: { 'reve': duplicate(this.data.data.carac.reve) },
- selectedCarac: duplicate(this.data.data.carac.reve),
+ forceCarac: { 'reve': duplicate(actorData.data.carac.reve) },
+ selectedCarac: duplicate(actorData.data.carac.reve),
draconicList: draconicList,
sortList: sortList,
competence: draconicList[0],
selectedSort: sortList[0],
tmr: TMRUtility.getTMR(coord),
diffLibre: sortList[0].data.difficulte, // Per default at startup
- coutreve: Array(20).fill().map((item, index) => 1 + index),
- carac: { 'reve': duplicate(this.data.data.carac.reve) }
+ coutreve: Array(30).fill().map((item, index) => 1 + index),
+ carac: { 'reve': duplicate(actorData.data.carac.reve) }
}
if (this.currentTMR) this.currentTMR.minimize(); // Hide
@@ -1863,7 +1872,7 @@ export class RdDActor extends Actor {
rollData.show = {}
rollData.depenseReve = Number(selectedSort.data.ptreve_reel);
- let myReve = duplicate(this.data.data.reve.reve);
+ let reveActuel = Misc.templateData(this).reve.reve.value;
if (rolled.isSuccess) { // Réussite du sort !
if (rolled.isPart) {
rollData.depenseReve = Math.max(Math.floor(rollData.depenseReve / 2), 1);
@@ -1872,9 +1881,9 @@ export class RdDActor extends Actor {
rollData.depenseReve++;
}
if (rollData.competence.name.includes('Thanatos')) { // Si Thanatos
- myReve.thanatosused = true;
+ await this.update({ "data.reve.reve.thanatosused": true });
}
- if (myReve.value > rollData.depenseReve) {
+ if (reveActuel > rollData.depenseReve) {
// Incrémenter/gére le bonus de case
RdDItemSort.incrementBonusCase(this, selectedSort, rollData.tmr.coord);
@@ -1890,15 +1899,15 @@ export class RdDActor extends Actor {
}
} else {
if (rolled.isETotal) { // Echec total !
- rollData.depenseReve = Math.min(myReve.value, Math.floor(rollData.depenseReve * 1.5))
+ rollData.depenseReve = Math.min(reveActuel, Math.floor(rollData.depenseReve * 1.5))
// TODO: mise en réserve d'un échec total...
} else {
rollData.depenseReve = 0
}
}
- myReve.value = Math.max(myReve.value - rollData.depenseReve, 0);
- await this.update({ "data.reve.reve": myReve });
+ reveActuel = Math.max(reveActuel - rollData.depenseReve, 0);
+ await this.update({ "data.reve.reve.value": reveActuel });
if (closeTMR) {
this.currentTMR.close(); // Close TMR !
@@ -1908,7 +1917,7 @@ export class RdDActor extends Actor {
// Final chat message
RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-sort.html');
- if (myReve.value == 0) { // 0 points de reve
+ if (reveActuel == 0) { // 0 points de reve
ChatMessage.create({ content: this.name + " est réduit à 0 Points de Rêve, et tombe endormi !" });
closeTMR = true;
}
@@ -1953,7 +1962,7 @@ export class RdDActor extends Actor {
RdDItemCompetenceCreature.setRollDataCreature(rollData);
}
else {
- rollData.carac = this.data.data.carac;
+ rollData.carac = Misc.templateData(this).carac;
}
console.log("rollCompetence !!!", rollData);
@@ -1971,18 +1980,18 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async creerTacheDepuisLivre(item) {
+ const itemData = Misc.data(item);
let tache = {
name: "Lire " + item.name, type: 'tache',
data: {
carac: 'intellect',
competence: 'Ecriture',
- difficulte: item.data.data.difficulte,
+ difficulte: itemData.data.difficulte,
periodicite: "60 minutes",
fatigue: 2,
- points_de_tache: item.data.data.points_de_tache,
+ points_de_tache: itemData.data.points_de_tache,
points_de_tache_courant: 0,
- description: "Lecture du livre " + item.name +
- " - XP : " + item.data.data.xp + " - Compétences : " + item.data.data.competence
+ description: "Lecture du livre " + item.name + " - XP : " + itemData.data.xp + " - Compétences : " + itemData.data.competence
}
}
await this.createOwnedItem(tache, { renderSheet: true });
@@ -2000,7 +2009,7 @@ export class RdDActor extends Actor {
use: { libre: false, conditions: false },
carac: {}
};
- rollData.carac[tache.data.carac] = duplicate(this.data.data.carac[tache.data.carac]); // Single carac
+ rollData.carac[tache.data.carac] = duplicate(Misc.templateData(this).carac[tache.data.carac]); // Single carac
console.log("rollTache !!!", rollData);
@@ -2035,6 +2044,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _rollArt(artData, selected, oeuvre, callBackResult = r => this._resultArt(r)) {
+ const actorData = Misc.data(this);
mergeObject(artData, {
oeuvre: oeuvre,
art: oeuvre.type,
@@ -2042,12 +2052,12 @@ export class RdDActor extends Actor {
diffLibre: - (oeuvre.data.niveau ?? 0),
diffConditions: 0,
use: { libre: false, conditions: true },
- selectedCarac: duplicate(this.data.data.carac[selected])
+ selectedCarac: duplicate(actorData.data.carac[selected])
});
artData.competence.data.defaut_carac = selected;
if (!artData.forceCarac) {
artData.forceCarac = {};
- artData.forceCarac[selected] = duplicate(this.data.data.carac[selected]);
+ artData.forceCarac[selected] = duplicate(actorData.data.carac[selected]);
}
console.log("rollArt !!!", artData);
@@ -2083,14 +2093,15 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async rollDanse(id) {
+ const actorData = Misc.data(this);
const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
const oeuvre = duplicate(this.getOeuvre(id, artData.art));
const selectedCarac = this._getCaracDanse(oeuvre);
if (oeuvre.data.agilite) {
- artData.forceCarac['agilite'] = duplicate(this.data.data.carac.agilite);
+ artData.forceCarac['agilite'] = duplicate(actorData.data.carac.agilite);
}
if (oeuvre.data.apparence) {
- artData.forceCarac['apparence'] = duplicate(this.data.data.carac.apparence);
+ artData.forceCarac['apparence'] = duplicate(actorData.data.carac.apparence);
}
await this._rollArt(artData, selectedCarac, oeuvre);
}
@@ -2160,7 +2171,7 @@ export class RdDActor extends Actor {
use: { libre: false, conditions: true, },
carac: {}
};
- meditationData.carac["intellect"] = duplicate(this.data.data.carac["intellect"]);
+ meditationData.carac["intellect"] = duplicate(Misc.templateData(this).carac["intellect"]);
console.log("rollMeditation !!!", meditationData);
@@ -2238,21 +2249,20 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async chanceActuelleIncDec(value, limit = true) {
- let chance = duplicate(this.data.data.compteurs.chance);
- chance.value = Math.max(chance.value + value, 0);
+ chance = Math.max(Misc.templateData(this).compteurs.chance.value + value, 0);
if (limit) {
- chance.value = Math.min(chance.value, this.getChance())
+ chance = Math.min(chance.value, this.getChance())
}
- await this.update({ "data.compteurs.chance": chance });
+ await this.updateCompteurValue("chance", chance);
}
/* -------------------------------------------- */
async appelDestinee(onSuccess = () => { }, onEchec = () => { }) {
- if (this.data.data.compteurs.destinee?.value ?? 0 > 0) {
+ let destinee = Misc.templateData(this).compteurs.destinee?.value ?? 0;
+ if (destinee > 0) {
ChatMessage.create({ content: `${this.name} a fait appel à la Destinée !` });
- let destinee = duplicate(this.data.data.compteurs.destinee);
- destinee.value = destinee.value - 1;
- await this.update({ "data.compteurs.destinee": destinee });
+ destinee--;
+ await this.updateCompteurValue( "destinee", destinee);
onSuccess();
}
else {
@@ -2266,8 +2276,9 @@ export class RdDActor extends Actor {
if (this.isCreature()) {
return 0;
}
+ const actorData = Misc.data(this);
// selon l'heure de naissance...
- return game.system.rdd.calendrier.getAjustementAstrologique(this.data.data.heure, this.data.name);
+ return game.system.rdd.calendrier.getAjustementAstrologique(actorData.data.heure, this.name);
}
/* -------------------------------------------- */
checkDesirLancinant() {
@@ -2301,7 +2312,7 @@ export class RdDActor extends Actor {
xpCarac = Math.max(xpCarac, 1);
}
if (xpCarac > 0) {
- let carac = duplicate(this.data.data.carac);
+ let carac = duplicate(Misc.templateData(this).carac);
let selectedCarac = RdDActor._findCaracByName(carac, caracName);
if (!selectedCarac.derivee) {
selectedCarac.xp = Misc.toInt(selectedCarac.xp) + xpCarac;
@@ -2322,7 +2333,7 @@ export class RdDActor extends Actor {
async ajouteNombreAstral(data) {
// Gestion expérience (si existante)
data.competence = RdDItemCompetence.findCompetence(this.data.items, "astrologie");
- data.selectedCarac = this.data.data.carac["vue"];
+ data.selectedCarac = Misc.templateData(this).carac["vue"];
this._appliquerAjoutExperience(data);
// Ajout du nombre astral
@@ -2333,8 +2344,8 @@ export class RdDActor extends Actor {
await this.createEmbeddedEntity("OwnedItem", item);
// Suppression des anciens nombres astraux
- let toDelete = this.data.items.filter((item) => item.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
- const deletions = toDelete.map(i => i._id);
+ let toDelete = this.data.items.filter(it => it.data.jourindex < game.system.rdd.calendrier.getCurrentDayIndex());
+ const deletions = toDelete.map(it => it._id);
await this.deleteEmbeddedEntity("OwnedItem", deletions);
// Affichage Dialog
@@ -2364,7 +2375,7 @@ export class RdDActor extends Actor {
type: "number"
};
}
- return RdDActor._findCaracByName(this.data.data.carac, caracName);
+ return RdDActor._findCaracByName(Misc.templateData(this).carac, caracName);
}
/* -------------------------------------------- */
@@ -2386,17 +2397,17 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
getSortList() {
- return this.data.items.filter(item => item.type == "sort");
+ return this.data.items.filter(it => it.type == "sort");
}
/* -------------------------------------------- */
getDraconicList() {
- return this.data.items.filter(item => item.data.categorie == 'draconic')
+ return this.data.items.filter(it => it.data.categorie == 'draconic')
}
/* -------------------------------------------- */
countMonteeLaborieuse() { // Return +1 par queue/ombre/souffle Montée Laborieuse présente
- let countMonteeLaborieuse = this.data.items.filter(item => EffetsDraconiques.isMonteeLaborieuse(item)).length;
+ let countMonteeLaborieuse = this.data.items.filter(it => EffetsDraconiques.isMonteeLaborieuse(it)).length;
if (countMonteeLaborieuse > 0) {
ChatMessage.create({
content: `Vous êtes sous le coup d'une Montée Laborieuse : vos montées en TMR coûtent ${countMonteeLaborieuse} Point de Rêve de plus.`,
@@ -2428,26 +2439,29 @@ export class RdDActor extends Actor {
}
}
- let data = {
+ const actorData = Misc.data(this);
+ const fatigue = actorData.data.sante.fatigue.value;
+ const endurance = actorData.data.sante.endurance.max;
+ let tmrFormData = {
mode: mode,
fatigue: {
- malus: RdDUtility.calculMalusFatigue(this.data.data.sante.fatigue.value, this.data.data.sante.endurance.max),
- html: "" + RdDUtility.makeHTMLfatigueMatrix(this.data.data.sante.fatigue.value, this.data.data.sante.endurance.max).html() + "
"
+ malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
+ html: "" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "
"
},
draconic: this.getDraconicList(),
sort: this.getSortList(),
- caracReve: this.data.data.carac.reve.value,
+ caracReve: actorData.data.carac.reve.value,
pointsReve: this.getReveActuel(),
isRapide: isRapide
}
- let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html', data);
- this.currentTMR = await RdDTMRDialog.create(html, this, data);
+ let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html', tmrFormData);
+ this.currentTMR = await RdDTMRDialog.create(html, this, tmrFormData);
this.currentTMR.render(true);
}
/* -------------------------------------------- */
rollArme(compName, armeName = undefined) {
- let arme = armeName ? this.data.items.find(item => item.name == armeName && RdDItemArme.isArme(item)) : undefined;
+ let arme = armeName ? this.data.items.find(it => it.name == armeName && RdDItemArme.isArme(it)) : undefined;
let competence = this.getCompetence(compName);
if (arme || armeName || (competence.type == 'competencecreature' && competence.data.iscombat)) {
@@ -2474,11 +2488,12 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
- verifierForceMin(item) {
- if (item.type == 'arme' && item.data.force > this.data.data.carac.force.value) {
+ verifierForceMin(itemData) {
+ const actorData = Misc.data(this);
+ if (itemData.type == 'arme' && itemData.data.force > actorData.data.carac.force.value) {
ChatMessage.create({
- content: `${this.name} s'est équipé(e) de l'arme ${item.name}, mais n'a pas une force suffisante pour l'utiliser normalement
- (${item.data.force} nécessaire pour une Force de ${this.data.data.carac.force.value})`
+ content: `${this.name} s'est équipé(e) de l'arme ${itemData.name}, mais n'a pas une force suffisante pour l'utiliser normalement
+ (${itemData.data.force} nécessaire pour une Force de ${actorData.data.carac.force.value})`
});
}
}
@@ -2486,30 +2501,32 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async equiperObjet(itemID) {
let item = this.getOwnedItem(itemID);
- if (item && item.data.data) {
- let update = { _id: item._id, "data.equipe": !item.data.data.equipe };
+ if (item?.data?.data) {
+ let itemData = Misc.itemData(item);
+ const isEquipe = !itemData.data.equipe;
+ let update = { _id: item._id, "data.equipe": isEquipe };
await this.updateEmbeddedEntity("OwnedItem", update);
this.computeEncombrementTotalEtMalusArmure(); // Mise à jour encombrement
this.computePrixTotalEquipement(); // Mis à jour du prix total de l'équipement
- if (item.data.data.equipe)
- this.verifierForceMin(item.data);
+ if (isEquipe)
+ this.verifierForceMin(itemData);
}
}
/* -------------------------------------------- */
computeArmure(attackerRoll) {
let dmg = (attackerRoll.dmg.dmgArme ?? 0) + (attackerRoll.dmg.dmgActor ?? 0);
- let arme = attackerRoll.arme;
+ let armeData = attackerRoll.arme;
let protection = 0;
const armures = this.data.items.filter(it => it.type == "armure" && it.data.equipe);
- for (const item of armures) {
- protection += new Roll(item.data.protection.toString()).roll().total;
+ for (const itemData of armures) {
+ protection += new Roll(itemData.data.protection.toString()).roll().total;
if (dmg > 0) {
- this._deteriorerArmure(item, dmg);
+ this._deteriorerArmure(itemData, dmg);
dmg = 0;
}
}
- const penetration = arme ? Misc.toInt(arme.data.penetration) : 0;
+ const penetration = armeData ? Misc.toInt(armeData.data.penetration) : 0;
protection = Math.max(protection - penetration, 0);
protection += this.getProtectionNaturelle();
// Gestion des cas particuliers sur la fenêtre d'encaissement
@@ -2528,24 +2545,24 @@ export class RdDActor extends Actor {
if (!ReglesOptionelles.isUsing('deteriorationArmure')) {
return;
}
- let update = duplicate(item);
- update.data.deterioration = (update.data.deterioration ?? 0) + dmg;
- if (update.data.deterioration >= 10) {
- update.data.deterioration = 0;
- let res = /\d+/.exec(update.data.protection);
+ let itemData = duplicate(Misc.itemData(item));
+ itemData.data.deterioration = (itemData.data.deterioration ?? 0) + dmg;
+ if (itemData.data.deterioration >= 10) {
+ itemData.data.deterioration = 0;
+ let res = /\d+/.exec(itemData.data.protection);
if (!res) {
- update.data.protection = "1d" + update.data.protection;
+ itemData.data.protection = "1d" + itemData.data.protection;
}
- else if (res = /(\d+d\d+)(\-\d+)?/.exec(update.data.protection)) {
+ else if (res = /(\d+d\d+)(\-\d+)?/.exec(itemData.data.protection)) {
let malus = Misc.toInt(res[2]) - 1;
- update.data.protection = res[1] + malus;
+ itemData.data.protection = res[1] + malus;
}
else {
ui.notifications.warn(`La valeur d'armure de votre ${item.name} est incorrecte`);
}
- ChatMessage.create({ content: "Votre armure s'est détériorée, elle protège maintenant de " + update.data.protection });
+ ChatMessage.create({ content: "Votre armure s'est détériorée, elle protège maintenant de " + itemData.data.protection });
}
- this.updateEmbeddedEntity("OwnedItem", update);
+ this.updateEmbeddedEntity("OwnedItem", itemData);
}
/* -------------------------------------------- */
@@ -2563,7 +2580,7 @@ export class RdDActor extends Actor {
console.log("encaisserDommages", rollData)
- let santeOrig = duplicate(this.data.data.sante);
+ let santeOrig = duplicate(Misc.templateData(this).sante);
let encaissement = this.jetEncaissement(rollData);
this.ajouterBlessure(encaissement); // Will upate the result table
@@ -2575,10 +2592,11 @@ export class RdDActor extends Actor {
this.computeEtatGeneral();
this.sheet.render(false);
+ const actorData = Misc.data(this);
mergeObject(encaissement, {
- alias: this.data.name,
+ alias: this.name,
hasPlayerOwner: this.hasPlayerOwner,
- resteEndurance: this.data.data.sante.endurance.value,
+ resteEndurance: actorData.data.sante.endurance.value,
sonne: perteEndurance.sonne,
jetEndurance: perteEndurance.jetEndurance,
endurance: santeOrig.endurance.value - perteEndurance.newValue,
@@ -2627,12 +2645,12 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
ajouterBlessure(encaissement) {
- // Fast exit
- if (this.data.type == 'entite') return; // Une entité n'a pas de blessures
+ const actorData = Misc.data(this);
+ if (actorData.type == 'entite') return; // Une entité n'a pas de blessures
if (encaissement.legeres + encaissement.graves + encaissement.critiques == 0) return;
- const endActuelle = Number(this.data.data.sante.endurance.value);
- let blessures = duplicate(this.data.data.blessures);
+ const endActuelle = Number(actorData.data.sante.endurance.value);
+ let blessures = duplicate(actorData.data.blessures);
let count = encaissement.legeres;
// Manage blessures
@@ -2741,11 +2759,12 @@ export class RdDActor extends Actor {
}
let rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(entite.data.data.carac.niveau.value));
+ const actorData = Misc.data(this);
const rollData = {
alias: this.name,
rolled: rolled,
entite: entite.name,
- selectedCarac: this.data.data.carac.reve
+ selectedCarac: actorData.data.carac.reve
};
if (rolled.isSuccess) {
@@ -2767,7 +2786,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
isEntiteCauchemarAccordee(attaquant) {
if (!this.isEntiteCauchemar()) { return true; }
- let resonnance = this.data.data.sante.resonnance;
+ let resonnance = Misc.templateData(this).sante.resonnance;
return (resonnance.actors.find(it => it == attaquant._id));
}
@@ -2777,7 +2796,7 @@ export class RdDActor extends Actor {
ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entite de cauchemer/rêve");
return;
}
- let resonnance = duplicate(this.data.data.sante.resonnance);
+ let resonnance = duplicate(Misc.templateData(this).sante.resonnance);
if (resonnance.actors.find(it => it == attaquant._id)) {
// déjà accordé
return;
@@ -2813,8 +2832,7 @@ export class RdDActor extends Actor {
sumDenier = Number(sumDenier);
let denierDisponible = 0;
- let monnaie = this.data.items.filter(item => item.type == 'monnaie');
- for (let piece of monnaie) {
+ for (let piece of monnaies) {
denierDisponible += piece.data.valeur_deniers * Number(piece.data.quantite);
}
console.log("DENIER", game.user.character, sumDenier, denierDisponible);
@@ -2856,6 +2874,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async effectuerTacheAlchimie(recetteId, alchimieName, alchimieData) {
let recette = this.data.items.find(item => item.type == 'recettealchimique' && item._id == recetteId);
+ const actorData = Misc.data(this);
if (recette) {
let competence = this.data.items.find(item => item.type == 'competence' && item.name.toLowerCase() == "alchimie");
let diffAlchimie = RdDAlchimie.getDifficulte(alchimieData);
@@ -2865,10 +2884,10 @@ export class RdDActor extends Actor {
diffLibre: diffAlchimie // Per default at startup
}
if (alchimieName == "couleur") {
- rollData.selectedCarac = this.data.data.carac.vue,
+ rollData.selectedCarac = actorData.data.carac.vue,
rollData.alchimieTexte = `Couleurs ${alchimieData} (${diffAlchimie}) (Malus de -4 si vous ne possédez pas de Cristal Alchimique)`;
} else {
- rollData.selectedCarac = this.data.data.carac.dexterite,
+ rollData.selectedCarac = actorData.data.carac.dexterite,
rollData.alchimieTexte = `Consistances ${alchimieData} (${diffAlchimie})`;
}
@@ -2897,8 +2916,9 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
listeVehicules() {
+ const actorData = Misc.data(this);
return this._buildActorLinksList(
- this.data.data.subacteurs?.vehicules ?? [],
+ actorData.data.subacteurs?.vehicules ?? [],
vehicle => {
return {
id: vehicle.id, name: vehicle.data.name, categorie: vehicle.data.data.categorie,
@@ -2909,12 +2929,12 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
listeSuivants() {
- return this._buildActorLinksList(this.data.data.subacteurs?.suivants ?? []);
+ return this._buildActorLinksList(Misc.templateData(this).subacteurs?.suivants ?? []);
}
/* -------------------------------------------- */
listeMontures() {
- return this._buildActorLinksList(this.data.data.subacteurs?.montures ?? []);
+ return this._buildActorLinksList(Misc.templateData(this).subacteurs?.montures ?? []);
}
_buildActorLinksList(links, actorTransformation = it => { return { id: it.id, name: it.data.name, img: it.data.img }; }) {
@@ -2936,16 +2956,17 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
- addSubacteur(actorId) {
- let actor = game.actors.get(actorId);
+ addSubacteur(subActorId) {
+ let subActor = game.actors.get(subActorId);
//console.log("Ajout acteur : ", actor, this);
- if (actor && actor.owner) {
- if (actor.data.type == 'vehicule') {
- this.pushSubacteur(actor, this.data.data.subacteurs.vehicules, 'data.subacteurs.vehicules', 'Ce Véhicule');
- } else if (actor.data.type == 'creature') {
- this.pushSubacteur(actor, this.data.data.subacteurs.montures, 'data.subacteurs.montures', 'Cette Monture');
- } else if (actor.data.type == 'personnage') {
- this.pushSubacteur(actor, this.data.data.subacteurs.suivants, 'data.subacteurs.suivants', 'Ce Suivant');
+ if (subActor && subActor.owner) {
+ const actorData = Misc.data(this);
+ if (subActor.data.type == 'vehicule') {
+ this.pushSubacteur(subActor, actorData.data.subacteurs.vehicules, 'data.subacteurs.vehicules', 'Ce Véhicule');
+ } else if (subActor.data.type == 'creature') {
+ this.pushSubacteur(subActor, actorData.data.subacteurs.montures, 'data.subacteurs.montures', 'Cette Monture');
+ } else if (subActor.data.type == 'personnage') {
+ this.pushSubacteur(subActor, actorData.data.subacteurs.suivants, 'data.subacteurs.suivants', 'Ce Suivant');
}
} else {
ui.notifications.warn("Vous n'avez pas les droits sur l'acteur que vous attachez.")
@@ -2954,9 +2975,10 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async removeSubacteur(actorId) {
- let newVehicules = this.data.data.subacteurs.vehicules.filter(function (obj, index, arr) { return obj.id != actorId });
- let newSuivants = this.data.data.subacteurs.suivants.filter(function (obj, index, arr) { return obj.id != actorId });
- let newMontures = this.data.data.subacteurs.montures.filter(function (obj, index, arr) { return obj.id != actorId });
+ const actorData = Misc.data(this);
+ let newVehicules = actorData.data.subacteurs.vehicules.filter(function (obj, index, arr) { return obj.id != actorId });
+ let newSuivants = actorData.data.subacteurs.suivants.filter(function (obj, index, arr) { return obj.id != actorId });
+ let newMontures = actorData.data.subacteurs.montures.filter(function (obj, index, arr) { return obj.id != actorId });
await this.update({ 'data.subacteurs.vehicules': newVehicules });
await this.update({ 'data.subacteurs.suivants': newSuivants });
await this.update({ 'data.subacteurs.montures': newMontures });
diff --git a/module/item-arme.js b/module/item-arme.js
index 0d6ea65d..638a4320 100644
--- a/module/item-arme.js
+++ b/module/item-arme.js
@@ -1,4 +1,5 @@
import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
+import { Misc } from "./misc.js";
import { RdDCombatManager } from "./rdd-combat.js";
const nomCategorieParade = {
@@ -17,16 +18,18 @@ const nomCategorieParade = {
/* -------------------------------------------- */
export class RdDItemArme extends Item {
- static isArme(item) {
- return (item.type == 'competencecreature' && item.data.iscombat) || item.type == 'arme';
+ static isArme(itemData) {
+ itemData = Misc.data(itemData);
+ return (itemData.type == 'competencecreature' && itemData.data.iscombat) || itemData.type == 'arme';
}
/* -------------------------------------------- */
- static getArmeData(item) {
- switch (item ? item.data.type : '') {
- case 'arme': return item.data;
+ static getArmeData(armeData) {
+ armeData = Misc.data(armeData);
+ switch (armeData ? armeData.type : '') {
+ case 'arme': return armeData;
case 'competencecreature':
- return RdDItemCompetenceCreature.toArme(item.data);
+ return RdDItemCompetenceCreature.toArme(armeData);
}
return RdDItemArme.mainsNues();
}
@@ -61,21 +64,22 @@ export class RdDItemArme extends Item {
}
/* -------------------------------------------- */
- static getCategorieParade(arme) {
- if (arme.data.categorie_parade) {
- return arme.data.categorie_parade;
+ static getCategorieParade(armeData) {
+ armeData = Misc.data(armeData);
+ if (armeData.data.categorie_parade) {
+ return armeData.data.categorie_parade;
}
// pour compatibilité avec des personnages existants
- if (arme.type == 'competencecreature' || arme.data.categorie == 'creature') {
- return arme.data.categorie_parade || (arme.data.isparade ? 'sans-armes' : '');
+ if (armeData.type == 'competencecreature' || armeData.data.categorie == 'creature') {
+ return armeData.data.categorie_parade || (armeData.data.isparade ? 'sans-armes' : '');
}
- if (!arme.type.match(/arme|competencecreature/)) {
+ if (!armeData.type.match(/arme|competencecreature/)) {
return '';
}
- if (arme.data.competence == undefined) {
+ if (armeData.data.competence == undefined) {
return 'competencecreature';
}
- let compname = arme.data.competence.toLowerCase();
+ let compname = armeData.data.competence.toLowerCase();
if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';
if (compname.match('hache')) return 'haches';
@@ -84,9 +88,9 @@ export class RdDItemArme extends Item {
if (compname.match('bouclier')) return 'boucliers';
if (compname.match('masse')) return 'masses';
if (compname.match('epée') || compname.match('épée')) {
- if (arme.name.toLowerCase().match(/(gnome)/))
+ if (armeData.name.toLowerCase().match(/(gnome)/))
return 'epees-courtes';
- if (arme.name.toLowerCase().match(/((e|é)pée dragone|esparlongue|demi-dragonne)/))
+ if (armeData.name.toLowerCase().match(/((e|é)pée dragone|esparlongue|demi-dragonne)/))
return 'epees-longues';
return 'epees-lourdes';
}
@@ -131,33 +135,35 @@ export class RdDItemArme extends Item {
}
/* -------------------------------------------- */
- static armeUneOuDeuxMains(arme, aUneMain) {
- if (arme) {
- arme.data.unemain = arme.data.unemain || !arme.data.deuxmains;
- const uneOuDeuxMains = arme.data.unemain && arme.data.deuxmains;
- const containsSlash = !Number.isInteger(arme.data.dommages) && arme.data.dommages.includes("/");
+ static armeUneOuDeuxMains(armeData, aUneMain) {
+ armeData = Misc.data(armeData);
+ if (armeData) {
+ armeData.data.unemain = armeData.data.unemain || !armeData.data.deuxmains;
+ const uneOuDeuxMains = armeData.data.unemain && armeData.data.deuxmains;
+ const containsSlash = !Number.isInteger(armeData.data.dommages) && armeData.data.dommages.includes("/");
if (containsSlash) { // Sanity check
- arme = duplicate(arme);
+ armeData = duplicate(armeData);
- const tableauDegats = arme.data.dommages.split("/");
+ const tableauDegats = armeData.data.dommages.split("/");
if (aUneMain)
- arme.data.dommagesReels = Number(tableauDegats[0]);
+ armeData.data.dommagesReels = Number(tableauDegats[0]);
else // 2 mains
- arme.data.dommagesReels = Number(tableauDegats[1]);
+ armeData.data.dommagesReels = Number(tableauDegats[1]);
}
else {
- arme.data.dommagesReels = Number(arme.data.dommages);
+ armeData.data.dommagesReels = Number(armeData.data.dommages);
}
if (uneOuDeuxMains != containsSlash) {
- ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
+ ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
}
}
- return arme;
+ return armeData;
}
- static isArmeUtilisable(item) {
- return item.type == 'arme' && item.data.equipe && (item.data.resistance > 0 || item.data.portee_courte > 0);
+ static isArmeUtilisable(itemData) {
+ itemData = Misc.data(itemData);
+ return itemData.type == 'arme' && itemData.data.equipe && (itemData.data.resistance > 0 || itemData.data.portee_courte > 0);
}
static ajoutCorpsACorps(armes, competences, carac) {
diff --git a/module/item-competence.js b/module/item-competence.js
index 98a422f6..a399e6fd 100644
--- a/module/item-competence.js
+++ b/module/item-competence.js
@@ -148,7 +148,7 @@ export class RdDItemCompetence extends Item {
static computeCompetenceXPCost(competence) {
let xp = RdDItemCompetence.getDeltaXp(competence.data.base, competence.data.niveau ?? competence.data.base);
xp += competence.data.xp ?? 0;
- if ( competence.name.includes('Thanatos') ) xp *= 2; /// Thanatos compte double !
+ if (competence.name.includes('Thanatos')) xp *= 2; /// Thanatos compte double !
xp += competence.data.xp_sort ?? 0;
return xp;
}
@@ -158,33 +158,33 @@ export class RdDItemCompetence extends Item {
let economie = 0;
for (let troncList of competenceTroncs) {
let list = troncList.map(name => RdDItemCompetence.findCompetence(competences, name))
- .sort( (c1, c2) => c2.data.niveau - c1.data.niveau); // tri du plus haut au plus bas
- list.splice(0,1); // ignorer la plus élevée
+ .sort((c1, c2) => c2.data.niveau - c1.data.niveau); // tri du plus haut au plus bas
+ list.splice(0, 1); // ignorer la plus élevée
list.forEach(c => {
- economie += RdDItemCompetence.getDeltaXp(c.data.base, Math.min(c.data.niveau, 0) );
+ economie += RdDItemCompetence.getDeltaXp(c.data.base, Math.min(c.data.niveau, 0));
});
}
return economie;
}
- static levelUp(item) {
- item.data.xpNext = RdDItemCompetence.getCompetenceNextXp(item.data.niveau);
- item.data.isLevelUp = item.data.xp >= item.data.xpNext;
+ static levelUp(itemData) {
+ itemData.data.xpNext = RdDItemCompetence.getCompetenceNextXp(itemData.data.niveau);
+ itemData.data.isLevelUp = itemData.data.xp >= itemData.data.xpNext;
}
- static isVisible(item) {
- return Number(item.data.niveau) != RdDItemCompetence.getNiveauBase(item.data.categorie);
+ static isVisible(itemData) {
+ return Number(itemData.data.niveau) != RdDItemCompetence.getNiveauBase(itemData.data.categorie);
}
-
+
/* -------------------------------------------- */
- static isNiveauBase(item) {
- return Number(item.data.niveau) == RdDItemCompetence.getNiveauBase(item.data.categorie);
+ static isNiveauBase(itemData) {
+ return Number(itemData.data.niveau) == RdDItemCompetence.getNiveauBase(itemData.data.categorie);
}
/* -------------------------------------------- */
static findCompetence(list, name) {
name = name.toLowerCase();
- return list.find(item => item.name.toLowerCase() == name && (item.type == "competence" || item.type == "competencecreature"))
+ return list.find(it => it.name.toLowerCase() == name && (it.type == "competence" || it.type == "competencecreature"))
}
/* -------------------------------------------- */
@@ -206,26 +206,26 @@ export class RdDItemCompetence extends Item {
}
/* -------------------------------------------- */
- static _valideNiveau(niveau){
+ static _valideNiveau(niveau) {
if (niveau < -11 || niveau > competence_niveau_max) {
console.warn(`Niveau ${niveau} en dehors des niveaux de compétences: [-11, ${competence_niveau_max} ]`);
}
}
-
+
/* -------------------------------------------- */
static computeResumeArchetype(competences) {
const archetype = RdDItemCompetence.getLimitesArchetypes();
- competences.forEach(item => {
- let niveau = (item.data.niveau_archetype < 0) ? 0 : item.data.niveau_archetype;
+ competences.forEach(it => {
+ let niveau = Math.max(0, it.data.niveau_archetype);
archetype[niveau] = archetype[niveau] ?? { "niveau": niveau, "nombreMax": 0, "nombre": 0 };
archetype[niveau].nombre = (archetype[niveau]?.nombre ?? 0) + 1;
});
return archetype;
}
- /* -------------------------------------------- */
- static getLimitesArchetypes() {
- return duplicate(limitesArchetypes);
- }
-
+ /* -------------------------------------------- */
+ static getLimitesArchetypes() {
+ return duplicate(limitesArchetypes);
+ }
+
}
\ No newline at end of file
diff --git a/module/item-competencecreature.js b/module/item-competencecreature.js
index 3835bc12..e6140035 100644
--- a/module/item-competencecreature.js
+++ b/module/item-competencecreature.js
@@ -1,3 +1,5 @@
+import { Misc } from "./misc.js";
+
/* -------------------------------------------- */
export class RdDItemCompetenceCreature extends Item {
@@ -15,12 +17,13 @@ export class RdDItemCompetenceCreature extends Item {
}
/* -------------------------------------------- */
- static toArme(item) {
- if (RdDItemCompetenceCreature.isCompetenceAttaque(item)) {
- let arme = { name: item.name, data: duplicate(item.data) };
+ static toArme(itemData) {
+ if (RdDItemCompetenceCreature.isCompetenceAttaque(itemData)) {
+ itemData = Misc.data(itemData);
+ let arme = { name: itemData.name, data: duplicate(itemData) };
mergeObject(arme.data,
{
- competence: item.name,
+ competence: itemData.name,
resistance: 100,
equipe: true,
penetration: 0,
@@ -29,17 +32,19 @@ export class RdDItemCompetenceCreature extends Item {
});
return arme;
}
- console.error("RdDItemCompetenceCreature.toArme(", item, ") : impossible de transformer l'Item en arme");
+ console.error("RdDItemCompetenceCreature.toArme(", itemData, ") : impossible de transformer l'Item en arme");
return undefined;
}
/* -------------------------------------------- */
- static isCompetenceAttaque(item) {
- return item.type == 'competencecreature' && item.data.iscombat;
+ static isCompetenceAttaque(itemData) {
+ itemData = Misc.data(itemData);
+ return itemData.type == 'competencecreature' && itemData.data.iscombat;
}
-
+
/* -------------------------------------------- */
- static isCompetenceParade(item) {
- return item.type == 'competencecreature' && item.data.isparade;
+ static isCompetenceParade(itemData) {
+ itemData = Misc.data(itemData);
+ return itemData.type == 'competencecreature' && itemData.data.isparade;
}
}
diff --git a/module/item-rdd.js b/module/item-rdd.js
index 362cb61e..cb86ecaa 100644
--- a/module/item-rdd.js
+++ b/module/item-rdd.js
@@ -1,3 +1,4 @@
+import { Misc } from "./misc.js";
import { RdDUtility } from "./rdd-utility.js";
/* -------------------------------------------- */
@@ -7,7 +8,8 @@ export class RdDItem extends Item {
async postItem() {
console.log(this);
const properties = this[`_${this.data.type}ChatData`]();
- let chatData = duplicate(this.data);
+ const itemData = Misc.data(this);
+ let chatData = duplicate(itemData);
chatData["properties"] = properties
//Check if the posted item should have availability/pay buttons
@@ -49,17 +51,17 @@ export class RdDItem extends Item {
{
if (this.isOwned)
{
- if (this.data.data.quantite == 0)
+ if (itemData.data.quantite == 0)
dialogResult[0] = -1
- else if (this.data.data.quantite < dialogResult[0])
+ else if (itemData.data.quantite < dialogResult[0])
{
- dialogResult[0] = this.data.data.quantite;
+ dialogResult[0] = itemData.data.quantite;
ui.notifications.notify(`Impossible de poster plus que ce que vous avez. La quantité à été réduite à ${dialogResult[0]}.`)
this.update({"data.quantite" : 0})
}
else {
ui.notifications.notify(`Quantité réduite par ${dialogResult[0]}.`)
- this.update({"data.quantite" : this.data.data.quantite - dialogResult[0]})
+ this.update({"data.quantite" : itemData.data.quantite - dialogResult[0]})
}
}
}
@@ -84,7 +86,7 @@ export class RdDItem extends Item {
chatData.jsondata = JSON.stringify(
{
compendium : "postedItem",
- payload: this.data,
+ payload: itemData,
});
renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-item.html', chatData).then(html => {
@@ -95,217 +97,217 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
_objetChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Encombrement: ${data.encombrement}`
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_armeChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Compétence: ${data.competence}`,
- `Dommages: ${data.dommages}`,
- `Force minimum: ${data.force}`,
- `Resistance: ${data.resistance}`,
- `Encombrement: ${data.encombrement}`
+ `Compétence: ${rddData.competence}`,
+ `Dommages: ${rddData.dommages}`,
+ `Force minimum: ${rddData.force}`,
+ `Resistance: ${rddData.resistance}`,
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_conteneurChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Capacité: ${data.capacite} Enc.`,
- `Encombrement: ${data.encombrement}`
+ `Capacité: ${rddData.capacite} Enc.`,
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_munitionChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Encombrement: ${data.encombrement}`
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_armureChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Protection: ${data.protection}`,
- `Détérioration: ${data.deterioration}`,
- `Malus armure: ${data.malus}`,
- `Encombrement: ${data.encombrement}`
+ `Protection: ${rddData.protection}`,
+ `Détérioration: ${rddData.deterioration}`,
+ `Malus armure: ${rddData.malus}`,
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_competenceChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Catégorie: ${data.categorie}`,
- `Niveau: ${data.niveau}`,
- `Caractéristique par défaut: ${data.carac_defaut}`,
- `XP: ${data.xp}`
+ `Catégorie: ${rddData.categorie}`,
+ `Niveau: ${rddData.niveau}`,
+ `Caractéristique par défaut: ${rddData.carac_defaut}`,
+ `XP: ${rddData.xp}`
]
return properties;
}
/* -------------------------------------------- */
_competencecreatureChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Catégorie: ${data.categorie}`,
- `Niveau: ${data.niveau}`,
- `Caractéristique: ${data.carac_value}`,
- `XP: ${data.xp}`
+ `Catégorie: ${rddData.categorie}`,
+ `Niveau: ${rddData.niveau}`,
+ `Caractéristique: ${rddData.carac_value}`,
+ `XP: ${rddData.xp}`
]
return properties;
}
/* -------------------------------------------- */
_sortChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Draconic: ${data.draconic}`,
- `Difficulté: ${data.difficulte}`,
- `Case TMR: ${data.caseTMR}`,
- `Points de Rêve: ${data.ptreve}`
+ `Draconic: ${rddData.draconic}`,
+ `Difficulté: ${rddData.difficulte}`,
+ `Case TMR: ${rddData.caseTMR}`,
+ `Points de Rêve: ${rddData.ptreve}`
]
return properties;
}
/* -------------------------------------------- */
_herbeChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Milieu: ${data.milieu}`,
- `Rareté: ${data.rarete}`,
- `Catégorie: ${data.categorie}`,
+ `Milieu: ${rddData.milieu}`,
+ `Rareté: ${rddData.rarete}`,
+ `Catégorie: ${rddData.categorie}`,
]
return properties;
}
/* -------------------------------------------- */
_ingredientChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Milieu: ${data.milieu}`,
- `Rareté: ${data.rarete}`,
- `Catégorie: ${data.categorie}`,
+ `Milieu: ${rddData.milieu}`,
+ `Rareté: ${rddData.rarete}`,
+ `Catégorie: ${rddData.categorie}`,
]
return properties;
}
/* -------------------------------------------- */
_tacheChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Caractéristique: ${data.carac}`,
- `Compétence: ${data.competence}`,
- `Périodicité: ${data.periodicite}`,
- `Fatigue: ${data.fatigue}`,
- `Difficulté: ${data.difficulte}`,
- `Points de Tâche: ${data.points_de_tache}`,
- `Points de Tâche atteints: ${data.points_de_tache_courant}`
+ `Caractéristique: ${rddData.carac}`,
+ `Compétence: ${rddData.competence}`,
+ `Périodicité: ${rddData.periodicite}`,
+ `Fatigue: ${rddData.fatigue}`,
+ `Difficulté: ${rddData.difficulte}`,
+ `Points de Tâche: ${rddData.points_de_tache}`,
+ `Points de Tâche atteints: ${rddData.points_de_tache_courant}`
]
return properties;
}
/* -------------------------------------------- */
_livreChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Compétence: ${data.competence}`,
- `Auteur: ${data.auteur}`,
- `Difficulté: ${data.difficulte}`,
- `Points de Tâche: ${data.points_de_tache}`,
- `Encombrement: ${data.encombrement}`
+ `Compétence: ${rddData.competence}`,
+ `Auteur: ${rddData.auteur}`,
+ `Difficulté: ${rddData.difficulte}`,
+ `Points de Tâche: ${rddData.points_de_tache}`,
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_potionChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Rareté: ${data.rarete}`,
- `Catégorie: ${data.categorie}`,
- `Encombrement: ${data.encombrement}`,
+ `Rareté: ${rddData.rarete}`,
+ `Catégorie: ${rddData.categorie}`,
+ `Encombrement: ${rddData.encombrement}`,
]
return properties;
}
/* -------------------------------------------- */
_queueChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Refoulement: ${data.refoulement}`
+ `Refoulement: ${rddData.refoulement}`
]
return properties;
}
/* -------------------------------------------- */
_ombreChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Refoulement: ${data.refoulement}`
+ `Refoulement: ${rddData.refoulement}`
]
return properties;
}
/* -------------------------------------------- */
_souffleChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [];
return properties;
}
/* -------------------------------------------- */
_teteChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [];
return properties;
}
/* -------------------------------------------- */
_tarotChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Concept: ${data.concept}`,
- `Aspect: ${data.aspect}`,
+ `Concept: ${rddData.concept}`,
+ `Aspect: ${rddData.aspect}`,
]
return properties;
}
/* -------------------------------------------- */
_nombreastralChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Valeur: ${data.value}`,
- `Jour: ${data.jourlabel}`,
+ `Valeur: ${rddData.value}`,
+ `Jour: ${rddData.jourlabel}`,
]
return properties;
}
/* -------------------------------------------- */
_monnaieChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Valeur en Deniers: ${data.valeur_deniers}`,
- `Encombrement: ${data.encombrement}`
+ `Valeur en Deniers: ${rddData.valeur_deniers}`,
+ `Encombrement: ${rddData.encombrement}`
]
return properties;
}
/* -------------------------------------------- */
_meditationChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Thème: ${data.theme}`,
- `Compétence: ${data.competence}`,
- `Support: ${data.support}`,
- `Heure: ${data.heure}`,
- `Purification: ${data.purification}`,
- `Vêture: ${data.veture}`,
- `Comportement: ${data.comportement}`,
- `Case TMR: ${data.tmr}`
+ `Thème: ${rddData.theme}`,
+ `Compétence: ${rddData.competence}`,
+ `Support: ${rddData.support}`,
+ `Heure: ${rddData.heure}`,
+ `Purification: ${rddData.purification}`,
+ `Vêture: ${rddData.veture}`,
+ `Comportement: ${rddData.comportement}`,
+ `Case TMR: ${rddData.tmr}`
]
return properties;
}
/* -------------------------------------------- */
_casetmrChatData() {
- const data = duplicate(this.data.data);
+ const rddData = Misc.data(this).data;
let properties = [
- `Coordonnée: ${data.coord}`,
- `Spécificité: ${data.specific}`
+ `Coordonnée: ${rddData.coord}`,
+ `Spécificité: ${rddData.specific}`
]
return properties;
}
diff --git a/module/item-sheet.js b/module/item-sheet.js
index 1808ec81..b51cb2ab 100644
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@@ -3,6 +3,7 @@ import { RdDUtility } from "./rdd-utility.js";
import { RdDItem } from "./item-rdd.js";
import { RdDAlchimie } from "./rdd-alchimie.js";
import { RdDItemCompetence } from "./item-competence.js";
+import { Misc } from "./misc.js";
/**
* Extend the basic ItemSheet with some very simple modifications
@@ -30,7 +31,7 @@ export class RdDItemSheet extends ItemSheet {
{
class: "post",
icon: "fas fa-comment",
- onclick: ev => new RdDItem(this.item.data).postItem()
+ onclick: ev => new RdDItem(Misc.data(this.item)).postItem()
})
return buttons
}
diff --git a/module/misc.js b/module/misc.js
index 8f972c7b..fcc89b22 100644
--- a/module/misc.js
+++ b/module/misc.js
@@ -6,26 +6,24 @@
export class Misc {
static isFunction(v) {
return v && {}.toString.call(v) === '[object Function]';
- }
+ }
static upperFirst(text) {
return text.charAt(0).toUpperCase() + text.slice(1);
}
- static toSignedString(number){
+ static toSignedString(number) {
const value = parseInt(number)
const isPositiveNumber = value != NaN && value > 0;
- return isPositiveNumber ? "+"+number : number
+ return isPositiveNumber ? "+" + number : number
}
/**
* Converts the value to an integer, or to 0 if undefined/null/not representing integer
* @param {*} value value to convert to an integer using parseInt
*/
- static toInt(value)
- {
- if (value == undefined)
- {
+ static toInt(value) {
+ if (value == undefined) {
return 0;
}
const parsed = parseInt(value);
@@ -78,4 +76,25 @@ export class Misc {
return [...new Set(array)];
}
+ static actorData(actor) {
+ return Misc.data(actor);
+ }
+
+ static itemData(item) {
+ return Misc.data(item);
+ }
+
+ static data(it) {
+ if (it instanceof Item) {
+ return it.data;
+ }
+ if (it instanceof Actor) {
+ return it.data;
+ }
+ return it;
+ }
+
+ static templateData(it) {
+ return Misc.data(it)?.data ?? {}
+ }
}
\ No newline at end of file
diff --git a/module/rdd-astrologie-joueur.js b/module/rdd-astrologie-joueur.js
index eccad906..b1d6d45c 100644
--- a/module/rdd-astrologie-joueur.js
+++ b/module/rdd-astrologie-joueur.js
@@ -1,4 +1,5 @@
import { RdDItemCompetence } from "./item-competence.js";
+import { Misc } from "./misc.js";
/**
@@ -61,7 +62,7 @@ export class RdDAstrologieJoueur extends Dialog {
/* -------------------------------------------- */
requestJetAstrologie( ) {
let data = { id: this.actor.data._id,
- carac_vue: this.actor.data.data.carac['vue'].value,
+ carac_vue: Misc.data(this.actor).data.carac['vue'].value,
etat: this.dataNombreAstral.etat,
astrologie: this.dataNombreAstral.astrologie,
conditions: $("#diffConditions").val(),
diff --git a/module/rdd-combat.js b/module/rdd-combat.js
index e668de44..79ea86d7 100644
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -82,22 +82,22 @@ export class RdDCombatManager extends Combat {
if (!rollFormula) {
let armeCombat, competence;
if (c.actor.data.type == 'creature' || c.actor.data.type == 'entite') {
- for (const competenceItem of c.actor.data.items) {
- if (competenceItem.data.iscombat) {
- competence = duplicate(competenceItem);
+ for (const competenceItemData of c.actor.data.items) {
+ if (competenceItemData.data.iscombat) {
+ competence = duplicate(competenceItemData);
}
}
rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, competence.data.carac_value) + ")/100)";
} else {
- for (const item of c.actor.data.items) {
- if (item.type == "arme" && item.data.equipe) {
- armeCombat = duplicate(item);
+ for (const itemData of c.actor.data.items) {
+ if (itemData.type == "arme" && itemData.data.equipe) {
+ armeCombat = duplicate(itemData);
}
}
let compName = (armeCombat == undefined) ? "Corps à corps" : armeCombat.data.competence;
competence = RdDItemCompetence.findCompetence(c.actor.data.items, compName);
let bonusEcaille = (armeCombat && armeCombat.data.magique) ? armeCombat.data.ecaille_efficacite : 0;
- rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, c.actor.data.data.carac[competence.data.defaut_carac].value, bonusEcaille) + ")/100)";
+ rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, Misc.data(c.actor).data.carac[competence.data.defaut_carac].value, bonusEcaille) + ")/100)";
}
}
//console.log("Combatat", c);
@@ -192,7 +192,7 @@ export class RdDCombatManager extends Combat {
.concat(RdDItemArme.mainsNues());
let competences = items.filter(it => it.type == 'competence');
- actions = actions.concat(RdDCombatManager.finalizeArmeList(armes, competences, combatant.actor.data.data.carac));
+ actions = actions.concat(RdDCombatManager.finalizeArmeList(armes, competences, Misc.data(combatant.actor).data.carac));
actions.push({ name: "Draconic", data: { initOnly: true, competence: "Draconic" } });
}
@@ -293,7 +293,7 @@ export class RdDCombatManager extends Combat {
initOffset = 5;
}
} else {
- caracForInit = combatant.actor.data.data.carac[competence.data.defaut_carac].value;
+ caracForInit = Misc.data(combatant.actor).data.carac[competence.data.defaut_carac].value;
if (competence.data.categorie == "lancer") { // Offset de principe pour les armes de jet
initOffset = 4;
}
@@ -861,7 +861,7 @@ export class RdDCombat {
/* -------------------------------------------- */
_filterArmesParade(defender, competence) {
let items = defender.data.items;
- items = items.filter(item => RdDItemArme.isArmeUtilisable(item) || RdDItemCompetenceCreature.isCompetenceParade(item));
+ items = items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it));
for (let item of items) {
item.data.nbUsage = defender.getItemUse(item._id); // Ajout du # d'utilisation ce round
}
diff --git a/module/rdd-roll.js b/module/rdd-roll.js
index 07462460..4f796a60 100644
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@@ -38,18 +38,19 @@ export class RdDRoll extends Dialog {
/* -------------------------------------------- */
static _setDefaultOptions(actor, rollData) {
+ const actorData = Misc.data(actor);
let defaultRollData = {
alias: actor.name,
ajustementsConditions: CONFIG.RDD.ajustementsConditions,
difficultesLibres: CONFIG.RDD.difficultesLibres,
etat: actor.getEtatGeneral(),
moral: actor.getMoralTotal(), /* La valeur du moral pour les jets de volonté */
- carac: actor.data.data.carac,
+ carac: actorData.data.carac,
finalLevel: 0,
diffConditions: 0,
diffLibre: rollData.competence?.data.default_diffLibre ?? 0,
malusArmureValue: actor.getMalusArmure(),
- surencMalusFlag: actor.isPersonnage() ? (actor.data.data.compteurs.surenc.value < 0) : false,
+ surencMalusFlag: actor.isPersonnage() ? (actorData.data.compteurs.surenc.value < 0) : false,
surencMalusValue: actor.getSurenc(),
useMalusSurenc: false,
useMoral: false, /* Est-ce que le joueur demande d'utiliser le moral ? Utile si le joueur change plusieurs fois de carac associée. */
diff --git a/module/rdd-tmr-dialog.js b/module/rdd-tmr-dialog.js
index b1fe330a..92329451 100644
--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@@ -11,6 +11,7 @@ import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
import { PixiTMR } from "./tmr/pixi-tmr.js";
import { Draconique } from "./tmr/draconique.js";
import { Grammar } from "./grammar.js";
+import { Misc } from "./misc.js";
/* -------------------------------------------- */
export class RdDTMRDialog extends Dialog {
@@ -72,7 +73,7 @@ export class RdDTMRDialog extends Dialog {
}
loadSortsReserve() {
- this.sortsReserves = this.actor.data.data.reve.reserve.list;
+ this.sortsReserves = Misc.data(this.actor).data.reve.reserve.list;
}
loadRencontres() {
@@ -136,7 +137,7 @@ export class RdDTMRDialog extends Dialog {
return EffetsDraconiques.sortReserve.token(this.pixiTMR, sortEnReserve.sort, () => sortEnReserve.coord);
}
_tokenDemiReve() {
- return EffetsDraconiques.demiReve.token(this.pixiTMR, this.actor, () => this.actor.data.data.reve.tmrpos.coord);
+ return EffetsDraconiques.demiReve.token(this.pixiTMR, this.actor, () => Misc.data(this.actor).data.reve.tmrpos.coord);
}
_updateDemiReve() {
@@ -155,7 +156,7 @@ export class RdDTMRDialog extends Dialog {
else {
// Roll Sort
html.find('#lancer-sort').click((event) => {
- this.actor.rollUnSort(this.actor.data.data.reve.tmrpos.coord);
+ this.actor.rollUnSort(Misc.data(this.actor).data.reve.tmrpos.coord);
});
}
if (this.viewOnly) {
@@ -170,7 +171,7 @@ export class RdDTMRDialog extends Dialog {
// Le reste...
this.updateValuesDisplay();
- let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
+ let tmr = TMRUtility.getTMR(Misc.data(this.actor).data.reve.tmrpos.coord);
await this.manageRencontre(tmr, () => {
this.postRencontre(tmr);
});
@@ -179,21 +180,22 @@ export class RdDTMRDialog extends Dialog {
/* -------------------------------------------- */
updateValuesDisplay() {
let ptsreve = document.getElementById("tmr-pointsreve-value");
- ptsreve.innerHTML = this.actor.data.data.reve.reve.value;
+ const actorData = Misc.data(this.actor);
+ ptsreve.innerHTML = actorData.data.reve.reve.value;
let tmrpos = document.getElementById("tmr-pos");
- let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
- tmrpos.innerHTML = this.actor.data.data.reve.tmrpos.coord + " (" + tmr.label + ")";
+ let tmr = TMRUtility.getTMR(actorData.data.reve.tmrpos.coord);
+ tmrpos.innerHTML = actorData.data.reve.tmrpos.coord + " (" + tmr.label + ")";
let etat = document.getElementById("tmr-etatgeneral-value");
etat.innerHTML = this.actor.getEtatGeneral();
let refoulement = document.getElementById("tmr-refoulement-value");
- refoulement.innerHTML = this.actor.data.data.reve.refoulement.value;
+ refoulement.innerHTML = actorData.data.reve.refoulement.value;
let fatigueItem = document.getElementById("tmr-fatigue-table");
- //console.log("Refresh : ", this.actor.data.data.sante.fatigue.value);
- fatigueItem.innerHTML = "" + RdDUtility.makeHTMLfatigueMatrix(this.actor.data.data.sante.fatigue.value, this.actor.data.data.sante.endurance.max).html() + "
";
+ //console.log("Refresh : ", actorData.data.sante.fatigue.value);
+ fatigueItem.innerHTML = "" + RdDUtility.makeHTMLfatigueMatrix(actorData.data.sante.fatigue.value, actorData.data.sante.endurance.max).html() + "
";
}
/* -------------------------------------------- */
@@ -310,7 +312,7 @@ export class RdDTMRDialog extends Dialog {
rencontre: this.currentRencontre,
nbRounds: 1,
canClose: false,
- tmr: TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord)
+ tmr: TMRUtility.getTMR(Misc.data(this.actor).data.reve.tmrpos.coord)
}
await this._tentativeMaitrise(rencontreData);
@@ -780,7 +782,7 @@ export class RdDTMRDialog extends Dialog {
}
async _onClickTMRPos(eventPos) {
- let currentPos = TMRUtility.convertToCellPos(this.actor.data.data.reve.tmrpos.coord);
+ let currentPos = TMRUtility.convertToCellPos(Misc.data(this.actor).data.reve.tmrpos.coord);
console.log("deplacerDemiReve >>>>", currentPos, eventPos);
@@ -846,7 +848,7 @@ export class RdDTMRDialog extends Dialog {
game.socket.emit("system.foundryvtt-reve-de-dragon", {
msg: "msg_tmr_move", data: {
actorId: this.actor.data._id,
- tmrPos: this.actor.data.data.reve.tmrpos
+ tmrPos: Misc.data(this.actor).data.reve.tmrpos
}
});
diff --git a/module/rolldata-ajustements.js b/module/rolldata-ajustements.js
index 1d4eb657..1164a345 100644
--- a/module/rolldata-ajustements.js
+++ b/module/rolldata-ajustements.js
@@ -18,9 +18,9 @@ import { ReglesOptionelles } from "./regles-optionelles.js";
*/
export const referenceAjustements = {
competence: {
- isUsed: (rollData, actor) => rollData.competence,
- getLabel: (rollData, actor) => rollData.competence?.name,
- getValue: (rollData, actor) => rollData.competence?.data?.niveau,
+ isUsed: (rollData, actor) => Misc.data(rollData.competence),
+ getLabel: (rollData, actor) => Misc.data(rollData.competence)?.name,
+ getValue: (rollData, actor) => Misc.data(rollData.competence)?.data?.niveau,
},
meditation: {
isUsed: (rollData, actor) => rollData.meditation,
@@ -32,7 +32,7 @@ export const referenceAjustements = {
getLabel: (rollData, actor) => rollData.selectedSort?.name ?? rollData.attackerRoll ? 'Imposée' : 'Libre',
getValue: (rollData, actor) => rollData.selectedSort
? RdDItemSort.getDifficulte(rollData.selectedSort, rollData.diffLibre)
- : rollData.diffLibre ?? rollData.competence?.data.default_diffLibre ?? 0
+ : rollData.diffLibre ?? Misc.data(rollData.competence)?.data.default_diffLibre ?? 0
},
diffConditions: {
isUsed: (rollData, actor) => rollData.diffConditions != undefined,
@@ -94,10 +94,10 @@ export const referenceAjustements = {
getDescr: (rollData, actor) => rollData.diviseurSignificative > 1 ? `Facteur significative ×${Misc.getFractionHtml(rollData.diviseurSignificative)}` : ''
},
isEcaille: {
- isVisible: (rollData, actor) => rollData.arme?.data.magique && Number(rollData.arme?.data.ecaille_efficacite) > 0,
- isUsed: (rollData, actor) => rollData.arme?.data.magique && Number(rollData.arme?.data.ecaille_efficacite) > 0,
+ isVisible: (rollData, actor) => Misc.data(rollData.arme)?.data.magique && Number(Misc.data(rollData.arme)?.data.ecaille_efficacite) > 0,
+ isUsed: (rollData, actor) => Misc.data(rollData.arme)?.data.magique && Number(Misc.data(rollData.arme)?.data.ecaille_efficacite) > 0,
getLabel: (rollData, actor) => "Ecaille d'Efficacité: ",
- getValue: (rollData, actor) => (rollData.arme?.data.magique && Number(rollData.arme.data.ecaille_efficacite) > 0) ? rollData.arme.data.ecaille_efficacite : 0,
+ getValue: (rollData, actor) => Math.max(Number(Misc.data(rollData.arme)?.data.ecaille_efficacite), 0),
},
finesse: {
isUsed: (rollData, actor) => RdDBonus.isDefenseAttaqueFinesse(rollData),
diff --git a/module/tmr/effets-draconiques.js b/module/tmr/effets-draconiques.js
index 6eefe7f3..a73fc272 100644
--- a/module/tmr/effets-draconiques.js
+++ b/module/tmr/effets-draconiques.js
@@ -16,6 +16,7 @@ import { Conquete } from "./conquete.js";
import { Pelerinage } from "./pelerinage.js";
import { Periple } from "./periple.js";
import { UrgenceDraconique } from "./urgence-draconique.js";
+import { Misc } from "../misc.js";
export class EffetsDraconiques {
@@ -92,98 +93,100 @@ export class EffetsDraconiques {
return EffetsDraconiques.presentCites.isCase(caseTMR, coord);
}
/* -------------------------------------------- */
- static isMauvaiseRencontre(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('mauvaise rencontre'));
+ static isMauvaiseRencontre(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('mauvaise rencontre'));
}
- static isMonteeLaborieuse(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('montée laborieuse'));
+ static isMonteeLaborieuse(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isQueueSouffle(it) && it.name.toLowerCase().includes('montée laborieuse'));
}
/* -------------------------------------------- */
- static isFermetureCite(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.fermetureCites.match(it));
+ static isFermetureCite(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.fermetureCites.match(it));
}
- static isPontImpraticable(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.pontImpraticable.match(it));
+ static isPontImpraticable(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.pontImpraticable.match(it));
}
- static isDoubleResistanceFleuve(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('résistance du fleuve'));
+ static isDoubleResistanceFleuve(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('résistance du fleuve'));
}
- static isPeage(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('péage'));
+ static isPeage(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isSouffleDragon(it) && it.name.toLowerCase().includes('péage'));
}
- static isPeriple(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.periple.match(it));
+ static isPeriple(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.periple.match(it));
}
- static isDesorientation(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.desorientation.match(it)); // TODO
+ static isDesorientation(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.desorientation.match(it)); // TODO
}
/* -------------------------------------------- */
- static isSortImpossible(element) {
- return EffetsDraconiques.isMatching(element, it =>
+ static isSortImpossible(item) {
+ return EffetsDraconiques.isMatching(item, it =>
EffetsDraconiques.conquete.match(it) ||
EffetsDraconiques.periple.match(it) ||
EffetsDraconiques.urgenceDraconique.match(it) ||
EffetsDraconiques.pelerinage.match(it)
);
}
- static isSortReserveImpossible(element) {
- return EffetsDraconiques.isMatching(element, it =>
+
+ static isSortReserveImpossible(item) {
+ return EffetsDraconiques.isMatching(item, it =>
EffetsDraconiques.conquete.match(it) ||
EffetsDraconiques.periple.match(it) ||
EffetsDraconiques.pelerinage.match(it)
);
}
- static isConquete(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.conquete.match(it));
+ static isConquete(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.conquete.match(it));
}
- static isPelerinage(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.pelerinage.match(it));
+ static isPelerinage(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.pelerinage.match(it));
}
-
- static countInertieDraconique(element) {
- return EffetsDraconiques.count(element, it => Draconique.isQueueDragon(it) && it.name.toLowerCase().includes('inertie draconique'));
+
+ static countInertieDraconique(item) {
+ return EffetsDraconiques.count(item, it => Draconique.isQueueDragon(it) && it.name.toLowerCase().includes('inertie draconique'));
}
-
- static isUrgenceDraconique(element) {
- return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.urgenceDraconique.match(it));
+
+ static isUrgenceDraconique(item) {
+ return EffetsDraconiques.isMatching(item, it => EffetsDraconiques.urgenceDraconique.match(it));
}
-
+
/* -------------------------------------------- */
- static isDonDoubleReve(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isTeteDragon(it) && it.name == 'Don de double-rêve');
+ static isDonDoubleReve(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name == 'Don de double-rêve');
+ }
+
+ static isConnaissanceFleuve(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes('connaissance du fleuve'));
+ }
+
+ static isReserveEnSecurite(item) {
+ return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' en sécurité'));
+ }
+
+ static isDeplacementAccelere(item) {
+ item = Misc.data(item);
+ return EffetsDraconiques.isMatching(item, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' déplacement accéléré'));
+ }
+
+ static isMatching(item, matcher) {
+ return EffetsDraconiques.toItems(item).find(matcher);
+ }
+ static count(item, matcher) {
+ return EffetsDraconiques.toItems(item).filter(matcher).length;
}
- static isConnaissanceFleuve(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes('connaissance du fleuve'));
- }
-
- static isReserveEnSecurite(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' en sécurité'));
- }
-
- static isDeplacementAccelere(element) {
- return EffetsDraconiques.isMatching(element, it => Draconique.isTeteDragon(it) && it.name.toLowerCase().includes(' déplacement accéléré'));
- }
-
- static isMatching(element, matcher) {
- return EffetsDraconiques.toItems(element).find(matcher);
- }
- static count(element, matcher) {
- return EffetsDraconiques.toItems(element).filter(matcher).length;
- }
-
- static toItems(element) {
- return (element?.entity === 'Actor') ? element.data.items : (element?.entity === 'Item') ? [element] : [];
+ static toItems(item) {
+ return (item?.entity === 'Actor') ? item.data.items : (item?.entity === 'Item') ? [Misc.data(item)] : [];
}
}
\ No newline at end of file