diff --git a/module/actor-sheet.js b/module/actor-sheet.js
index 75dc8495..5d129fe1 100644
--- a/module/actor-sheet.js
+++ b/module/actor-sheet.js
@@ -48,21 +48,22 @@ export class RdDActorSheet extends ActorSheet {
name: objectData.name,
editable: this.isEditable,
cssClass: this.isEditable ? "editable" : "locked",
- data: foundry.utils.deepClone(Misc.templateData(this.object)),
+ data: foundry.utils.deepClone(this.object.system),
effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
limited: this.object.limited,
options: this.options,
owner: this.document.isOwner,
itemsByType: Misc.classify(this.object.items.map(i => foundry.utils.deepClone(i.data))),
};
+ console.log("ACTOR DATA:", formData)
- RdDUtility.filterItemsPerTypeForSheet(formData);
+ RdDUtility.filterItemsPerTypeForSheet(formData)
formData.options.isGM = game.user.isGM;
if (formData.type == 'creature') return formData; // Shortcut
- formData.competenceByCategory = Misc.classify(formData.competences, it => it.data.categorie);
+ formData.competenceByCategory = Misc.classify(formData.competences, it => it.system.categorie)
formData.calc = {
comptageArchetype: RdDItemCompetence.computeResumeArchetype(formData.competences),
@@ -93,8 +94,8 @@ export class RdDActorSheet extends ActorSheet {
formData.combat = duplicate(formData.armes ?? []);
RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.data.carac);
- formData.esquives = this.actor.getCompetences("Esquive").map(i => foundry.utils.deepClone(i.data));
- formData.combat = RdDCombatManager.finalizeArmeList(formData.combat, formData.competences, formData.data.carac);
+ formData.esquives = this.actor.getCompetences("Esquive").map(i => foundry.utils.deepClone(i.system))
+ formData.combat = RdDCombatManager.finalizeArmeList(formData.combat, formData.competences, formData.data.carac)
this.armesList = formData.combat;
@@ -118,7 +119,7 @@ export class RdDActorSheet extends ActorSheet {
montures: this.actor.listeMontures(),
suivants: this.actor.listeSuivants()
}
- if (this.actor.getBestDraconic().data.niveau > -11 && !this.actor.isHautRevant()) {
+ if (this.actor.getBestDraconic().system.niveau > -11 && !this.actor.isHautRevant()) {
ui.notifications.error(`${this.actor.name} a des compétences draconiques, mais pas le don de Haut-Rêve!
Ajoutez-lui la tête "Don de Haut-Rêve" pour lui permettre d'utiliser ses compétences et d'accéder aux terres médianes du rêve`);
}
diff --git a/module/actor.js b/module/actor.js
index a4ded765..6b6f16eb 100644
--- a/module/actor.js
+++ b/module/actor.js
@@ -126,7 +126,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
prepareData() {
super.prepareData();
- const actorData = this.data;
+ const actorData = this.system
// Dynamic computing fields
this.encTotal = 0;
@@ -205,20 +205,20 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
isCreature() {
- return this.data.type == 'creature' || this.data.type == 'entite';
+ return this.type == 'creature' || this.type == 'entite';
}
/* -------------------------------------------- */
isPersonnage() {
- return this.data.type == 'personnage';
+ return this.type == 'personnage';
}
/* -------------------------------------------- */
isHautRevant() {
- return this.isPersonnage() && Misc.templateData(this).attributs.hautrevant.value != ""
+ return this.isPersonnage() && this.system.attributs.hautrevant.value != ""
}
/* -------------------------------------------- */
getFatigueActuelle() {
if (ReglesOptionelles.isUsing("appliquer-fatigue") && this.isPersonnage()) {
- return Misc.toInt(Misc.templateData(this).sante.fatigue?.value);
+ return Misc.toInt(this.system.sante.fatigue?.value);
}
return 0;
}
@@ -227,57 +227,56 @@ export class RdDActor extends Actor {
if (!this.isPersonnage()) {
return 1;
}
- return Misc.toInt(Misc.templateData(this).sante.fatigue?.max);
+ return Misc.toInt(this.system.sante.fatigue?.max);
}
/* -------------------------------------------- */
getReveActuel() {
- const templateData = Misc.templateData(this);
- return Misc.toInt(templateData.reve?.reve?.value ?? templateData.carac.reve.value);
+ return Misc.toInt(this.system.reve?.reve?.value ?? this.system.carac.reve.value);
}
/* -------------------------------------------- */
getChanceActuel() {
- return Misc.toInt(Misc.templateData(this).compteurs.chance?.value ?? 10);
+ return Misc.toInt(this.system.compteurs.chance?.value ?? 10);
}
/* -------------------------------------------- */
getTaille() {
- return Misc.toInt(Misc.templateData(this).carac.taille?.value);
+ return Misc.toInt(this.system.carac.taille?.value);
}
/* -------------------------------------------- */
getForce() {
if (this.isEntiteCauchemar()) {
- return Misc.toInt(Misc.templateData(this).carac.reve?.value);
+ return Misc.toInt(this.system.carac.reve?.value);
}
- return Misc.toInt(Misc.templateData(this).carac.force?.value);
+ return Misc.toInt(this.system.carac.force?.value);
}
/* -------------------------------------------- */
getAgilite() {
switch (this.data.type) {
- 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);
+ case 'personnage': return Misc.toInt(this.system.carac.agilite?.value);
+ case 'creature': return Misc.toInt(this.system.carac.force?.value);
+ case 'entite': return Misc.toInt(this.system.carac.reve?.value);
}
return 10;
}
/* -------------------------------------------- */
getChance() {
- return Misc.toInt(Misc.templateData(this).carac.chance?.value ?? 10);
+ return Misc.toInt(this.system.carac.chance?.value ?? 10);
}
getMoralTotal() {
- return Misc.toInt(Misc.templateData(this).compteurs.moral?.value);
+ return Misc.toInt(this.system.compteurs.moral?.value);
}
/* -------------------------------------------- */
getBonusDegat() {
// TODO: gérer séparation et +dom créature/entité indépendament de la compétence
- return Misc.toInt(Misc.templateData(this).attributs.plusdom.value);
+ return Misc.toInt(this.system.attributs.plusdom.value);
}
/* -------------------------------------------- */
getProtectionNaturelle() {
- return Misc.toInt(Misc.templateData(this).attributs.protection.value);
+ return Misc.toInt(this.system.attributs.protection.value);
}
/* -------------------------------------------- */
getEtatGeneral(options = { ethylisme: false }) {
- const tplData = Misc.templateData(this);
+ const tplData = this.system
let etatGeneral = Misc.toInt(tplData.compteurs.etat?.value);
if (options.ethylisme) {
// Pour les jets d'Ethylisme, on ignore le degré d'éthylisme (p.162)
@@ -287,12 +286,12 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
getActivePoisons() {
- return duplicate(this.data.items.filter(item => item.type == 'poison' && item.data.data.active));
+ return duplicate(this.items.filter(item => item.type == 'poison' && item.system.active))
}
/* -------------------------------------------- */
getMalusArmure() {
- return Misc.toInt(Misc.templateData(this).attributs?.malusarmure?.value);
+ return Misc.toInt(this.system.attributs?.malusarmure?.value);
}
/* -------------------------------------------- */
@@ -302,36 +301,36 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
getPrixTotalEquipement() {
- return Math.floor(Misc.templateData(this).prixTotalEquipement ?? 0);
+ return Math.floor(this.system.prixTotalEquipement ?? 0);
}
/* -------------------------------------------- */
getCompetence(idOrName, options = {}) {
- return RdDItemCompetence.findCompetence(this.data.items, idOrName, options);
+ return RdDItemCompetence.findCompetence(this.items, idOrName, options);
}
getCompetences(name) {
- return RdDItemCompetence.findCompetences(this.data.items, name);
+ return RdDItemCompetence.findCompetences(this.items, name);
}
/* -------------------------------------------- */
getObjet(id) {
- return id ? this.data.items.find(it => it.id == id) : undefined;
+ return id ? this.items.find(it => it.id == id) : undefined;
}
listItemsData(type) {
return this.filterItemsData(it => it.type == type);
}
filterItemsData(filter) {
- return this.data.items.map(it => Misc.data(it)).filter(filter);
+ return this.items.map(it => it).filter(filter)
}
filterItems(filter) {
- return this.data.items.filter(it => filter(Misc.data(it)));
+ return this.items.filter(it => filter(Misc.data(it)))
}
getItemOfType(idOrName, type) {
- return this.data.items.find(it => it.id == idOrName && it.type == type)
- ?? Misc.findFirstLike(idOrName, this.data.items, { filter: it => it.type == type, description: type });
+ return this.items.find(it => it.id == idOrName && it.type == type)
+ ?? Misc.findFirstLike(idOrName, this.items, { filter: it => it.type == type, description: type });
}
getMonnaie(id) {
@@ -364,13 +363,14 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
getDraconicList() {
- return this.items.filter(it => Misc.data(it).type == 'competence' && Misc.templateData(it).categorie == 'draconic')
- .sort(Misc.descending(it => Misc.templateData(it).niveau));
+ return this.items.filter(it => it.type == 'competence' && it.system.categorie == 'draconic')
+ .sort(Misc.descending(it => it.system.niveau))
}
/* -------------------------------------------- */
getBestDraconic() {
- const list = this.getDraconicList();
- return duplicate(list[0]);
+ const list = this.getDraconicList()
+ console.log("Draco", list)
+ return duplicate(list[0])
}
getDraconicOrZero() {
const list = this.getDraconicList().filter(it => Misc.data(it).data.niveau >= 0);
@@ -381,7 +381,7 @@ export class RdDActor extends Actor {
}
getDemiReve() {
- return Misc.templateData(this).reve.tmrpos.coord;
+ return this.system.reve.tmrpos.coord;
}
/* -------------------------------------------- */
@@ -410,7 +410,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async deleteSortReserve(sortReserve) {
- let reserve = duplicate(Misc.templateData(this).reve.reserve);
+ let reserve = duplicate(this.system.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)
@@ -445,14 +445,14 @@ export class RdDActor extends Actor {
};
for (let i = 0; i < nGrisReve; i++) {
await this.dormir(6, { grisReve: true });
- const blessures = duplicate(Misc.templateData(this).blessures);
+ const blessures = duplicate(this.system.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);
await this.update({ "data.blessures": blessures });
await this._recupererVie(message);
- const moralActuel = Misc.toInt(Misc.templateData(this).compteurs.moral.value);
+ const moralActuel = Misc.toInt(this.system.compteurs.moral.value);
if (moralActuel != 0) {
await this.moralIncDec(-Math.sign(moralActuel));
}
@@ -471,7 +471,7 @@ export class RdDActor extends Actor {
content: ""
};
- const blessures = duplicate(Misc.templateData(this).blessures);
+ const blessures = duplicate(this.system.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);
@@ -556,7 +556,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _recupererVie(message) {
- const tData = Misc.templateData(this);
+ const tData = this.system
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 = tData.sante.vie.max - tData.sante.vie.value;
@@ -583,7 +583,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _jetRecuperationConstitution(bonusSoins, message = undefined) {
- const tData = Misc.templateData(this);
+ const tData = this.system
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) {
@@ -671,7 +671,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _recupererEthylisme(message) {
- let ethylisme = duplicate(Misc.templateData(this).compteurs.ethylisme);
+ let ethylisme = duplicate(this.system.compteurs.ethylisme);
ethylisme.nb_doses = 0;
ethylisme.jet_moral = false;
if (ethylisme.value < 1) {
@@ -685,7 +685,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recupereEndurance(message) {
- const manquant = this._computeEnduranceMax() - Misc.templateData(this).sante.endurance.value;
+ const manquant = this._computeEnduranceMax() - this.system.sante.endurance.value;
if (manquant > 0) {
await this.santeIncDec("endurance", manquant);
message.content += "Vous récuperez " + manquant + " points d'endurance. ";
@@ -695,7 +695,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recupererFatigue(message) {
if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
- let fatigue = Misc.templateData(this).sante.fatigue.value;
+ let fatigue = this.system.sante.fatigue.value;
const fatigueMin = this._computeFatigueMin();
if (fatigue <= fatigueMin) {
return;
@@ -710,7 +710,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
_calculRecuperationSegment(actuel) {
- const segments = RdDUtility.getSegmentsFatigue(Misc.templateData(this).sante.endurance.max);
+ const segments = RdDUtility.getSegmentsFatigue(this.system.sante.endurance.max);
let cumul = 0;
let i;
for (i = 0; i < 11; i++) {
@@ -730,7 +730,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async recuperationReve(message) {
- const seuil = Misc.templateData(this).reve.seuil.value;
+ const seuil = this.system.reve.seuil.value;
const reveActuel = this.getReveActuel();
if (reveActuel < seuil) {
let deRecuperation = await RdDDice.rollTotal("1dr");
@@ -751,7 +751,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async retourSeuilDeReve(message) {
- const seuil = Misc.templateData(this).reve.seuil.value;
+ const seuil = this.system.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)})`;
@@ -760,7 +760,7 @@ export class RdDActor extends Actor {
}
async retourSust(message) {
- const tplData = Misc.templateData(this);
+ const tplData = this.system
const sustNeeded = tplData.attributs.sust.value;
const sustConsomme = tplData.compteurs.sust.value;
const eauConsomme = tplData.compteurs.eau.value;
@@ -837,7 +837,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async sortMisEnReserve(rollData, sort) {
- let reserve = duplicate(Misc.templateData(this).reve.reserve.list);
+ let reserve = duplicate(this.system.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();
@@ -851,7 +851,7 @@ export class RdDActor extends Actor {
return;
}
}
- const tplData = Misc.templateData(this);
+ const tplData = this.system
if (caracName == "reve") {
if (caracValue > Misc.toInt(tplData.reve.seuil.value)) {
this.setPointsDeSeuil(caracValue);
@@ -880,7 +880,7 @@ export class RdDActor extends Actor {
if (caracName == 'Taille') {
return;
}
- let carac = RdDActor._findCaracByName(Misc.templateData(this).carac, caracName);
+ let carac = RdDActor._findCaracByName(this.system.carac, caracName);
if (carac) {
carac = duplicate(carac);
let xp = Number(carac.xp);
@@ -1031,7 +1031,7 @@ export class RdDActor extends Actor {
async updateExperienceLog(modeXP, valeurXP, raisonXP = 'Inconnue') {
let d = new Date();
console.log(modeXP, valeurXP, raisonXP);
- let expLog = duplicate((Misc.templateData(this)).experiencelog);
+ let expLog = duplicate(this.system.experiencelog);
expLog.push({
mode: Misc.upperFirst(modeXP), valeur: valeurXP, raison: Misc.upperFirst(raisonXP),
daterdd: game.system.rdd.calendrier.getDateFromIndex(), datereel: `${d.getDate()}/${d.getMonth() + 1}/${d.getFullYear()}`
@@ -1048,7 +1048,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async addCompteurValue(fieldName, fieldValue, raison = 'Inconnue') {
- let oldValue = (Misc.templateData(this)).compteurs[fieldName].value;
+ let oldValue = this.system.compteurs[fieldName].value;
await this.update({ [`data.compteurs.${fieldName}.value`]: Number(oldValue) + Number(fieldValue) });
await this.addStressExperienceLog(fieldName, fieldValue, raison);
}
@@ -1082,7 +1082,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
_isConteneurContenu(item, conteneur) {
if (item?.isConteneur()) { // Si c'est un conteneur, il faut vérifier qu'on ne le déplace pas vers un sous-conteneur lui appartenant
- for (let id of Misc.templateData(item).contenu) {
+ for (let id of item.system.contenu) {
let subObjet = this.getObjet(id);
if (subObjet?.id == conteneur.id) {
return true; // Loop detected !
@@ -1100,7 +1100,7 @@ export class RdDActor extends Actor {
if (!objet) {
return 0;
}
- const tplData = Misc.templateData(objet);
+ const tplData = this.system
if (objet.type != 'conteneur') {
return Number(tplData.encombrement) * Number(tplData.quantite);
}
@@ -1113,7 +1113,7 @@ export class RdDActor extends Actor {
buildSubConteneurObjetList(conteneurId, deleteList) {
let conteneur = this.getObjet(conteneurId);
if (conteneur?.type == 'conteneur') { // Si c'est un conteneur
- for (let subId of Misc.templateData(conteneur).contenu) {
+ for (let subId of conteneur.system.contenu) {
let subObj = this.getObjet(subId);
if (subObj) {
if (subObj.type == 'conteneur') {
@@ -1267,7 +1267,7 @@ export class RdDActor extends Actor {
let newItemId = itemMap[item.id]; // Get newItem
console.log('New conteneur filling!', newConteneur, newItemId, item);
- let contenu = duplicate(Misc.templateData(newConteneur).contenu);
+ let contenu = duplicate(newConteneur.system.contenu);
contenu.push(newItemId);
await this.updateEmbeddedDocuments('Item', [{ _id: newConteneurId, 'data.contenu': contenu }]);
}
@@ -1305,18 +1305,18 @@ export class RdDActor extends Actor {
getEncombrementMax() {
switch (this.type){
case 'vehicule':
- return Misc.templateData(this).capacite_encombrement;
+ return this.system.capacite_encombrement;
case 'entite':
return 0;
default:
- return Misc.templateData(this).attributs.encombrement.value;
+ return this.system.attributs.encombrement.value;
}
}
/* -------------------------------------------- */
computeIsHautRevant() {
if (this.isPersonnage()) {
- Misc.templateData(this).attributs.hautrevant.value = this.hasItemNamed('tete', 'don de haut-reve')
+ this.system.attributs.hautrevant.value = this.hasItemNamed('tete', 'don de haut-reve')
? "Haut rêvant"
: "";
}
@@ -1344,20 +1344,22 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async computeMalusArmure() {
- const newMalusArmure = this.filterItemsData(it => it.type == 'armure' && it.data.equipe)
- .map(it => it.data.malus ?? 0)
- .reduce(Misc.sum(), 0);
+ let arm = this.filterItemsData(it => it.type == 'armure' && it.system.equipe)
+ console.log(">>>>>>>>>ARM", arm)
+ const newMalusArmure = this.filterItemsData(it => it.type == 'armure' && it.system.equipe)
+ .map(it => it.system.malus ?? 0)
+ .reduce(Misc.sum(), 0)
// Mise à jour éventuelle du malus armure
- if (Misc.templateData(this).attributs?.malusarmure?.value != newMalusArmure) {
- await this.updateAttributeValue("malusarmure", newMalusArmure);
+ if (this.system.attributs?.malusarmure?.value != newMalusArmure) {
+ await this.updateAttributeValue("malusarmure", newMalusArmure)
}
- return newMalusArmure;
+ return newMalusArmure
}
/* -------------------------------------------- */
computePrixTotalEquipement() {
- this.prixTotalEquipement = this.filterItemsData(it => it.data.prixTotal)
- .map(it => it.data.prixTotal ?? 0)
+ this.prixTotalEquipement = this.filterItemsData(it => it.system.prixTotal)
+ .map(it => it.system.prixTotal ?? 0)
.reduce(Misc.sum(), 0);
// Mise à jour valeur totale de l'équipement
return this.prixTotalEquipement;
@@ -1365,7 +1367,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
computeResumeBlessure(blessures = undefined) {
- blessures = blessures ?? Misc.templateData(this).blessures;
+ blessures = blessures ?? this.system.blessures
let nbLegeres = this.countBlessures(blessures.legeres.liste);
let nbGraves = this.countBlessures(blessures.graves.liste);
let nbCritiques = this.countBlessures(blessures.critiques.liste);
@@ -1394,8 +1396,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
computeEtatGeneral() {
- const actorData = Misc.data(this);
- const tplData = Misc.templateData(this);
+ const tplData = this.system
// Pas d'état général pour les entités forçage à 0
if (this.data.type == 'entite') {
@@ -1418,20 +1419,20 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ajouterRefoulement(value = 1) {
- let refoulement = Misc.templateData(this).reve.refoulement.value + value;
- let total = await RdDDice.rollTotal("1d20");
+ let refoulement = this.system.reve.refoulement.value + value
+ let total = await RdDDice.rollTotal("1d20")
if (total <= refoulement) {
refoulement = 0;
await this.ajouterSouffle({ chat: true });
}
- await this.update({ "data.reve.refoulement.value": refoulement });
+ await this.update({ "data.reve.refoulement.value": refoulement })
return refoulement == 0 ? "souffle" : "none";
}
/* -------------------------------------------- */
async ajouterSouffle(options = { chat: false }) {
- let souffle = Misc.data(await RdDRollTables.getSouffle());
- souffle._id = undefined; //TBC
+ let souffle = Misc.data(await RdDRollTables.getSouffle())
+ souffle._id = undefined;//TBC
await this.createEmbeddedDocuments('Item', [souffle]);
if (options.chat) {
ChatMessage.create({
@@ -1444,15 +1445,15 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ajouterQueue(options = { chat: false }) {
- let queue;
- if (Misc.data(this).data.reve.reve.thanatosused) {
- queue = Misc.data(await RdDRollTables.getOmbre());
- await this.update({ "data.reve.reve.thanatosused": false });
+ let queue
+ if (this.system.reve.reve.thanatosused) {
+ queue = Misc.data(await RdDRollTables.getOmbre())
+ await this.update({ "data.reve.reve.thanatosused": false })
}
else {
- queue = Misc.data(await RdDRollTables.getQueue());
+ queue = Misc.data(await RdDRollTables.getQueue())
}
- await this.createEmbeddedDocuments('Item', [queue]);
+ await this.createEmbeddedDocuments('Item', [queue])
if (options.chat) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
@@ -1470,7 +1471,7 @@ export class RdDActor extends Actor {
await this.update({ 'data.reve.tmrpos.cache': false });
}
isTMRCache() {
- return this.data.data.reve.tmrpos.cache;
+ return this.system.reve.tmrpos.cache
}
/* -------------------------------------------- */
async cacheTMRetMessage() {
@@ -1489,8 +1490,8 @@ export class RdDActor extends Actor {
await this.montreTMR();
game.socket.emit(SYSTEM_SOCKET_ID, {
msg: "msg_tmr_move", data: {
- actorId: this.data._id,
- tmrPos: this.data.data.reve.tmrpos
+ actorId: this.id,
+ tmrPos: this.system.reve.tmrpos
}
});
}
@@ -1512,12 +1513,12 @@ export class RdDActor extends Actor {
buildTMRInnaccessible() {
const tmrInnaccessibles = this.filterItemsData(it => Draconique.isCaseTMR(it) &&
EffetsDraconiques.isInnaccessible(it));
- return tmrInnaccessibles.map(it => it.data.coord);
+ return tmrInnaccessibles.map(it => it.system.coord);
}
/* -------------------------------------------- */
getTMRRencontres() {
- return Misc.templateData(this).reve.rencontre.list;
+ return this.system.reve.rencontre.list;
}
/* -------------------------------------------- */
@@ -1541,7 +1542,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async deleteTMRRencontre(rencontreKey) {
- let list = duplicate(Misc.templateData(this).reve.rencontre.list);
+ let list = duplicate(this.system.reve.rencontre.list);
let newList = [];
for (let i = 0; i < list.length; i++) {
if (i != rencontreKey)
@@ -1558,15 +1559,14 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async reveActuelIncDec(value) {
- let mydata = Misc.templateData(this);
- let reve = Math.max(mydata.reve.reve.value + value, 0);
+ let reve = Math.max(this.system.reve.reve.value + value, 0);
await this.update({ "data.reve.reve.value": reve });
}
/* -------------------------------------------- */
async updatePointDeSeuil(value = 1) {
- const seuil = Misc.toInt(Misc.templateData(this).reve.seuil.value);
- const reve = Misc.toInt(Misc.templateData(this).carac.reve.value);
+ const seuil = Misc.toInt(this.system.reve.seuil.value);
+ const reve = Misc.toInt(this.system.carac.reve.value);
if (seuil < reve) {
await this.setPointsDeSeuil(Math.min(seuil + value, reve));
}
@@ -1574,12 +1574,12 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setPointsDeSeuil(seuil) {
- await this.update({ "data.reve.seuil.value": seuil });
+ await this.update({ "data.reve.seuil.value": seuil })
}
/* -------------------------------------------- */
async setPointsDeChance(chance) {
- await this.updateCompteurValue("chance", chance);
+ await this.updateCompteurValue("chance", chance)
}
/* -------------------------------------------- */
@@ -1626,12 +1626,12 @@ export class RdDActor extends Actor {
if (this.isEntiteCauchemar()) {
return 0;
}
- return RdDCarac.calculSConst(Misc.templateData(this).carac.constitution.value);
+ return RdDCarac.calculSConst(this.system.carac.constitution.value);
}
async ajoutXpConstitution(xp) {
- await this.update({ "data.carac.constitution.xp": Misc.toInt(Misc.templateData(this).carac.constitution.xp) + xp });
+ await this.update({ "data.carac.constitution.xp": Misc.toInt(this.system.carac.constitution.xp) + xp });
}
/* -------------------------------------------- */
@@ -1640,11 +1640,11 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
countBlessuresByName(name) {
- return this.countBlessures(Misc.templateData(this).blessures[name].liste);
+ return this.countBlessures(this.system.blessures[name].liste);
}
countBlessuresNonSoigneeByName(name) {
- let blessures = Misc.templateData(this).blessures[name].liste;
+ let blessures = this.system.blessures[name].liste;
return blessures.filter(b => b.active && !b.psdone).length;
}
@@ -1659,10 +1659,9 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async jetEndurance() {
- const actorData = Misc.data(this);
- const endurance = actorData.data.sante.endurance.value;
+ const endurance = this.system.sante.endurance.value;
- const result = await this._jetEndurance(actorData.data.sante.endurance.value)
+ const result = await this._jetEndurance(this.system.sante.endurance.value)
const message = {
content: "Jet d'Endurance : " + result.roll.total + " / " + endurance + "
",
whisper: ChatMessage.getWhisperRecipients(game.user.name)
@@ -1700,9 +1699,8 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async jetVie() {
let roll = await RdDDice.roll("1d20");
- const actorData = Misc.data(this);
- let msgText = "Jet de Vie : " + roll.total + " / " + actorData.data.sante.vie.value + "
";
- if (roll.total <= actorData.data.sante.vie.value) {
+ let msgText = "Jet de Vie : " + roll.total + " / " + this.system.sante.vie.value + "
";
+ if (roll.total <= this.system.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 (roll.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)";
@@ -1726,7 +1724,7 @@ export class RdDActor extends Actor {
if (name == 'fatigue' && !ReglesOptionelles.isUsing("appliquer-fatigue")) {
return;
}
- const sante = duplicate(Misc.templateData(this).sante);
+ const sante = duplicate(this.system.sante);
let compteur = sante[name];
if (!compteur) {
return;
@@ -1777,30 +1775,29 @@ export class RdDActor extends Actor {
}
isDead() {
- return !this.isEntiteCauchemar() && Misc.templateData(this).sante.vie.value < -this.getSConst()
+ return !this.isEntiteCauchemar() && this.system.sante.vie.value < -this.getSConst()
}
/* -------------------------------------------- */
_computeFatigueMin() {
- return Misc.templateData(this).sante.endurance.max - Misc.templateData(this).sante.endurance.value;
+ return this.system.sante.endurance.max - this.system.sante.endurance.value;
}
/* -------------------------------------------- */
_computeEnduranceMax() {
- 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 blessures = this.system.data.blessures;
+ let diffVie = this.system.data.sante.vie.max - this.system.data.sante.vie.value;
+ let maxEndVie = this.system.data.sante.endurance.max - (diffVie * 2);
let nbGraves = this.countBlessures(blessures.graves.liste);
let nbCritiques = this.countBlessures(blessures.critiques.liste);
- let maxEndGraves = Math.floor(actorData.data.sante.endurance.max / (2 * nbGraves));
- let maxEndCritiques = nbCritiques > 0 ? 1 : actorData.data.sante.endurance.max;
+ let maxEndGraves = Math.floor(this.system.data.sante.endurance.max / (2 * nbGraves));
+ let maxEndCritiques = nbCritiques > 0 ? 1 : this.system.data.sante.endurance.max;
return Math.max(0, Math.min(maxEndVie, maxEndGraves, maxEndCritiques));
}
/* -------------------------------------------- */
async manageBlessureFromSheet(gravite, index) {
- let listBlessures = duplicate(Misc.templateData(this).blessures);
+ let listBlessures = duplicate(this.system.blessures);
let blessure = listBlessures[gravite + "s"].liste[index];
blessure.active = !blessure.active;
if (!blessure.active) {
@@ -1811,7 +1808,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setDataBlessureFromSheet(gravite, index, psoins, pcomplets, jours, loc, psdone, scdone) {
- let listBlessures = duplicate(Misc.templateData(this).blessures);
+ let listBlessures = duplicate(this.system.blessures);
let blessure = listBlessures[gravite + "s"].liste[index];
blessure.psdone = psdone;
blessure.scdone = scdone;
@@ -1834,7 +1831,7 @@ export class RdDActor extends Actor {
}
async _jetDeMoral(situation) {
- const moralActuel = Misc.toInt(Misc.templateData(this).compteurs.moral.value);
+ const moralActuel = Misc.toInt(this.system.compteurs.moral.value);
const jet = await RdDDice.rollTotal("1d20");
const difficulte = 10 + moralActuel;
const succes = jet <= difficulte;
@@ -1852,21 +1849,20 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async moralIncDec(ajustementMoral) {
- let tplData = Misc.templateData(this);
if (ajustementMoral != 0) {
- let moral = Misc.toInt(tplData.compteurs.moral.value) + ajustementMoral
+ let moral = Misc.toInt(this.system.compteurs.moral.value) + ajustementMoral
if (moral > 3) { // exaltation
- const exaltation = Misc.toInt(tplData.compteurs.exaltation.value) + moral - 3;
+ const exaltation = Misc.toInt(this.system.compteurs.exaltation.value) + moral - 3;
await this.updateCompteurValue('exaltation', exaltation);
}
if (moral < -3) { // dissolution
- const dissolution = Misc.toInt(tplData.compteurs.dissolution.value) + 3 - moral;
+ const dissolution = Misc.toInt(this.system.compteurs.dissolution.value) + 3 - moral;
await this.updateCompteurValue('dissolution', dissolution);
}
moral = Math.max(-3, Math.min(moral, 3));
await this.updateCompteurValue('moral', moral);
}
- return tplData.compteurs.moral.value;
+ return this.system.compteurs.moral.value;
}
/* -------------------------------------------- */
@@ -1883,7 +1879,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async setEthylisme(degre) {
- let ethylisme = duplicate(Misc.templateData(this).compteurs.ethylisme);
+ let ethylisme = duplicate(this.system.compteurs.ethylisme);
ethylisme.value = degre;
ethylisme.nb_doses = 0;
if (degre == 1) {
@@ -1894,12 +1890,11 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async jetEthylisme() {
- const actorData = Misc.data(this);
let rollData = {
- vie: actorData.data.sante.vie.max,
+ vie: this.system.sante.vie.max,
forceAlcool: 0,
etat: this.getEtatGeneral({ ethylisme: true }),
- diffNbDoses: -Number(actorData.data.compteurs.ethylisme.nb_doses || 0),
+ diffNbDoses: -Number(this.system.data.compteurs.ethylisme.nb_doses || 0),
finalLevel: 0,
diffConditions: 0,
ajustementsForce: CONFIG.RDD.difficultesLibres,
@@ -2000,9 +1995,9 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async manger(item, doses, options = { diminuerQuantite: true }) {
- const sust = Misc.templateData(item).sust;
+ const sust = this.system.sust;
if (sust > 0) {
- await this.updateCompteurValue('sust', Misc.keepDecimals(Misc.templateData(this).compteurs.sust.value + sust * doses, 1));
+ await this.updateCompteurValue('sust', Misc.keepDecimals(this.system.compteurs.sust.value + sust * doses, 1));
}
await item.diminuerQuantite(doses, options);
}
@@ -2012,7 +2007,7 @@ export class RdDActor extends Actor {
const itemData = Misc.data(item);
const desaltere = itemData.data.desaltere;
if (desaltere > 0) {
- await this.updateCompteurValue('eau', Misc.keepDecimals(Misc.templateData(this).compteurs.eau.value + desaltere * doses, 1));
+ await this.updateCompteurValue('eau', Misc.keepDecimals(this.system.compteurs.eau.value + desaltere * doses, 1));
}
if (item.isAlcool()) {
for (let i = 0; i < doses; i++) {
@@ -2024,22 +2019,21 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async saouler(forceAlcool, alcool = undefined) {
- const actorData = Misc.data(this);
- let ethylisme = duplicate(actorData.data.compteurs.ethylisme);
+ let ethylisme = duplicate(this.system.compteurs.ethylisme);
const etat = this.getEtatGeneral({ ethylisme: true });
- const nbDoses = Number(actorData.data.compteurs.ethylisme.nb_doses || 0);
+ const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
const ethylismeData = {
alias: actorData.name,
actor: actorData,
- vie: actorData.data.sante.vie.max,
+ vie: this.system.sante.vie.max,
alcool: Misc.data(alcool),
jetVie: {
forceAlcool: forceAlcool,
nbDoses: nbDoses,
- selectedCarac: actorData.data.sante.vie,
+ selectedCarac: this.system.sante.vie,
carac: actorData.data.carac,
- caracValue: actorData.data.sante.vie.max,
+ caracValue: this.system.sante.vie.max,
finalLevel: etat + forceAlcool - nbDoses
},
}
@@ -2071,10 +2065,10 @@ export class RdDActor extends Actor {
if (ethylisme.value < 0) {
// Qui a bu boira (p 164)
ethylismeData.jetVolonte = {
- selectedCarac: actorData.data.carac.volonte,
- caracValue: actorData.data.carac.volonte.value,
+ selectedCarac: this.system.carac.volonte,
+ caracValue: this.system.carac.volonte.value,
ethylisme: ethylisme.value,
- finalLevel: ethylisme.value + actorData.data.compteurs.moral.value
+ finalLevel: ethylisme.value + this.system.compteurs.moral.value
}
await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
this._appliquerExperienceRollData(ethylismeData.jetVolonte);
@@ -2097,8 +2091,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async transformerStress() {
- const actorData = Misc.data(this);
- const stress = Misc.toInt(actorData.data.compteurs.stress.value);
+ const stress = Misc.toInt(this.system.compteurs.stress.value);
if (stress <= 0) {
return;
}
@@ -2106,8 +2099,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(actorData.data.compteurs.dissolution.value));
- let exaltation = Math.max(0, Misc.toInt(actorData.data.compteurs.exaltation.value));
+ let dissolution = Math.max(0, Misc.toInt(this.system.compteurs.dissolution.value));
+ let exaltation = Math.max(0, Misc.toInt(this.system.compteurs.exaltation.value));
const annule = Math.min(dissolution, exaltation);
dissolution -= annule;
exaltation -= annule;
@@ -2115,7 +2108,7 @@ export class RdDActor extends Actor {
let stressRollData = {
alias: this.name,
- selectedCarac: actorData.data.carac.reve,
+ selectedCarac: this.system.carac.reve,
rolled: stressRoll,
stress: stress,
perte: Math.min(conversion, stress),
@@ -2130,7 +2123,7 @@ export class RdDActor extends Actor {
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.html`, stressRollData)
});
- let compteurs = duplicate(actorData.data.compteurs);
+ let compteurs = duplicate(this.system.compteurs);
compteurs.stress.value = Math.max(stress - stressRollData.perte - 1, 0);
compteurs.experience.value += stressRollData.xp;
compteurs.dissolution.value = dissolution - perteDissolution;
@@ -2186,7 +2179,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async checkCaracXP(caracName, display = true) {
- let carac = RdDActor._findCaracByName(Misc.templateData(this).carac, caracName);
+ let carac = RdDActor._findCaracByName(this.system.carac, caracName);
if (carac && carac.xp > 0) {
const niveauSuivant = Number(carac.value) + 1;
let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
@@ -2337,8 +2330,7 @@ export class RdDActor extends Actor {
if (this.currentTMR) this.currentTMR.minimize(); // Hide
let draconicList = this.computeDraconicAndSortIndex(sortList);
- const actorData = Misc.data(this);
- const reve = duplicate(actorData.data.carac.reve);
+ const reve = duplicate(this.system.carac.reve);
let rollData = {
carac: { 'reve': reve },
forceCarac: { 'reve': reve },
@@ -2403,7 +2395,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async checkSoufflePeage(tmr) {
- let peage = this.data.items.find(item => EffetsDraconiques.isPeage(item));
+ let peage = this.items.find(item => EffetsDraconiques.isPeage(item));
if (peage && (tmr.type == 'pont' || tmr.type == 'cite')) {
await this.reveActuelIncDec(-1);
ChatMessage.create({
@@ -2425,7 +2417,7 @@ export class RdDActor extends Actor {
if (rollData.competence.name.includes('Thanatos')) { // Si Thanatos
await this.update({ "data.reve.reve.thanatosused": true });
}
- let reveActuel = Misc.templateData(this).reve.reve.value;
+ let reveActuel = this.system.reve.reve.value;
if (rolled.isSuccess) { // Réussite du sort !
if (rolled.isPart) {
rollData.depenseReve = Math.max(Math.floor(rollData.depenseReve / 2), 1);
@@ -2550,7 +2542,7 @@ export class RdDActor extends Actor {
RdDItemCompetenceCreature.setRollDataCreature(rollData);
}
else {
- rollData.carac = Misc.templateData(this).carac;
+ rollData.carac = this.system.carac;
}
console.log("rollCompetence !!!", rollData);
@@ -2599,7 +2591,6 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async rollTache(id) {
- const actorData = Misc.data(this);
const tacheData = Misc.data(this.getTache(id));
const compData = Misc.data(this.getCompetence(tacheData.data.competence));
compData.data.defaut_carac = tacheData.data.carac; // Patch !
@@ -2612,7 +2603,7 @@ export class RdDActor extends Actor {
use: { libre: false, conditions: true },
carac: {}
};
- rollData.carac[tacheData.data.carac] = duplicate(actorData.data.carac[tacheData.data.carac]); // Single carac
+ rollData.carac[tacheData.data.carac] = duplicate(this.system.carac[tacheData.data.carac]); // Single carac
console.log("rollTache !!!", rollData);
@@ -2652,7 +2643,6 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _rollArt(artData, selected, oeuvre, callBackResult = r => this._resultArt(r)) {
- const actorData = Misc.data(this);
mergeObject(artData,
{
oeuvre: oeuvre,
@@ -2661,13 +2651,13 @@ export class RdDActor extends Actor {
diffLibre: - (oeuvre.data.niveau ?? 0),
diffConditions: 0,
use: { libre: false, conditions: true },
- selectedCarac: duplicate(actorData.data.carac[selected])
+ selectedCarac: duplicate(this.system.carac[selected])
},
{ overwrite: false });
artData.competence.data.defaut_carac = selected;
if (!artData.forceCarac) {
artData.forceCarac = {};
- artData.forceCarac[selected] = duplicate(actorData.data.carac[selected]);
+ artData.forceCarac[selected] = duplicate(this.system.carac[selected]);
}
console.log("rollArt !!!", artData);
@@ -2706,14 +2696,13 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async rollDanse(id) {
- const actorData = Misc.data(this);
const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
const oeuvre = duplicate(this.getItemOfType(id, artData.art));
if (oeuvre.data.agilite) {
- artData.forceCarac['agilite'] = duplicate(actorData.data.carac.agilite);
+ artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite);
}
if (oeuvre.data.apparence) {
- artData.forceCarac['apparence'] = duplicate(actorData.data.carac.apparence);
+ artData.forceCarac['apparence'] = duplicate(this.system.carac.apparence);
}
const selectedCarac = this._getCaracDanse(oeuvre);
await this._rollArt(artData, selectedCarac, oeuvre);
@@ -2777,7 +2766,6 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async rollJeu(id) {
- const actorData = Misc.data(this);
const oeuvre = Misc.data(this.getJeu(id));
const listCarac = oeuvre.data.caraccomp.toLowerCase().split(/[.,:\/-]/).map(it => it.trim());
@@ -2788,7 +2776,7 @@ export class RdDActor extends Actor {
competence: duplicate(Misc.data(this.getCompetence('jeu'))),
forceCarac: {}
};
- listCarac.forEach(c => artData.forceCarac[c] = actorData.data.carac[c]);
+ listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]);
artData.competence.data.niveauReel = artData.competence.data.niveau;
artData.competence.data.niveau = Math.max(artData.competence.data.niveau, oeuvre.data.base);
await this._rollArt(artData, carac, oeuvre);
@@ -2811,7 +2799,7 @@ export class RdDActor extends Actor {
conditionMeditation: { isHeure: false, isVeture: false, isComportement: false, isPurification: false },
diffConditions: 0,
use: { libre: false, conditions: true, },
- carac: { "intellect": Misc.templateData(this).carac.intellect }
+ carac: { "intellect": this.system.carac.intellect }
};
const dialog = await RdDRoll.create(this, meditationData,
@@ -2877,7 +2865,7 @@ export class RdDActor extends Actor {
.map(draconic => duplicate(Misc.data(draconic)))
.map(draconic => { draconic.data.defaut_carac = "intellect"; return draconic; });
- const intellect = Misc.templateData(this).carac.intellect;
+ const intellect = this.system.carac.intellect;
let rollData = {
carac: { 'intellect': intellect },
selectedCarac: intellect,
@@ -2963,7 +2951,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async appelDestinee(onSuccess = () => { }, onEchec = () => { }) {
- let destinee = Misc.templateData(this).compteurs.destinee?.value ?? 0;
+ let destinee = this.system.compteurs.destinee?.value ?? 0;
if (destinee > 0) {
ChatMessage.create({ content: `${this.name} a fait appel à la Destinée !` });
destinee--;
@@ -2989,9 +2977,8 @@ 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(actorData.data.heure, this.name);
+ return game.system.rdd.calendrier.getAjustementAstrologique(this.system.heure, this.name);
}
/* -------------------------------------------- */
checkDesirLancinant() {
@@ -3048,7 +3035,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async _xpCarac(xpData) {
if (xpData.xpCarac > 0) {
- let carac = duplicate(Misc.templateData(this).carac);
+ let carac = duplicate(this.system.carac);
let selectedCarac = RdDActor._findCaracByName(carac, xpData.caracName);
if (!selectedCarac.derivee) {
selectedCarac.xp = Misc.toInt(selectedCarac.xp) + xpData.xpCarac;
@@ -3072,7 +3059,7 @@ export class RdDActor extends Actor {
async ajouteNombreAstral(data) {
// Gestion expérience (si existante)
data.competence = Misc.data(this.getCompetence("astrologie"));
- data.selectedCarac = Misc.templateData(this).carac["vue"];
+ data.selectedCarac = this.system.carac["vue"];
this.appliquerAjoutExperience(data, false);
// Ajout du nombre astral
@@ -3114,7 +3101,7 @@ export class RdDActor extends Actor {
type: "number"
};
}
- return RdDActor._findCaracByName(Misc.templateData(this).carac, name);
+ return RdDActor._findCaracByName(this.system.carac, name);
}
/* -------------------------------------------- */
@@ -3179,16 +3166,15 @@ export class RdDActor extends Actor {
await this.setStatusEffect("EFFECT.StatusDemiReve", true);
}
- const actorData = Misc.data(this);
- const fatigue = actorData.data.sante.fatigue.value;
- const endurance = actorData.data.sante.endurance.max;
+ const fatigue = this.system.sante.fatigue.value;
+ const endurance = this.system.sante.endurance.max;
let tmrFormData = {
mode: mode,
fatigue: RdDUtility.calculFatigueHtml(fatigue, endurance),
draconic: this.getDraconicList(),
sort: this.getSortList(),
signes: this.listItemsData("signedraconique"),
- caracReve: actorData.data.carac.reve.value,
+ caracReve: this.system.carac.reve.value,
pointsReve: this.getReveActuel(),
isRapide: isRapide
}
@@ -3200,8 +3186,8 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
rollArme(arme) {
- let competence = Misc.data(this.getCompetence(arme.data.competence));
- if (arme || (competence.type == 'competencecreature' && competence.data.iscombat)) {
+ let competence = Misc.data(this.getCompetence(arme.system.competence));
+ if (arme || (competence.type == 'competencecreature' && competence.system.iscombat)) {
if (competence.data.ispossession) {
RdDPossession.managePosession(this, competence);
} else {
@@ -3230,11 +3216,10 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
verifierForceMin(itemData) {
- const actorData = Misc.data(this);
- if (itemData.type == 'arme' && itemData.data.force > actorData.data.carac.force.value) {
+ if (itemData.type == 'arme' && itemData.data.force > this.system.carac.force.value) {
ChatMessage.create({
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})`
+ (${itemData.data.force} nécessaire pour une Force de ${this.system.carac.force.value})`
});
}
}
@@ -3322,7 +3307,7 @@ export class RdDActor extends Actor {
console.log("encaisserDommages", rollData)
- let santeOrig = duplicate(Misc.templateData(this).sante);
+ let santeOrig = duplicate(this.system.sante);
let encaissement = await this.jetEncaissement(rollData);
this.ajouterBlessure(encaissement); // Will upate the result table
@@ -3333,11 +3318,10 @@ export class RdDActor extends Actor {
this.computeEtatGeneral();
- const actorData = Misc.data(this);
mergeObject(encaissement, {
alias: this.name,
hasPlayerOwner: this.hasPlayerOwner,
- resteEndurance: actorData.data.sante.endurance.value,
+ resteEndurance: this.system.sante.endurance.value,
sonne: perteEndurance.sonne,
jetEndurance: perteEndurance.jetEndurance,
endurance: santeOrig.endurance.value - perteEndurance.newValue,
@@ -3421,12 +3405,11 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
ajouterBlessure(encaissement) {
- 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(actorData.data.sante.endurance.value);
- let blessures = duplicate(actorData.data.blessures);
+ const endActuelle = Number(this.system.sante.endurance.value);
+ let blessures = duplicate(this.system.blessures);
let count = encaissement.legeres;
// Manage blessures
@@ -3535,7 +3518,7 @@ export class RdDActor extends Actor {
|| entite.isEntiteCauchemarAccordee(this)) {
return true;
}
- const tplData = Misc.templateData(this);
+ const tplData = this.system;
let rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(Misc.templateData(entite).carac.niveau.value));
const rollData = {
alias: this.name,
@@ -3563,7 +3546,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
isEntiteCauchemarAccordee(attaquant) {
if (!this.isEntiteCauchemar()) { return true; }
- let resonnance = Misc.templateData(this).sante.resonnance;
+ let resonnance = this.system.sante.resonnance;
return (resonnance.actors.find(it => it == attaquant._id));
}
@@ -3573,7 +3556,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(Misc.templateData(this).sante.resonnance);
+ let resonnance = duplicate(this.system.sante.resonnance);
if (resonnance.actors.find(it => it == attaquant._id)) {
// déjà accordé
return;
@@ -3585,7 +3568,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
getFortune() {
- let monnaies = Monnaie.filtrerMonnaies(this.data.items);
+ let monnaies = Monnaie.filtrerMonnaies(this.items);
if (monnaies.length < 4) {
ui.notifications.error("Problème de monnaies manquantes, impossible de payer correctement!")
return 0;
@@ -3597,7 +3580,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async optimizeArgent(fortuneTotale) {
- let monnaies = Monnaie.filtrerMonnaies(this.data.items);
+ let monnaies = Monnaie.filtrerMonnaies(this.items);
let parValeur = Misc.classifyFirst(monnaies, it => Misc.templateData(it).valeur_deniers);
let nouvelleFortune = {
1000: Math.floor(fortuneTotale / 1000), // or
@@ -3790,22 +3773,22 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async effectuerTacheAlchimie(recetteId, tacheAlchimie, texteTache) {
- let recetteData = Misc.data(this.getItemOfType(recetteId, 'recettealchimique'));
- const actorData = Misc.data(this);
+ let recetteData = Misc.data(this.getItemOfType(recetteId, 'recettealchimique'))
+ const actorData = this.system
if (recetteData) {
if (tacheAlchimie != "couleur" && tacheAlchimie != "consistance") {
ui.notifications.warn(`L'étape alchimique ${tacheAlchimie} - ${texteTache} est inconnue`);
return;
}
- const sansCristal = tacheAlchimie == "couleur" && this.data.items.filter(it => it.isCristalAlchimique()).length == 0;
+ const sansCristal = tacheAlchimie == "couleur" && this.items.filter(it => it.isCristalAlchimique()).length == 0;
const caracTache = RdDAlchimie.getCaracTache(tacheAlchimie);
const alchimieData = Misc.data(this.getCompetence("alchimie"));
let rollData = {
recette: recetteData,
- carac: { [caracTache]: actorData.data.carac[caracTache] },
- selectedCarac: actorData.data.carac[caracTache],
+ carac: { [caracTache]: actorData.carac[caracTache] },
+ selectedCarac: actorData.carac[caracTache],
competence: alchimieData,
diffLibre: RdDAlchimie.getDifficulte(texteTache),
diffConditions: sansCristal ? -4 : 0,
@@ -3846,18 +3829,18 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
listeVehicules() {
- const listeVehichules = Misc.templateData(this).subacteurs?.vehicules ?? [];
+ const listeVehichules = this.system.subacteurs?.vehicules ?? [];
return this._buildActorLinksList(listeVehichules, vehicle => RdDActor._vehicleData(vehicle));
}
/* -------------------------------------------- */
listeSuivants() {
- return this._buildActorLinksList(Misc.templateData(this).subacteurs?.suivants ?? []);
+ return this._buildActorLinksList(this.system.subacteurs?.suivants ?? []);
}
/* -------------------------------------------- */
listeMontures() {
- return this._buildActorLinksList(Misc.templateData(this).subacteurs?.montures ?? []);
+ return this._buildActorLinksList(this.system.subacteurs?.montures ?? []);
}
/* -------------------------------------------- */
@@ -3928,7 +3911,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async buildPotionGuerisonList(pointsGuerison) {
let pointsGuerisonInitial = pointsGuerison;
- let myData = Misc.templateData(this);
+ let myData = this.system;
const blessures = duplicate(myData.blessures);
let guerisonData = { list: [], pointsConsommes: 0 }
diff --git a/module/item-competence.js b/module/item-competence.js
index 5c7f3156..89bdba98 100644
--- a/module/item-competence.js
+++ b/module/item-competence.js
@@ -146,7 +146,7 @@ export class RdDItemCompetence extends Item {
return competenceTroncs.map(
list => list.map(name => RdDItemCompetence.findCompetence(competences, name))
// calcul du coût xp jusqu'au niveau 0 maximum
- .map(it => RdDItemCompetence.computeDeltaXP(it?.data.base ?? -11, Math.min(it?.data.niveau ?? -11, 0)))
+ .map(it => RdDItemCompetence.computeDeltaXP(it?.system.base ?? -11, Math.min(it?.system.niveau ?? -11, 0)))
.sort(Misc.ascending())
.splice(0, list.length - 1) // prendre toutes les valeurs sauf l'une des plus élevées
.reduce(Misc.sum(), 0)
diff --git a/module/item.js b/module/item.js
index be445e19..98f94ffb 100644
--- a/module/item.js
+++ b/module/item.js
@@ -101,16 +101,16 @@ export class RdDItem extends Item {
}
getEncTotal() {
- const itemData = Misc.data(this);
- return Number(itemData.data.encombrement ?? 0) * Number(itemData.data.quantite ?? 1);
+ const itemData = this.system
+ return Number(itemData.encombrement ?? 0) * Number(itemData.quantite ?? 1);
}
getEnc() {
- const itemData = Misc.data(this);
+ const itemData = this.system
switch (itemData.type) {
case 'herbe':
return encBrin;
}
- return itemData.data.encombrement ?? 0;
+ return itemData.encombrement ?? 0
}
prepareDerivedData() {
@@ -138,7 +138,7 @@ export class RdDItem extends Item {
}
_calculsEquipement() {
- const tplData = Misc.templateData(this);
+ const tplData = this.system
const quantite = this.isConteneur() ? 1 : (tplData.quantite ?? 0);
const enc = this.getEnc();
if (enc != undefined) {
@@ -150,15 +150,15 @@ export class RdDItem extends Item {
}
getActionPrincipale(options = { warnIfNot: true }) {
- const itemData = Misc.data(this);
- if (!this.isConteneur() && (itemData.data.quantite ?? 0) <= 0) {
+ const itemData = this.system
+ if (!this.isConteneur() && (itemData.quantite ?? 0) <= 0) {
if (options.warnIfNot) {
ui.notifications.warn(`Vous n'avez plus de ${itemData.name}.`);
}
return undefined;
}
switch (itemData.type) {
- case 'nourritureboisson': return itemData.data.boisson ? 'Boire' : 'Manger';
+ case 'nourritureboisson': return itemData.boisson ? 'Boire' : 'Manger';
case 'potion': return 'Boire';
case 'livre': return 'Lire';
case 'conteneur': return 'Ouvrir';
@@ -177,8 +177,8 @@ export class RdDItem extends Item {
}
async quantiteIncDec(nombre, options = { diminuerQuantite: true, supprimerSiZero: false }) {
- const itemData = Misc.data(this);
- const quantite = Number(itemData.data.quantite ?? -1);
+ const itemData = this.system
+ const quantite = Number(itemData.quantite ?? -1);
if (quantite >= 0) {
const reste = Math.max(quantite + Number(nombre), 0);
@@ -201,8 +201,8 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
// détermine si deux équipements sont similaires: de même type, et avec les même champs hormis la quantité
isEquipementSimilaire(other) {
- const itemData = Misc.data(this);
- const otherData = Misc.data(other);
+ const itemData = this.system
+ const otherData = other.data
const tplData = Misc.templateData(this);
const otherTplData = Misc.templateData(other);
if (!this.isEquipement()) return false;
diff --git a/module/misc.js b/module/misc.js
index 59fc080c..02d296e5 100644
--- a/module/misc.js
+++ b/module/misc.js
@@ -108,13 +108,14 @@ export class Misc {
static data(it) {
if (it instanceof Actor || it instanceof Item || it instanceof Combatant) {
- return it.data;
+ return it.system
}
- return it;
+ return it
}
static templateData(it) {
- return Misc.data(it)?.data ?? {}
+ return it.system ?? {}
+ //return Misc.data(it)?.system ?? {}
}
static getEntityTypeLabel(entity) {
diff --git a/module/rdd-combat.js b/module/rdd-combat.js
index ea574f09..21ed8a4d 100644
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -155,12 +155,13 @@ export class RdDCombatManager extends Combat {
// Gestion des armes 1/2 mains
let armesEquipe = [];
for (const arme of armes) {
- let armeData = duplicate(Misc.data(arme));
+ let armeData = duplicate(arme)
if (armeData.data.equipe) {
let compData = competences.map(c => Misc.data(c)).find(c => c.name == armeData.data.competence);
- armesEquipe.push(armeData);
+ armesEquipe.push(armeData)
armeData.data.dommagesReels = Number(armeData.data.dommages);
+ console.log("ARME", armeData, compData)
armeData.data.niveau = compData.data.niveau;
armeData.data.initiative = RdDCombatManager.calculInitiative(compData.data.niveau, carac[compData.data.defaut_carac].value);
// Dupliquer les armes pouvant être à 1 main et 2 mains en patchant la compétence
diff --git a/module/rdd-main.js b/module/rdd-main.js
index ba58e175..f89c0535 100644
--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@@ -225,6 +225,7 @@ function registerUsageCount( registerKey ) {
name: "Unique world key",
scope: "world",
config: false,
+ value: "EMPTY",
type: String
});
@@ -268,7 +269,7 @@ Hooks.once("ready", async function () {
}
if (Misc.isUniqueConnectedGM()) {
messageDeBienvenue();
- registerUsageCount( SYSTEM_RDD );
+ registerUsageCount( SYSTEM_RDD )
}
});
diff --git a/module/rdd-roll.js b/module/rdd-roll.js
index 41c38ff5..aae05e03 100644
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@@ -38,19 +38,18 @@ 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: actorData.data.carac,
+ carac: actor.system.carac,
finalLevel: 0,
diffConditions: 0,
diffLibre: rollData.competence?.data.default_diffLibre ?? 0,
malusArmureValue: actor.getMalusArmure(),
- surencMalusFlag: actor.isPersonnage() ? (actorData.data.compteurs.surenc.value < 0) : false,
+ surencMalusFlag: actor.isPersonnage() ? (actor.system.compteurs.surenc.value < 0) : false,
surencMalusValue: actor.computeMalusSurEncombrement(),
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/system.json b/system.json
index ee56f3b2..ad77510c 100644
--- a/system.json
+++ b/system.json
@@ -29,9 +29,9 @@
"url": "https://gitlab.com/LeRatierBretonnien/foundryvtt-reve-de-dragon/",
"license": "LICENSE.txt",
"flags": {},
- "version": "1.5.68",
- "minimumCoreVersion": "0.8.0",
- "compatibleCoreVersion": "9",
+ "version": "10.0.0",
+ "minimumCoreVersion": "10",
+ "compatibleCoreVersion": "10",
"scripts": [],
"esmodules": [
"module/rdd-main.js"