public/foundryvtt-reve-de-dragon
1
1
Fork 1
Code Issues Pull Requests 1 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

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)
}
}
}