public/foundryvtt-reve-de-dragon
1
1
Fork 1
Code Issues 4 Pull Requests Actions Projects Releases 186 Wiki Activity

Big WIP...

Browse Source
This commit is contained in:
sladecraven
2022-06-12 09:46:58 +02:00
parent 6b48839841
commit 0228d5bc56
55 changed files with 412 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
module/actor-entite-sheet.js
View File

@ -25,7 +25,7 @@ export class RdDActorEntiteSheet extends ActorSheet {
/* -------------------------------------------- */
async getData() {
const objectData = Misc.data(this.object);
const objectData = this.object;
let formData = {
title: this.title,
id: objectData.id,

12
module/actor-sheet.js
View File

@ -94,7 +94,7 @@ export class RdDActorSheet extends ActorSheet {
RdDItemArme.ajoutCorpsACorps(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);
console.log("COMBAT STUFF", formData.combat, formData.armes)
this.armesList = formData.combat;
// Common data
@ -137,9 +137,9 @@ export class RdDActorSheet extends ActorSheet {
/* -------------------------------------------- */
async _onDropItem(event, dragData) {
const destItemId = $(event.target)?.closest('.item').attr('data-item-id');
const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur);
const callSuper = await this.actor.processDropItem(dropParams);
const destItemId = $(event.target)?.closest('.item').attr('data-item-id')
const dropParams = RdDSheetUtility.prepareItemDropParameters(destItemId, this.actor.id, dragData, this.objetVersConteneur)
const callSuper = await this.actor.processDropItem(dropParams)
if (callSuper) {
await super._onDropItem(event, dragData)
}
@ -518,9 +518,9 @@ export class RdDActorSheet extends ActorSheet {
const li = $(event.currentTarget)?.parents(".item");
let armeName = li.data("arme-name");
let compName = li.data('competence-name');
const arme = this.armesList.find(a => a.name == armeName && a.data.competence == compName);
const arme = this.armesList.find(a => a.name == armeName && a.system.competence == compName);
if (!arme) {
return { name: armeName, data: { competence: compName } };
return { name: armeName, system: { competence: compName } };
}
return arme;
}

6
module/actor-vehicule-sheet.js
View File

@ -27,7 +27,7 @@ export class RdDActorVehiculeSheet extends ActorSheet {
/* -------------------------------------------- */
async getData() {
const objectData = Misc.data(this.object);
const objectData = this.object
let formData = {
title: this.title,
id: objectData.id,
@ -36,7 +36,7 @@ export class RdDActorVehiculeSheet 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,
@ -82,7 +82,7 @@ export class RdDActorVehiculeSheet extends ActorSheet {
async monnaieIncDec(id, value) {
let monnaie = this.getMonnaie(id);
if (monnaie) {
const quantite = Math.max(0, Misc.templateData(monnaie).quantite + value);
const quantite = Math.max(0, monnaie.system.quantite + value);
await this.updateEmbeddedDocuments('Item', [{ _id: monnaie.id, 'data.quantite': quantite }]);
}
}

309
module/actor.js
View File

@ -553,7 +553,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;
@ -580,7 +580,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) {
@ -595,14 +595,13 @@ 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", actorData.data.sante.endurance.max - actorData.data.sante.endurance.value);
await this.santeIncDec("endurance", this.system.sante.endurance.max - this.system.sante.endurance.value);
}
else {
if (actorData.data.blessures) {
const blessures = duplicate(actorData.data.blessures);
if (this.system.blessures) {
const blessures = duplicate(this.system.blessures);
for (let listeBlessures of [blessures.legeres.liste, blessures.graves.liste, blessures.critiques.liste]) {
for (let blessure of listeBlessures) {
this._supprimerBlessure(blessure);
@ -614,10 +613,10 @@ export class RdDActor extends Actor {
await this.setEthylisme(1);
}
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 (ReglesOptionelles.isUsing("appliquer-fatigue") && actorData.data.sante.fatigue) {
await this.update({ "data.sante.fatigue.value": 0 });
await this.santeIncDec("vie", this.system.sante.vie.max - this.system.sante.vie.value);
await this.santeIncDec("endurance", this.system.sante.endurance.max - this.system.sante.endurance.value);
if (ReglesOptionelles.isUsing("appliquer-fatigue") && this.system.sante.fatigue) {
await this.update({ "system.sante.fatigue.value": 0 });
}
}
ChatMessage.create(message);
@ -668,7 +667,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) {
@ -682,7 +681,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. ";
@ -692,7 +691,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;
@ -707,7 +706,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++) {
@ -727,7 +726,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");
@ -748,7 +747,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 += `<br>Votre rêve redescend vers son seuil naturel (${seuil}, nouveau rêve actuel ${(reveActuel - 1)})`;
@ -757,7 +756,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;
@ -811,10 +810,10 @@ export class RdDActor extends Actor {
async resultCombatReveDeDragon(rollData) {
rollData.queues = [];
if (rollData.rolled.isEchec) {
rollData.queues.push(Misc.data(await this.ajouterQueue()));
rollData.queues.push( await this.ajouterQueue());
}
if (rollData.rolled.isETotal) {
rollData.queues.push(Misc.data(await this.ajouterQueue()));
rollData.queues.push(await this.ajouterQueue());
}
if (rollData.rolled.isSuccess) {
await this.updatePointDeSeuil();
@ -834,7 +833,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();
@ -876,7 +875,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);
@ -896,9 +895,8 @@ export class RdDActor extends Actor {
async updateCompetenceXPAuto(idOrName) {
let competence = this.getCompetence(idOrName);
if (competence) {
let compData = Misc.data(competence);
let xp = Number(compData.data.xp);
let niveau = Number(compData.data.niveau);
let xp = Number(competence.system.xp);
let niveau = Number(competence.system.niveau);
while (xp >= RdDItemCompetence.getCompetenceNextXp(niveau) && xp > 0) {
xp -= RdDItemCompetence.getCompetenceNextXp(niveau);
niveau++;
@ -916,28 +914,27 @@ export class RdDActor extends Actor {
if (!competence) {
return;
}
const compData = Misc.data(competence);
const niveau = Number(compData.data.niveau);
const stressTransforme = Misc.data(this).data.compteurs.experience.value;
const xpRequis = RdDItemCompetence.getCompetenceNextXp(niveau) - compData.data.xp;
if (stressTransforme <= 0 || niveau >= compData.data.niveau_archetype || xpRequis <= 0) {
const niveau = Number(competence.system.niveau);
const stressTransforme = this.system.compteurs.experience.value;
const xpRequis = RdDItemCompetence.getCompetenceNextXp(niveau) - competence.system.xp;
if (stressTransforme <= 0 || niveau >= competence.system.niveau_archetype || xpRequis <= 0) {
ui.notifications.info(`La compétence ne peut pas augmenter!
stress disponible: ${stressTransforme}
expérience requise: ${xpRequis}
niveau : ${niveau}
archétype : ${compData.data.niveau_archetype}`);
archétype : ${competence.system.niveau_archetype}`);
return;
}
const xpUtilise = Math.min(stressTransforme, xpRequis);
const gainNiveau = xpUtilise >= xpRequis ? 1 : 0;
const nouveauNiveau = niveau + gainNiveau;
const nouveauXp = gainNiveau > 0 ? Math.max(compData.data.xp - xpRequis, 0) : (compData.data.xp + xpUtilise);
const nouveauXp = gainNiveau > 0 ? Math.max(competence.system.xp - xpRequis, 0) : (competence.system.xp + xpUtilise);
await competence.update({
"data.xp": nouveauXp,
"data.niveau": nouveauNiveau,
"system.xp": nouveauXp,
"system.niveau": nouveauNiveau,
});
const stressTransformeRestant = Math.max(0, stressTransforme - xpUtilise);
await this.update({ "data.compteurs.experience.value": stressTransformeRestant });
await this.update({ "system.compteurs.experience.value": stressTransformeRestant });
this.updateExperienceLog('Dépense stress', xpUtilise, `Stress en ${competence.name} ${gainNiveau ? "pour passer à " + nouveauNiveau : ""}`);
}
@ -960,10 +957,10 @@ export class RdDActor extends Actor {
async updateCompetence(idOrName, compValue) {
let competence = this.getCompetence(idOrName);
if (competence) {
let nouveauNiveau = compValue ?? RdDItemCompetence.getNiveauBase(Misc.data(competence).data.categorie);
let nouveauNiveau = compValue ?? RdDItemCompetence.getNiveauBase(competence.system.categorie);
const tronc = RdDItemCompetence.getListTronc(competence.name).filter(it => {
const comp = this.getCompetence(it);
const niveauTr = comp? Misc.data(comp).data.niveau : 0;
const niveauTr = competence? competence.system.niveau : 0;
return niveauTr < 0 && niveauTr < nouveauNiveau;
});
if (tronc.length > 0) {
@ -1027,7 +1024,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()}`
@ -1044,7 +1041,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);
}
@ -1078,7 +1075,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 this.system.contenu) {
let subObjet = this.getObjet(id);
if (subObjet?.id == conteneur.id) {
return true; // Loop detected !
@ -1096,7 +1093,7 @@ export class RdDActor extends Actor {
if (!objet) {
return 0;
}
const tplData = Misc.templateData(objet);
const tplData = objet.system;
if (objet.type != 'conteneur') {
return Number(tplData.encombrement) * Number(tplData.quantite);
}
@ -1109,7 +1106,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 this.system.contenu) {
let subObj = this.getObjet(subId);
if (subObj) {
if (subObj.type == 'conteneur') {
@ -1134,14 +1131,14 @@ export class RdDActor extends Actor {
* de leurs ID */
async enleverDeConteneur(item, conteneur, onEnleverDeConteneur) {
if (conteneur?.isConteneur()) {
let data2use = duplicate(Misc.data(conteneur));
let contenu = data2use.data.contenu;
let data2use = duplicate(conteneur);
let contenu = data2use.system.contenu;
let index = contenu.indexOf(item.id);
while (index >= 0) { // Force cleanup, itemId is unique
contenu.splice(index, 1);
index = contenu.indexOf(item.id);
}
item.data.estContenu = false;
item.system.estContenu = false;
await this.updateEmbeddedDocuments('Item', [data2use]);
onEnleverDeConteneur();
}
@ -1152,7 +1149,7 @@ export class RdDActor extends Actor {
* de leurs ID */
async ajouterDansConteneur(item, conteneur, onAjouterDansConteneur) {
if (conteneur?.isConteneur()) {
let data2use = duplicate(Misc.data(conteneur));
let data2use = duplicate(conteneur);
data2use.data.contenu.push(item.id);
item.data.estContenu = true;
await this.updateEmbeddedDocuments('Item', [data2use]);
@ -1165,12 +1162,11 @@ export class RdDActor extends Actor {
async nettoyerConteneurs() {
const corrections = [];
for (let item of this.items) {
let itemData = Misc.data(item);
if (itemData.estContenu) {
itemData.estContenu = undefined;
if (item.estContenu) {
item.estContenu = undefined;
}
if (itemData.type == 'conteneur' && itemData.data.contenu.length > 0) {
corrections.push({ _id: itemData._id, 'data.contenu': [] });
if (item.type == 'conteneur' && item.system.contenu.length > 0) {
corrections.push({ _id: itemData._id, 'system.contenu': [] });
}
}
if (corrections.length > 0) {
@ -1219,20 +1215,20 @@ export class RdDActor extends Actor {
if (!dest.isConteneur()) {
return false;
}
const destData = Misc.data(dest);
const destData = dest
if (this._isConteneurContenu(item, dest)) {
ui.notifications.warn(`Impossible de déplacer un conteneur parent (${item.name}) dans un de ses contenus ${destData.name} !`);
return false; // Loop detected !
}
// Calculer le total actuel des contenus
let encContenu = this.getRecursiveEnc(dest) - Number(destData.data.encombrement);
let encContenu = this.getRecursiveEnc(dest) - Number(destData.system.encombrement);
let newEnc = this.getRecursiveEnc(item); // Calculer le total actuel du nouvel objet
// Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
if (Number(destData.data.capacite) < encContenu + newEnc) {
if (Number(destData.system.capacite) < encContenu + newEnc) {
ui.notifications.warn(
`Le conteneur ${dest.name} a une capacité de ${destData.data.capacite}, et contient déjà ${encContenu}.
`Le conteneur ${dest.name} a une capacité de ${destData.system.capacite}, et contient déjà ${encContenu}.
Impossible d'y ranger: ${item.name} d'encombrement ${newEnc}!`);
return false;
}
@ -1248,8 +1244,8 @@ export class RdDActor extends Actor {
sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
const itemsDataToCreate = itemsList.map(it => sourceActor.getObjet(it.id))
.map(it => duplicate(Misc.data(it)))
.map(it => { it.data.contenu = []; return it; });
.map(it => duplicate(it))
.map(it => { it.system.contenu = []; return it; });
let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);
let itemMap = this._buildMapOldNewId(itemsList, newItems);
@ -1263,7 +1259,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(this.system.contenu);
contenu.push(newItemId);
await this.updateEmbeddedDocuments('Item', [{ _id: newConteneurId, 'data.contenu': contenu }]);
}
@ -1282,7 +1278,7 @@ export class RdDActor extends Actor {
}
async regrouperEquipementsSimilaires(item, dest) {
await dest.quantiteIncDec(Misc.templateData(item).quantite);
await dest.quantiteIncDec(item.system.quantite);
await item.delete();
}
@ -1362,7 +1358,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);
@ -1414,7 +1410,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ajouterRefoulement(value = 1) {
let refoulement = Misc.templateData(this).reve.refoulement.value + value;
let refoulement = this.system.reve.refoulement.value + value;
let total = await RdDDice.rollTotal("1d20");
if (total <= refoulement) {
refoulement = 0;
@ -1426,7 +1422,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async ajouterSouffle(options = { chat: false }) {
let souffle = Misc.data(await RdDRollTables.getSouffle());
let souffle = await RdDRollTables.getSouffle();
souffle._id = undefined; //TBC
await this.createEmbeddedDocuments('Item', [souffle]);
if (options.chat) {
@ -1441,12 +1437,12 @@ 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());
if (this.system.reve.reve.thanatosused) {
queue = await RdDRollTables.getOmbre();
await this.update({ "data.reve.reve.thanatosused": false });
}
else {
queue = Misc.data(await RdDRollTables.getQueue());
queue = await RdDRollTables.getQueue();
}
await this.createEmbeddedDocuments('Item', [queue]);
if (options.chat) {
@ -1513,7 +1509,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
getTMRRencontres() {
return Misc.templateData(this).reve.rencontre.list;
return this.system.reve.rencontre.list;
}
/* -------------------------------------------- */
@ -1998,14 +1994,14 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async boire(item, doses, options = { diminuerQuantite: true }) {
const itemData = Misc.data(item);
const desaltere = itemData.data.desaltere;
const itemData = item;
const desaltere = itemData.system.desaltere;
if (desaltere > 0) {
await this.updateCompteurValue('eau', Misc.keepDecimals(this.system.compteurs.eau.value + desaltere * doses, 1));
}
if (item.isAlcool()) {
for (let i = 0; i < doses; i++) {
await this.saouler(itemData.data.force, item);
await this.saouler(itemData.system.force, item);
}
}
await item.diminuerQuantite(doses, options);
@ -2021,7 +2017,7 @@ export class RdDActor extends Actor {
alias: this.name,
actor: this,
vie: this.system.sante.vie.max,
alcool: Misc.data(alcool),
alcool: alcool,
jetVie: {
forceAlcool: forceAlcool,
nbDoses: nbDoses,
@ -2173,7 +2169,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);
@ -2200,24 +2196,24 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async checkCompetenceXP(compName, newXP, display = true) {
let compData = Misc.data(this.getCompetence(compName));
if (compData && newXP && newXP == compData.data.xp) { // Si édition, mais sans changement XP
let compData = this.getCompetence(compName);
if (compData && newXP && newXP == compData.system.xp) { // Si édition, mais sans changement XP
return;
}
newXP = (newXP) ? newXP : compData.data.xp;
newXP = (newXP) ? newXP : compData.system.xp;
if (compData && newXP > 0) {
let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.data.niveau + 1);
let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1);
if (newXP >= xpNeeded) {
let newCompData = duplicate(compData);
newCompData.data.niveau += 1;
newCompData.data.xp = newXP;
newCompData.system.niveau += 1;
newCompData.system.xp = newXP;
let checkXp = {
alias: this.name,
competence: newCompData.name,
niveau: newCompData.data.niveau,
xp: newCompData.data.xp,
archetype: newCompData.data.niveau_archetype,
archetypeWarning: newCompData.data.niveau > compData.data.niveau_archetype
niveau: newCompData.system.niveau,
xp: newCompData.system.xp,
archetype: newCompData.system.niveau_archetype,
archetypeWarning: newCompData.system.niveau > compData.system.niveau_archetype
}
if (display) {
ChatMessage.create({
@ -2277,15 +2273,15 @@ export class RdDActor extends Actor {
computeDraconicAndSortIndex(sortList) {
let draconicList = this.getDraconicList()
.map(it => {
it = duplicate(Misc.data(it))
it = duplicate(it)
it.data.defaut_carac = "reve";
return it;
});
for (let sort of sortList) {
let draconicsSort = this.getDraconicsSort(draconicList, sort).map(it => it.name);
for (let index = 0; index < draconicList.length && sort.data.listIndex == undefined; index++) {
for (let index = 0; index < draconicList.length && sort.system.listIndex == undefined; index++) {
if (draconicsSort.includes(draconicList[index].name)) {
sort.data.listIndex = index;
sort.system.listIndex = index;
}
}
}
@ -2300,7 +2296,7 @@ export class RdDActor extends Actor {
case "detection d'aura":
return draconicList;
case "annulation de magie":
return draconicList.filter(it => !Grammar.toLowerCaseNoAccent(Misc.data(it).name).includes('thanatos'));
return draconicList.filter(it => !Grammar.toLowerCaseNoAccent(it.name).includes('thanatos'));
}
return [RdDItemCompetence.getVoieDraconic(draconicList, sort.data.draconic)];
}
@ -2324,8 +2320,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 },
@ -2411,7 +2406,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);
@ -2489,11 +2484,11 @@ export class RdDActor extends Actor {
ui.notifications.warn(`${this.name} n'a pas de caractéristique correspondant à ${caracName}`)
return;
}
const competence = Misc.data(this.getCompetence(compName));
const competence = this.getCompetence(compName);
if (options.apprecier && competence) {
const minQualite = Math.max(0, competence.data.niveau);
const minQualite = Math.max(0, competence.system.niveau);
if (diff <= minQualite) {
ui.notifications.info(`${this.name} a un niveau ${competence.data.niveau} en ${competence.name}, trop élevé pour apprécier la qualité de ${diff}`)
ui.notifications.info(`${this.name} a un niveau ${competence.system.niveau} en ${competence.name}, trop élevé pour apprécier la qualité de ${diff}`)
return;
}
}
@ -2522,11 +2517,11 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async rollCompetence(idOrName) {
let rollData = { competence: Misc.data(this.getCompetence(idOrName)) }
let rollData = { competence: this.getCompetence(idOrName) }
if (rollData.competence.type == 'competencecreature') {
if (rollData.competence.data.iscombat) {
if (rollData.competence.data.ispossession) {
if (rollData.competence.system.iscombat) {
if (rollData.competence.system.ispossession) {
RdDPossession.managePossession(this, rollData.competence)
} else {
const arme = RdDItemCompetenceCreature.toArme(rollData.competence)
@ -2566,7 +2561,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async creerTacheDepuisLivre(item, options = { renderSheet: true }) {
const itemData = Misc.data(item);
const itemData = item
const nomTache = "Lire " + itemData.name;
const filterTacheLecture = it => it.type == 'tache' && it.name == nomTache;
let tachesExistantes = this.filterItems(filterTacheLecture);
@ -2576,12 +2571,12 @@ export class RdDActor extends Actor {
data: {
carac: 'intellect',
competence: 'Ecriture',
difficulte: itemData.data.difficulte,
difficulte: itemData.system.difficulte,
periodicite: "60 minutes",
fatigue: 2,
points_de_tache: itemData.data.points_de_tache,
points_de_tache: itemData.system.points_de_tache,
points_de_tache_courant: 0,
description: "Lecture du livre " + item.name + " - XP : " + itemData.data.xp + " - Compétences : " + itemData.data.competence
description: "Lecture du livre " + item.name + " - XP : " + itemData.system.xp + " - Compétences : " + itemData.system.competence
}
}
await this.createEmbeddedDocuments('Item', [tache], options);
@ -2592,20 +2587,19 @@ 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 !
const tacheData = this.getTache(id)
const compData = this.getCompetence(tacheData.system.competence)
compData.system.defaut_carac = tacheData.system.carac; // Patch !
let rollData = {
competence: compData,
tache: tacheData,
diffLibre: tacheData.data.difficulte,
diffLibre: tacheData.system.difficulte,
diffConditions: 0,
use: { libre: false, conditions: true },
carac: {}
};
rollData.carac[tacheData.data.carac] = duplicate(actorData.data.carac[tacheData.data.carac]); // Single carac
rollData.carac[tacheData.system.carac] = duplicate(this.system.carac[tacheData.system.carac]); // Single carac
console.log("rollTache !!!", rollData);
@ -2626,19 +2620,19 @@ export class RdDActor extends Actor {
// Mise à jour de la tache
rollData.appliquerFatigue = ReglesOptionelles.isUsing("appliquer-fatigue");
rollData.tache = duplicate(rollData.tache);
rollData.tache.data.points_de_tache_courant += rollData.rolled.ptTache;
rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache;
if (rollData.rolled.isETotal) {
rollData.tache.data.difficulte--;
rollData.tache.system.difficulte--;
}
if (rollData.rolled.isSuccess) {
rollData.tache.data.nb_jet_succes++;
rollData.tache.system.nb_jet_succes++;
} else {
rollData.tache.data.nb_jet_echec++;
rollData.tache.system.nb_jet_echec++;
}
rollData.tache.data.tentatives = rollData.tache.data.nb_jet_succes + rollData.tache.data.nb_jet_echec;
rollData.tache.system.tentatives = rollData.tache.system.nb_jet_succes + rollData.tache.system.nb_jet_echec;
this.updateEmbeddedDocuments('Item', [rollData.tache]);
this.santeIncDec("fatigue", rollData.tache.data.fatigue);
this.santeIncDec("fatigue", rollData.tache.system.fatigue);
await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-tache.html');
}
@ -2862,7 +2856,7 @@ export class RdDActor extends Actor {
if (this.currentTMR) this.currentTMR.minimize(); // Hide
let draconicList = this.getDraconicList()
.map(draconic => duplicate(Misc.data(draconic)))
.map(draconic => duplicate(draconic))
.map(draconic => { draconic.system.defaut_carac = "intellect"; return draconic; });
const intellect = this.system.carac.intellect;
@ -3185,9 +3179,9 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
rollArme(arme) {
let competence = this.getCompetence(arme.data.competence)
let competence = this.getCompetence(arme.system.competence)
if (arme || (competence.type == 'competencecreature' && competence.system.iscombat)) {
if (competence.data.ispossession) {
if (competence.system.ispossession) {
RdDPossession.managePossession(this, competence);
} else {
RdDCombat.createUsingTarget(this)?.attaque(competence, arme);
@ -3226,15 +3220,14 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async equiperObjet(itemID) {
let item = this.getEmbeddedDocument('Item', itemID);
let itemData = Misc.data(item);
if (itemData?.data) {
const isEquipe = !itemData.data.equipe;
let update = { _id: item.id, "data.equipe": isEquipe };
if (item?.system) {
const isEquipe = !item.system.equipe;
let update = { _id: item.id, "system.equipe": isEquipe };
await this.updateEmbeddedDocuments('Item', [update]);
this.computeEncombrementTotalEtMalusArmure(); // Mise à jour encombrement
this.computePrixTotalEquipement(); // Mis à jour du prix total de l'équipement
if (isEquipe)
this.verifierForceMin(itemData);
this.verifierForceMin(item);
}
}
@ -3243,16 +3236,15 @@ export class RdDActor extends Actor {
let dmg = (attackerRoll.dmg.dmgArme ?? 0) + (attackerRoll.dmg.dmgActor ?? 0);
let armeData = attackerRoll.arme;
let protection = 0;
const armures = this.items.map(it => Misc.data(it))
.filter(it => it.type == "armure" && it.data.equipe);
const armures = this.items.filter(it => it.type == "armure" && it.system.equipe);
for (const itemData of armures) {
protection += await RdDDice.rollTotal(itemData.data.protection.toString());
protection += await RdDDice.rollTotal(itemData.system.protection.toString());
if (dmg > 0) {
this._deteriorerArmure(itemData, dmg);
dmg = 0;
}
}
const penetration = Misc.toInt(armeData?.data.penetration ?? 0);
const penetration = Misc.toInt(armeData?.system.penetration ?? 0);
protection = Math.max(protection - penetration, 0);
protection += this.getProtectionNaturelle();
// Gestion des cas particuliers sur la fenêtre d'encaissement
@ -3268,30 +3260,30 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
_deteriorerArmure(item, dmg) {
let itemData = duplicate(Misc.data(item));
if (!ReglesOptionelles.isUsing('deteriorationArmure') || itemData.data.protection == '0') {
let itemData = duplicate(item);
if (!ReglesOptionelles.isUsing('deteriorationArmure') || itemData.system.protection == '0') {
return;
}
itemData.data.deterioration = (itemData.data.deterioration ?? 0) + dmg;
if (itemData.data.deterioration >= 10) {
itemData.data.deterioration -= 10;
let res = /(\d+)?d(\d+)(\-\d+)?/.exec(itemData.data.protection);
itemData.data.deterioration = (itemData.system.deterioration ?? 0) + dmg;
if (itemData.system.deterioration >= 10) {
itemData.system.deterioration -= 10;
let res = /(\d+)?d(\d+)(\-\d+)?/.exec(itemData.system.protection);
if (res) {
let malus = Misc.toInt(res[3]) - 1;
let armure = Misc.toInt(res[2]);
if (armure+malus <= 0){
itemData.data.protection = 0;
itemData.system.protection = 0;
} else {
itemData.data.protection = '' + (res[1]??'1') + 'd' + armure + malus;
itemData.system.protection = '' + (res[1]??'1') + 'd' + armure + malus;
}
}
else if (/\d+/.exec(itemData.data.protection)) {
itemData.data.protection = "1d" + itemData.data.protection;
else if (/\d+/.exec(itemData.system.protection)) {
itemData.system.protection = "1d" + itemData.system.protection;
}
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 " + itemData.data.protection });
ChatMessage.create({ content: "Votre armure s'est détériorée, elle protège maintenant de " + itemData.system.protection });
}
this.updateEmbeddedDocuments('Item', [itemData]);
}
@ -3311,7 +3303,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
@ -3322,11 +3314,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,
@ -3410,12 +3401,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 (this.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
@ -3524,8 +3514,8 @@ export class RdDActor extends Actor {
|| entite.isEntiteCauchemarAccordee(this)) {
return true;
}
const tplData = Misc.templateData(this);
let rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(Misc.templateData(entite).carac.niveau.value));
const tplData = this.system;
let rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(entite.system.carac.niveau.value));
const rollData = {
alias: this.name,
rolled: rolled,
@ -3562,7 +3552,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;
@ -3579,7 +3569,7 @@ export class RdDActor extends Actor {
ui.notifications.error("Problème de monnaies manquantes, impossible de payer correctement!")
throw "Problème de monnaies manquantes, impossible de payer correctement!";
}
return monnaies.map(m => Misc.templateData(m))
return monnaies.map(m => this.system)
.map(tpl => tpl.valeur_deniers * Number(tpl.quantite))
.reduce(Misc.sum(), 0);
}
@ -3587,7 +3577,7 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async optimizeArgent(fortuneTotale) {
let monnaies = Monnaie.filtrerMonnaies(this.data.items);
let parValeur = Misc.classifyFirst(monnaies, it => Misc.templateData(it).valeur_deniers);
let parValeur = Misc.classifyFirst(monnaies, it => this.system.valeur_deniers);
let nouvelleFortune = {
1000: Math.floor(fortuneTotale / 1000), // or
100: Math.floor(fortuneTotale / 100) % 10, // argent
@ -3683,7 +3673,7 @@ export class RdDActor extends Actor {
async monnaieIncDec(id, value) {
let monnaie = this.getMonnaie(id);
if (monnaie) {
const quantite = Math.max(0, Misc.templateData(monnaie).quantite + value);
const quantite = Math.max(0, monnaie.system.quantite + value);
await this.updateEmbeddedDocuments('Item', [{ _id: monnaie.id, 'data.quantite': quantite }]);
}
}
@ -3721,15 +3711,15 @@ export class RdDActor extends Actor {
return;
}
}
const itemVendu = Misc.data(vendeur?.getObjet(itemId));
const itemVendu = vendeur?.getObjet(itemId);
if (itemVendu) {
if (isItemEmpilable ? (itemVendu.data.quantite < achat.quantiteTotal) : (achat.choix.nombreLots != 1)) {
if (isItemEmpilable ? (itemVendu.system.quantite < achat.quantiteTotal) : (achat.choix.nombreLots != 1)) {
await acheteur?.ajouterDeniers(coutDeniers);
ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a plus assez de ${vente.item.name} !`);
return;
}
vendeur.ajouterDeniers(coutDeniers);
let resteQuantite = (itemVendu.data.quantite ?? 1) - achat.quantiteTotal;
let resteQuantite = (itemVendu.system.quantite ?? 1) - achat.quantiteTotal;
if (resteQuantite == 0) {
vendeur.deleteEmbeddedDocuments("Item", [itemId])
}
@ -3742,7 +3732,7 @@ export class RdDActor extends Actor {
type: vente.item.type,
img: vente.item.img,
name: vente.item.name,
data: mergeObject(vente.item.data, { quantite: isItemEmpilable ? achat.quantiteTotal : undefined }),
data: mergeObject(vente.item.system, { quantite: isItemEmpilable ? achat.quantiteTotal : undefined }),
}
let listeAchat = isItemEmpilable ? [achatData] : Array.from({ length: achat.quantiteTotal }, (_, i) => achatData)
let items = await acheteur.createEmbeddedDocuments("Item", listeAchat)
@ -3779,22 +3769,21 @@ 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 = this.getItemOfType(recetteId, 'recettealchimique');
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"));
const alchimieData = this.getCompetence("alchimie");
let rollData = {
recette: recetteData,
carac: { [caracTache]: actorData.data.carac[caracTache] },
selectedCarac: actorData.data.carac[caracTache],
carac: { [caracTache]: this.system.carac[caracTache] },
selectedCarac: this.system.carac[caracTache],
competence: alchimieData,
diffLibre: RdDAlchimie.getDifficulte(texteTache),
diffConditions: sansCristal ? -4 : 0,
@ -3804,7 +3793,7 @@ export class RdDActor extends Actor {
sansCristal: sansCristal
}
}
rollData.competence.data.defaut_carac = caracTache;
rollData.competence.system.defaut_carac = caracTache;
const dialog = await RdDRoll.create(this, rollData,
{
@ -3914,7 +3903,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 }
@ -4072,11 +4061,11 @@ export class RdDActor extends Actor {
/* -------------------------------------------- */
async consommerPotion(potion, onActionItem = async () => {}) {
const potionData = Misc.data(potion);
const potionData = potion
if (potionData.data.categorie.includes('Soin')) {
this.consommerPotionSoin(potionData);
} else if (potionData.data.categorie.includes('Repos')) {
} else if (potionData.system.categorie.includes('Repos')) {
this.consommerPotionRepos(potionData);
} else {
this.consommerPotionGenerique(potionData);
@ -4206,7 +4195,7 @@ export class RdDActor extends Actor {
if (Misc.isUniqueConnectedGM()) {
let draconique = Draconique.all().find(it => it.isCase(item));
if (draconique) {
draconique.onActorDeleteCaseTmr(this, Misc.data(item))
draconique.onActorDeleteCaseTmr(this, item)
}
}
}

6
module/dialog-create-signedraconique.js
View File

@ -12,7 +12,7 @@ export class DialogCreateSigneDraconique extends Dialog {
signe: signe,
tmrs: TMRUtility.listSelectedTMR(signe.data.typesTMR ?? []),
actors: game.actors.filter(actor => actor.isHautRevant()).map(actor => {
let actorData = duplicate(Misc.data(actor));
let actorData = duplicate(actor);
actorData.selected = actor.hasPlayerOwner;
return actorData;
})
@ -48,10 +48,10 @@ export class DialogCreateSigneDraconique extends Dialog {
async _createSigneForActor(actor, signe) {
actor.createEmbeddedDocuments("Item", [signe]);
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(Misc.data(actor).name),
whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html", {
signe: signe,
alias: Misc.data(actor).name
alias: actor.name
})
});
}

2
module/dialog-fabriquer-potion.js
View File

@ -24,7 +24,7 @@ export class DialogFabriquerPotion extends Dialog {
/* -------------------------------------------- */
static prepareData(actor, item) {
let potionData = duplicate(Misc.data(item));
let potionData = duplicate(item)
potionData.nbBrinsSelect = RdDUtility.buildListOptions(1, potionData.data.quantite);
potionData.nbBrins = Math.min(potionData.data.quantite, DialogFabriquerPotion.getNombreBrinOptimal(potionData));
potionData.buttonName = "Fabriquer";

4
module/dialog-item-achat.js
View File

@ -59,8 +59,8 @@ export class DialogItemAchat extends Dialog {
let venteData = {
item: JSON.parse(jsondata),
vendeurId: vendeurId,
vendeur: Misc.data(vendeur),
acheteur: Misc.data(acheteur),
vendeur: vendeur,
acheteur:acheteur,
tailleLot: parseInt(buttonAcheter.attributes['data-tailleLot']?.value ?? 1),
quantiteIllimite: buttonAcheter.attributes['data-quantiteIllimite']?.value == 'true',
quantiteNbLots: parseInt(buttonAcheter.attributes['data-quantiteNbLots']?.value),

4
module/dialog-item-consommer.js
View File

@ -38,10 +38,10 @@ export class DialogConsommer extends Dialog {
/* -------------------------------------------- */
static prepareData(actor, item) {
const itemData = duplicate(Misc.data(item));
const itemData = duplicate(item);
let consommerData = {
item: itemData,
cuisine: Misc.data(actor.getCompetence('cuisine')),
cuisine: actor.getCompetence('cuisine'),
choix: {
doses: 1,
seForcer: false,

2
module/dialog-item-vente.js
View File

@ -4,7 +4,7 @@ import { Misc } from "./misc.js";
export class DialogItemVente extends Dialog {
static async create(item, callback) {
const itemData = Misc.data(item);
const itemData = item
const quantite = item.isConteneur() ? 1 : itemData.data.quantite;
const venteData = {
item: itemData,

2
module/dialog-repos.js
View File

@ -3,7 +3,7 @@ import { Misc } from "./misc.js";
export class DialogRepos extends Dialog {
static async create(actor) {
let actorData = Misc.data(actor)
let actorData = actor
const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-repos.html", actorData);
new DialogRepos(html, actor).render(true);
}

2
module/dialog-split-item.js
View File

@ -3,7 +3,7 @@ import { Misc } from "./misc.js";
export class DialogSplitItem extends Dialog {
static async create(item, callback) {
const itemData = Misc.data(item);
const itemData = item
const splitData = {
item: itemData,
choix: { quantite: 1, max: itemData.data.quantite - 1 }

2
module/dialog-stress.js
View File

@ -9,7 +9,7 @@ export class DialogStress extends Dialog {
immediat: false,
actors: game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
.map(actor => {
let actorData = duplicate(Misc.data(actor));
let actorData = duplicate(actor);
actorData.selected = actor.hasPlayerOwner;
return actorData;
})

4
module/item-arme.js
View File

@ -20,13 +20,13 @@ const nomCategorieParade = {
export class RdDItemArme extends Item {
static isArme(itemData) {
itemData = Misc.data(itemData);
itemData = itemData
return (itemData.type == 'competencecreature' && itemData.system.iscombat) || itemData.type == 'arme';
}
/* -------------------------------------------- */
static getArmeData(armeData) {
armeData = Misc.data(armeData);
armeData = armeData
switch (armeData ? armeData.type : '') {
case 'arme': return armeData;
case 'competencecreature':

6
module/item-competence.js
View File

@ -76,10 +76,10 @@ export class RdDItemCompetence extends Item {
/* -------------------------------------------- */
static getCategorie(competence) {
return Misc.data(competence)?.data.categorie;
return competence?.system.categorie;
}
static isDraconic(competence) {
return Misc.data(competence)?.data.categorie == 'draconic';
return competence?.system.categorie == 'draconic';
}
/* -------------------------------------------- */
@ -173,7 +173,7 @@ export class RdDItemCompetence extends Item {
let economie = 0;
for (let troncList of competenceTroncs) {
let list = troncList.map(name => RdDItemCompetence.findCompetence(competences, name))
.sort(Misc.descending(c => Misc.templateData(c).niveau)); // tri du plus haut au plus bas
.sort(Misc.descending(c => this.system.niveau)); // tri du plus haut au plus bas
list.splice(0, 1); // ignorer la plus élevée
list.map(c => c).forEach(c => {
economie += RdDItemCompetence.getDeltaXp(c.system.base, Math.min(c.system.niveau, 0))

12
module/item-competencecreature.js
View File

@ -5,7 +5,7 @@ export class RdDItemCompetenceCreature extends Item {
/* -------------------------------------------- */
static setRollDataCreature(rollData) {
rollData.competence = Misc.data(rollData.competence);
rollData.competence = rollData.competence
rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.data.carac_value } };
rollData.competence.data.defaut_carac = "carac_creature"
rollData.competence.data.categorie = "creature"
@ -19,13 +19,13 @@ export class RdDItemCompetenceCreature extends Item {
static toArme(item) {
if (RdDItemCompetenceCreature.isCompetenceAttaque(item)) {
// si c'est un Item compétence: cloner pour ne pas modifier lma compétence
let arme = Misc.data( (item instanceof Item) ? item.clone(): item);
mergeObject(arme.data,
let arme = (item instanceof Item) ? item.clone(): item;
mergeObject(arme.system,
{
competence: arme.name,
resistance: 100,
equipe: true,
dommagesReels: arme.data.dommages,
dommagesReels: arme.system.dommages,
penetration: 0,
force: 0,
rapide: true
@ -38,13 +38,13 @@ export class RdDItemCompetenceCreature extends Item {
/* -------------------------------------------- */
static isCompetenceAttaque(itemData) {
itemData = Misc.data(itemData);
itemData = itemData
return itemData.type == 'competencecreature' && itemData.data.iscombat;
}
/* -------------------------------------------- */
static isCompetenceParade(itemData) {
itemData = Misc.data(itemData);
itemData = itemData
return itemData.type == 'competencecreature' && itemData.data.isparade;
}
}

4
module/item-monnaie.js
View File

@ -35,15 +35,13 @@ export class Monnaie {
}
static filtrerMonnaies(items) {
return items.filter(it => Misc.data(it).type == 'monnaie');
return items.filter(it => it.type == 'monnaie');
}
static monnaiesManquantes(items) {
const valeurs = Monnaie.filtrerMonnaies(items)
.map(it => it.system.valeur_deniers);
const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != monnaie.system?.valeur_deniers))
//const manquantes = monnaiesData.filter(monnaie => !valeurs.find(v => v != Misc.templateData(monnaie).valeur_deniers) );
//console.log("Valeurs : ", valeurs, manquantes);
return []; //manquantes;
}

6
module/item-sheet.js
View File

@ -115,8 +115,8 @@ export class RdDItemSheet extends ItemSheet {
/* -------------------------------------------- */
prepareConteneurData(formData) {
formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i.data)));
RdDUtility.filterEquipementParType(formData);
formData.itemsByType = Misc.classify(this.actor.items.map(i => foundry.utils.deepClone(i)))
RdDUtility.filterEquipementParType(formData)
this.objetVersConteneur = RdDUtility.buildArbreDeConteneurs(formData.conteneurs, formData.objets);
formData.subItems = formData.conteneurs.find(it => it._id == this.object.id)?.subItems;
@ -221,7 +221,7 @@ export class RdDItemSheet extends ItemSheet {
if (this.object.isCompetence()) {
let level = RdDItemCompetence.getNiveauBase(event.currentTarget.value);
Misc.templateData(this.object).base = level;
this.object.system.base = level;
$("#base").val(level);
}
}

4
module/item-signedraconique-sheet.js
View File

@ -40,7 +40,7 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
/* -------------------------------------------- */
async getData() {
const formData = duplicate(Misc.data(this.object));
const formData = duplicate(this.object);
mergeObject(formData, {
title: formData.name,
isGM: game.user.isGM,
@ -80,7 +80,7 @@ export class RdDSigneDraconiqueItemSheet extends ItemSheet {
async onValeurXpSort(event) {
const codeReussite = event.currentTarget.attributes['data-typereussite']?.value ?? 0;
const xp = Number(event.currentTarget.value);
const oldValeur = Misc.templateData(this.object).valeur;
const oldValeur = this.object.system.valeur;
const newValeur = RdDItemSigneDraconique.calculValeursXpSort(codeReussite, xp, oldValeur);
await this.object.update({ 'data.valeur': newValeur });
}

4
module/item-signedraconique.js
View File

@ -18,7 +18,7 @@ const DIFFICULTE_LECTURE_SIGNE_MANQUE = +11;
export class RdDItemSigneDraconique {
static prepareSigneDraconiqueMeditation(meditation, rolled) {
meditation = Misc.data(meditation);
meditation = meditation
return {
name: "de la " + meditation.name,
type: "signedraconique",
@ -43,7 +43,7 @@ export class RdDItemSigneDraconique {
}
static getXpSortSigneDraconique(code, signe) {
return Misc.toInt(Misc.data(signe).data.valeur[code] ?? 0);
return Misc.toInt(signe.system.valeur[code] ?? 0);
}
static calculValeursXpSort(qualite, valeur, avant) {

64
module/item.js
View File

@ -83,7 +83,7 @@ export class RdDItem extends Item {
return this.type == 'herbe' && (this.system.categorie == 'Soin' || this.system.categorie == 'Repos');
}
isPotion() {
return Misc.data(this).type == 'potion';
return this.type == 'potion';
}
isEquipement() {
@ -192,10 +192,10 @@ 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 tplData = Misc.templateData(this)
const otherTplData = Misc.templateData(other)
const itemData = this
const otherData = other
const tplData = this
const otherTplData = other
if (!this.isEquipement()) return false;
if (itemData.type != otherData.type) return false;
if (itemData.name != otherData.name) return false;
@ -241,13 +241,13 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
getProprietes() {
return this[`_${Misc.data(this).type}ChatData`]();
return this[`_${this.type}ChatData`]();
}
/* -------------------------------------------- */
async postItem(modeOverride) {
console.log(this);
let chatData = duplicate(Misc.data(this));
let chatData = duplicate(this);
const properties = this.getProprietes();
chatData["properties"] = properties
if (this.actor) {
@ -272,7 +272,7 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
_objetChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [].concat(
RdDItem.propertyIfDefined('Résistance', tplData.resistance, tplData.resistance),
RdDItem.propertyIfDefined('Qualité', tplData.qualite, tplData.qualite),
@ -283,7 +283,7 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
_nourritureboissonChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [].concat(
RdDItem.propertyIfDefined('Sustentation', tplData.sust, tplData.sust > 0),
RdDItem.propertyIfDefined('Désaltère', tplData.desaltere, tplData.boisson),
@ -296,7 +296,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_armeChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Compétence</b>: ${tplData.competence}`,
`<b>Dommages</b>: ${tplData.dommages}`,
@ -308,7 +308,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_conteneurChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Capacité</b>: ${tplData.capacite} Enc.`,
`<b>Encombrement</b>: ${tplData.encombrement}`
@ -317,7 +317,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_munitionChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Encombrement</b>: ${tplData.encombrement}`
]
@ -325,7 +325,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_armureChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Protection</b>: ${tplData.protection}`,
`<b>Détérioration</b>: ${tplData.deterioration}`,
@ -336,7 +336,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_competenceChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Catégorie</b>: ${tplData.categorie}`,
`<b>Niveau</b>: ${tplData.niveau}`,
@ -347,7 +347,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_competencecreatureChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Catégorie</b>: ${tplData.categorie}`,
`<b>Niveau</b>: ${tplData.niveau}`,
@ -358,7 +358,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_sortChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Draconic</b>: ${tplData.draconic}`,
`<b>Difficulté</b>: ${tplData.difficulte}`,
@ -369,7 +369,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_herbeChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Milieu</b>: ${tplData.milieu}`,
`<b>Rareté</b>: ${tplData.rarete}`,
@ -379,7 +379,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_ingredientChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Milieu</b>: ${tplData.milieu}`,
`<b>Rareté</b>: ${tplData.rarete}`,
@ -389,7 +389,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_tacheChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Caractéristique</b>: ${tplData.carac}`,
`<b>Compétence</b>: ${tplData.competence}`,
@ -405,7 +405,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_livreChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Compétence</b>: ${tplData.competence}`,
`<b>Auteur</b>: ${tplData.auteur}`,
@ -417,7 +417,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_potionChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Rareté</b>: ${tplData.rarete}`,
`<b>Catégorie</b>: ${tplData.categorie}`,
@ -427,7 +427,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_queueChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Refoulement</b>: ${tplData.refoulement}`
]
@ -435,7 +435,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_ombreChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Refoulement</b>: ${tplData.refoulement}`
]
@ -443,19 +443,19 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_souffleChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [];
return properties;
}
/* -------------------------------------------- */
_teteChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [];
return properties;
}
/* -------------------------------------------- */
_tarotChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Concept</b>: ${tplData.concept}`,
`<b>Aspect</b>: ${tplData.aspect}`,
@ -464,7 +464,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_nombreastralChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Valeur</b>: ${tplData.value}`,
`<b>Jour</b>: ${tplData.jourlabel}`,
@ -473,7 +473,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_monnaieChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Valeur en Deniers</b>: ${tplData.valeur_deniers}`,
`<b>Encombrement</b>: ${tplData.encombrement}`
@ -482,7 +482,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_meditationChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Thème</b>: ${tplData.theme}`,
`<b>Compétence</b>: ${tplData.competence}`,
@ -497,7 +497,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_casetmrChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Coordonnée</b>: ${tplData.coord}`,
`<b>Spécificité</b>: ${tplData.specific}`
@ -506,7 +506,7 @@ export class RdDItem extends Item {
}
/* -------------------------------------------- */
_maladieChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties
if (tplData.identifie) {
properties = [
@ -531,7 +531,7 @@ export class RdDItem extends Item {
/* -------------------------------------------- */
_gemmeChatData() {
const tplData = Misc.templateData(this);
const tplData = this.system
let properties = [
`<b>Pureté</b>: ${tplData.purete}`,
`<b>Taille</b>: ${tplData.taille}`,

11
module/misc.js
View File

@ -106,17 +106,6 @@ export class Misc {
}
static data(it) {
/*if (it instanceof Actor || it instanceof Item || it instanceof Combatant) {
return it.data;
}*/
return it;
}
static templateData(it) {
return Misc.data(it)?.data ?? {}
}
static getEntityTypeLabel(entity) {
const documentName = entity?.documentName
const type = entity?.type

103
module/rdd-combat.js
View File

@ -89,23 +89,23 @@ export class RdDCombatManager extends Combat {
let rollFormula = formula; // Init per default
if (!rollFormula) {
let armeCombat, competence;
if (combatant.actor.data.type == 'creature' || combatant.actor.data.type == 'entite') {
for (const competenceItemData of combatant.actor.data.items) {
if (competenceItemData.data.data.iscombat) {
if (combatant.actor.system.type == 'creature' || combatant.actor.system.type == 'entite') {
for (const competenceItemData of combatant.actor.items) {
if (competenceItemData.system.iscombat) {
competence = duplicate(competenceItemData);
}
}
rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, competence.data.carac_value) + ")/100)";
rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.system.niveau, competence.system.carac_value) + ")/100)";
} else {
for (const itemData of combatant.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(combatant.actor.data.items, compName);
let bonusEcaille = (armeCombat && armeCombat.data.magique) ? armeCombat.data.ecaille_efficacite : 0;
rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.data.niveau, Misc.data(combatant.actor).data.carac[competence.data.defaut_carac].value, bonusEcaille) + ")/100)";
let compName = (armeCombat == undefined) ? "Corps à corps" : armeCombat.system.competence;
competence = RdDItemCompetence.findCompetence(combatant.actor.items, compName);
let bonusEcaille = (armeCombat && armeCombat.data.magique) ? armeCombat.system.ecaille_efficacite : 0;
rollFormula = "2+( (" + RdDCombatManager.calculInitiative(competence.system.niveau, combatant.actor.system.carac[competence.system.defaut_carac].value, bonusEcaille) + ")/100)";
}
}
//console.log("Combatat", c);
@ -155,37 +155,37 @@ export class RdDCombatManager extends Combat {
// Gestion des armes 1/2 mains
let armesEquipe = [];
for (const arme of armes) {
let armeData = duplicate(arme.system)
if (armeData.equipe) {
let compData = competences.find(c => c.name.toLowerCase() == armeData.competence.toLowerCase())
console.log("ARME", arme, compData, armeData.competence, competences)
let armeData = duplicate(arme)
if (armeData.system.equipe) {
let compData = competences.find(c => c.name.toLowerCase() == armeData.system.competence.toLowerCase())
console.log("ARME", arme, compData, armeData.system.competence, competences)
armesEquipe.push(armeData)
armeData.dommagesReels = Number(armeData.dommages)
armeData.niveau = compData.system.niveau
armeData.initiative = RdDCombatManager.calculInitiative(compData.system.niveau, carac[compData.system.defaut_carac].value);
armeData.system.dommagesReels = Number(armeData.system.dommages)
armeData.system.niveau = compData.system.niveau
armeData.system.initiative = RdDCombatManager.calculInitiative(compData.system.niveau, carac[compData.system.defaut_carac].value);
// Dupliquer les armes pouvant être à 1 main et 2 mains en patchant la compétence
if (armeData.unemain && !armeData.deuxmains) {
armeData.mainInfo = "(1m)";
} else if (!armeData.unemain && armeData.deuxmains) {
armeData.mainInfo = "(2m)";
} else if (armeData.unemain && armeData.deuxmains) {
armeData.mainInfo = "(1m)";
if (armeData.system.unemain && !armeData.system.deuxmains) {
armeData.system.mainInfo = "(1m)";
} else if (!armeData.system.unemain && armeData.system.deuxmains) {
armeData.system.mainInfo = "(2m)";
} else if (armeData.system.unemain && armeData.system.deuxmains) {
armeData.system.mainInfo = "(1m)";
const comp2m = armeData.competence.replace(" 1 main", " 2 mains"); // Replace !
const comp2m = armeData.system.competence.replace(" 1 main", " 2 mains"); // Replace !
const comp = competences.find(c => c.name == comp2m)
const arme2main = duplicate(armeData)
arme2main.mainInfo = "(2m)";
arme2main.niveau = comp.data.niveau;
arme2main.competence = comp2m;
arme2main.initiative = RdDCombatManager.calculInitiative(arme2main.niveau, carac[comp.system.defaut_carac].value)
arme2main.system.mainInfo = "(2m)";
arme2main.system.niveau = comp.system.niveau;
arme2main.system.competence = comp2m;
arme2main.system.initiative = RdDCombatManager.calculInitiative(arme2main.niveau, carac[comp.system.defaut_carac].value)
armesEquipe.push(arme2main);
const containsSlash = armeData.dommages.includes("/");
const containsSlash = armeData.system.dommages.includes("/");
if (containsSlash) {
const tableauDegats = armeData.dommages.split("/");
armeData.dommagesReels = Number(tableauDegats[0]);
arme2main.dommagesReels = Number(tableauDegats[1]);
const tableauDegats = armeData.system.dommages.split("/");
armeData.system.dommagesReels = Number(tableauDegats[0]);
arme2main.system.dommagesReels = Number(tableauDegats[1]);
}
else{
ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
@ -193,7 +193,7 @@ export class RdDCombatManager extends Combat {
}
}
}
return armesEquipe.sort(Misc.ascending(armeData => armeData.name + (armeData.mainInfo ?? '')))
return armesEquipe.sort(Misc.ascending(armeData => armeData.name + (armeData.system.mainInfo ?? '')))
}
/* -------------------------------------------- */
@ -202,7 +202,7 @@ export class RdDCombatManager extends Combat {
ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
return [];
}
const actorData = Misc.data(combatant.actor);
const actorData = combatant.actor
let items = combatant.actor.items
let actions = []
if (combatant.actor.isCreature()) {
@ -307,20 +307,20 @@ export class RdDCombatManager extends Combat {
initOffset = 9;
initInfo = "Draconic"
} else {
compData = Misc.data(RdDItemCompetence.findCompetence(combatant.actor.data.items, arme.data.competence));
compNiveau = compData.data.niveau;
compData = RdDItemCompetence.findCompetence(combatant.actor.items, arme.system.competence);
compNiveau = compData.system.niveau;
initInfo = arme.name + " / " + arme.data.competence;
if (combatant.actor.data.type == 'creature' || combatant.actor.data.type == 'entite') {
caracForInit = compData.data.carac_value;
if (compData.data.categorie == "lancer") {
if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
caracForInit = compData.system.carac_value;
if (compData.system.categorie == "lancer") {
initOffset = 7;
}
else {
initOffset = 5;
}
} else {
caracForInit = Misc.data(combatant.actor).data.carac[compData.data.defaut_carac].value;
initOffset = RdDCombatManager._baseInitOffset(compData.data.categorie, arme);
caracForInit = combatant.actor.system.carac[compData.system.defaut_carac].value;
initOffset = RdDCombatManager._baseInitOffset(compData.system.categorie, arme);
}
}
let malus = combatant.actor.getEtatGeneral(); // Prise en compte état général
@ -725,7 +725,7 @@ export class RdDCombat {
else {
// sans armes: à mains nues
const niveau = competence.data.niveau;
const init = RdDCombatManager.calculInitiative(niveau, Misc.templateData(this.attacker).carac['melee'].value);
const init = RdDCombatManager.calculInitiative(niveau, this.attacker.system.carac['melee'].value);
rollData.arme = RdDItemArme.mainsNues({ niveau: niveau, initiative: init });
}
return rollData;
@ -804,16 +804,16 @@ export class RdDCombat {
}
// # utilisation esquive
const corpsACorps = Misc.data(this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) }));
const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }).map(c => Misc.data(c)));
const corpsACorps = this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) });
const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }))
esquives.forEach(e => e.usages = e?.id ? this.defender.getItemUse(e.id) : 0);
const paramChatDefense = {
passeArme: attackerRoll.passeArme,
essais: attackerRoll.essais,
isPossession: this.isPossession(attackerRoll),
defender: Misc.data(this.defender),
attacker: Misc.data(this.attacker),
defender: this.defender,
attacker: this.attacker,
attackerId: this.attackerId,
esquives: esquives,
defenderTokenId: this.defenderTokenId,
@ -867,7 +867,6 @@ export class RdDCombat {
_filterArmesParade(defender, competence) {
let items = defender.data.items;
items = items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it))
.map(Misc.data);
for (let item of items) {
item.data.nbUsage = defender.getItemUse(item._id); // Ajout du # d'utilisation ce round
}
@ -890,7 +889,7 @@ export class RdDCombat {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html', {
attackerId: this.attackerId,
attacker: Misc.data(this.attacker),
attacker: this.attacker,
defenderTokenId: this.defenderTokenId,
essais: attackerRoll.essais
})
@ -934,7 +933,7 @@ export class RdDCombat {
async parade(attackerRoll, armeParadeId) {
const arme = this.defender.getArmeParade(armeParadeId);
console.log("RdDCombat.parade >>>", attackerRoll, armeParadeId, arme);
const competence = Misc.templateData(arme)?.competence;
const competence = this.system?.competence;
if (competence == undefined)
{
console.error("Pas de compétence de parade associée à ", arme) ;
@ -969,12 +968,12 @@ export class RdDCombat {
passeArme: attackerRoll.passeArme,
diffLibre: attackerRoll.diffLibre,
attackerRoll: attackerRoll,
competence: Misc.data(this.defender.getCompetence(competenceParade)),
competence: this.defender.getCompetence(competenceParade),
arme: armeParade,
surprise: this.defender.getSurprise(true),
needParadeSignificative: ReglesOptionelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
needResist: RdDItemArme.needArmeResist(attackerRoll.arme, armeParade),
carac: Misc.templateData(this.defender).carac,
carac: this.defender.system.carac,
show: {}
};
@ -1018,7 +1017,7 @@ export class RdDCombat {
/* -------------------------------------------- */
async esquive(attackerRoll, compId, compName) {
const esquive = Misc.data(this.defender.getCompetence(compId) ?? this.defender.getCompetence(compName));
const esquive = this.defender.getCompetence(compId) ?? this.defender.getCompetence(compName)
if (esquive == undefined) {
ui.notifications.error(this.defender.name + " n'a pas de compétence " + compName);
return;
@ -1052,7 +1051,7 @@ export class RdDCombat {
competence: competence,
surprise: this.defender.getSurprise(true),
surpriseDefenseur: this.defender.getSurprise(true),
carac: Misc.templateData(this.defender).carac,
carac: this.defender.system.carac,
show: {}
};
@ -1227,7 +1226,7 @@ export class RdDCombat {
return true;
}
let rolled = await RdDResolutionTable.roll(this.attacker.getReveActuel(), - Number(Misc.templateData(this.defender).carac.niveau.value));
let rolled = await RdDResolutionTable.roll(this.attacker.getReveActuel(), - Number(this.defender.system.carac.niveau.value));
let message = {
content: "Jet de points actuels de rêve à " + rolled.finalLevel + RdDResolutionTable.explain(rolled) + "<br>",

2
module/rdd-commands.js
View File

@ -354,7 +354,7 @@ export class RdDCommands {
async supprimerSignesDraconiquesEphemeres() {
game.actors.forEach(actor => {
const ephemeres = actor.filterItems(item => Misc.data(item).type = 'signedraconique' && Misc.data(item).data.ephemere)
const ephemeres = actor.filterItems(item => item.type = 'signedraconique' && item.system.ephemere)
.map(item => item.id);
if (ephemeres.length > 0) {
actor.deleteEmbeddedDocuments("Item", ephemeres);

4
module/rdd-herbes.js
View File

@ -25,7 +25,7 @@ export class RdDHerbes extends Item {
static buildHerbesList(listHerbes, max) {
let list = {}
for ( let herbe of listHerbes) {
let herbeData = Misc.templateData(herbe);
let herbeData = herbe.system
let brins = max - herbeData.niveau;
list[herbe.data.name] = `${herbe.data.name} (Bonus: ${herbeData.niveau}, Brins: ${brins})`;
}
@ -65,7 +65,7 @@ export class RdDHerbes extends Item {
if ( Number(formData.data.herbebrins) ) {
let herbe = herbesList.find(item => item.name.toLowerCase() == formData.data.herbe.toLowerCase() );
if( herbe ) {
let herbeData = Misc.templateData(herbe);
let herbeData = herbe.system;
let brinsBase = max - herbeData.niveau;
//console.log(herbeData, brinsBase, formData.data.herbebrins);
formData.data.herbebonus = Math.max(herbeData.niveau - Math.max(brinsBase - formData.data.herbebrins, 0), 0);

11
module/rdd-sheet-utility.js
View File

@ -21,7 +21,10 @@ export class RdDSheetUtility {
}
static prepareItemDropParameters(destItemId, actorId, dragData, objetVersConteneur) {
const itemId = dragData.id || dragData.data._id
console.log("ID", dragData)
const item = fromUuidSync(dragData.uuid)
let itemId = item.id
//const itemId = dragData.id || dragData.data._id
return {
destId: destItemId,
targetActorId: actorId,
@ -42,11 +45,11 @@ export class RdDSheetUtility {
}
static async _onSplitItem(item, split, actor) {
if (split >= 1 && split < Misc.data(item).data.quantite) {
if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split);
const itemData = duplicate(Misc.data(item));
const itemData = duplicate(item);
// todo: ajouter dans le même conteneur?
itemData.data.quantite = split;
itemData.system.quantite = split;
await actor.createEmbeddedDocuments('Item', [itemData])
}
}

2
module/rdd-token-hud.js
View File

@ -22,7 +22,7 @@ export class RdDTokenHud {
let token = canvas.tokens.get(tokenId);
let actor = token.actor;
let combatant = game.combat.combatants.find(c => Misc.data(c).tokenId == tokenId);
let combatant = game.combat.combatants.find(c => c.tokenId == tokenId);
app.hasExtension = true;
let armesList = RdDCombatManager.buildListeActionsCombat(combatant);

4
module/rdd-utility.js
View File

@ -437,7 +437,7 @@ export class RdDUtility {
/* -------------------------------------------- */
static calculEncContenu(conteneur, objets) {
const contenuDatas = (conteneur.system.contenu ?? []).filter(id => id != undefined)
.map(id => Misc.data(objets.find(it => (id == it._id))))
.map(id => objets.find(it => (id == it._id)))
.filter(it => it);
let enc = Number(conteneur.system.encombrement ?? 0) * Number(conteneur.system.quantite ?? 1);
for (let itemData of contenuDatas) {
@ -873,7 +873,7 @@ export class RdDUtility {
label: "Annuler"
}
}
const docData = Misc.data(objet);
const docData = objet
if (docData.type == 'conteneur' && docData.data.contenu.length > 0) {
msgTxt += "<br>Ce conteneur n'est pas vide. Choisissez l'option de suppression";
buttons['deleteall'] = {

14
module/rolldata-ajustements.js
View File

@ -19,9 +19,9 @@ import { ReglesOptionelles } from "./regles-optionelles.js";
*/
export const referenceAjustements = {
competence: {
isUsed: (rollData, actor) => Misc.data(rollData.competence),
getLabel: (rollData, actor) => Misc.data(rollData.competence)?.name,
getValue: (rollData, actor) => Misc.data(rollData.competence)?.system?.niveau,
isUsed: (rollData, actor) => rollData.competence,
getLabel: (rollData, actor) => rollData.competence?.name,
getValue: (rollData, actor) => rollData.competence?.system?.niveau,
},
meditation: {
isUsed: (rollData, actor) => rollData.meditation,
@ -33,7 +33,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 ?? Misc.data(rollData.competence)?.data.default_diffLibre ?? 0
: rollData.diffLibre ?? rollData.competence?.data.default_diffLibre ?? 0
},
diffConditions: {
isUsed: (rollData, actor) => rollData.diffConditions != undefined,
@ -95,10 +95,10 @@ export const referenceAjustements = {
getDescr: (rollData, actor) => rollData.diviseurSignificative > 1 ? `Facteur significative <span class="rdd-diviseur">&times;${Misc.getFractionHtml(rollData.diviseurSignificative)}</span>` : ''
},
isEcaille: {
isVisible: (rollData, actor) => Misc.data(rollData.arme)?.system.magique && Number(Misc.data(rollData.arme)?.system.ecaille_efficacite) > 0,
isUsed: (rollData, actor) => Misc.data(rollData.arme)?.system.magique && Number(Misc.data(rollData.arme)?.system.ecaille_efficacite) > 0,
isVisible: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
isUsed: (rollData, actor) => rollData.arme?.system.magique && Number(rollData.arme?.system.ecaille_efficacite) > 0,
getLabel: (rollData, actor) => "Ecaille d'Efficacité: ",
getValue: (rollData, actor) => Math.max(Number(Misc.data(rollData.arme)?.system.ecaille_efficacite), 0),
getValue: (rollData, actor) => Math.max(Number(rollData.arme?.system.ecaille_efficacite), 0),
},
finesse: {
isUsed: (rollData, actor) => RdDBonus.isDefenseAttaqueFinesse(rollData),

4
module/tmr-rencontres.js
View File

@ -422,7 +422,7 @@ export class TMRRencontres {
/* -------------------------------------------- */
static async msgEchecPasseurFou(tmrData) {
tmrData.sortReserve = Misc.templateData(tmrData.actor).reve.reserve.list[0];
tmrData.sortReserve = tmrData.actor.system.reve.reserve.list[0];
if (tmrData.sortReserve) {
// Passeur fou positionne sur la case d'un ort en réserve // TODO : Choisir le sort le plus loin ou au hasard
tmrData.newTMR = TMRUtility.getTMR(tmrData.sortReserve.coord);
@ -465,7 +465,7 @@ export class TMRRencontres {
/* -------------------------------------------- */
static async _toubillonner(tmrDialog, actor, cases) {
let coord = Misc.templateData(actor).reve.tmrpos.coord;
let coord = actor.system.reve.tmrpos.coord;
for (let i = 0; i < cases; i++) {
coord = await TMRUtility.deplaceTMRAleatoire(actor, coord).coord;
}

2
module/tmr/urgence-draconique.js
View File

@ -16,7 +16,7 @@ export class UrgenceDraconique extends Draconique {
match(item) { return Draconique.isQueueDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('urgence draconique'); }
manualMessage() { return false }
async onActorCreateOwned(actor, queue) {
const coordSortsReserve = (Misc.templateData(actor).reve.reserve?.list.map(it => it.coord)) ?? [];
const coordSortsReserve = (actor.system.reve.reserve?.list.map(it => it.coord)) ?? [];
if (coordSortsReserve.length == 0) {
// La queue se transforme en idée fixe
const ideeFixe = await RdDRollTables.getIdeeFixe();