VincentVk/foundryvtt-reve-de-dragon
0
0
Fork 0
forked from public/foundryvtt-reve-de-dragon
Code Issues Pull Requests Projects Releases Wiki Activity

Preparation du passage en v12

Browse Source
This commit is contained in:
LeRatierBretonnien 2024-05-02 14:08:02 +02:00
parent bc35c8d80e
commit 7f7148e658
32 changed files with 78 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
module/actor-sheet.js
View File

@ -80,7 +80,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
// toujours avoir une liste d'armes (pour mettre esquive et corps à corps) // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
const actor = this.actor; const actor = this.actor;
formData.combat = duplicate(formData.armes); formData.combat = foundry.utils.duplicate(formData.armes);
RdDItemArme.computeNiveauArmes(formData.combat, formData.competences); RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
formData.combat.push(RdDItemArme.mainsNues(actor)); formData.combat.push(RdDItemArme.mainsNues(actor));
formData.combat.push(RdDItemArme.empoignade(actor)); formData.combat.push(RdDItemArme.empoignade(actor));
@ -221,7 +221,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
// Points de reve actuel // Points de reve actuel
this.html.find('.ptreve-actuel a').click(async event => this.actor.rollCarac('reve-actuel', true)) this.html.find('.ptreve-actuel a').click(async event => this.actor.rollCarac('reve-actuel', true))
this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor))) this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
this.html.find('.arme-label a').click(async event => this.actor.rollArme(duplicate(this._getEventArmeCombat(event)))) this.html.find('.arme-label a').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
// Initiative pour l'arme // Initiative pour l'arme
this.html.find('.arme-initiative a').click(async event => { this.html.find('.arme-initiative a').click(async event => {
@ -388,7 +388,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
async _onSplitItem(item, split) { async _onSplitItem(item, split) {
if (split >= 1 && split < item.system.quantite) { if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split); await item.diminuerQuantite(split);
const splitItem = duplicate(item); const splitItem = foundry.utils.duplicate(item);
splitItem.system.quantite = split; splitItem.system.quantite = split;
await this.actor.createEmbeddedDocuments('Item', [splitItem]) await this.actor.createEmbeddedDocuments('Item', [splitItem])
} }

54
module/actor.js
View File

@ -120,7 +120,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
getActivePoisons() { getActivePoisons() {
return duplicate(this.items.filter(item => item.type == 'poison' && item.system.active)) return foundry.utils.duplicate(this.items.filter(item => item.type == 'poison' && item.system.active))
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
@ -143,7 +143,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
getDemiReve() { return this.system.reve.tmrpos.coord } getDemiReve() { return this.system.reve.tmrpos.coord }
getDraconicList() { return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic') } getDraconicList() { return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic') }
getBestDraconic() { return duplicate(this.getDraconicList().sort(Misc.descending(it => it.system.niveau)).find(it => true)) } getBestDraconic() { return foundry.utils.duplicate(this.getDraconicList().sort(Misc.descending(it => it.system.niveau)).find(it => true)) }
getDraconicOuPossession() { getDraconicOuPossession() {
return [...this.getDraconicList().filter(it => it.system.niveau >= 0), return [...this.getDraconicList().filter(it => it.system.niveau >= 0),
super.getDraconicOuPossession()] super.getDraconicOuPossession()]
@ -691,7 +691,7 @@ export class RdDActor extends RdDBaseActorSang {
} }
let carac = this.findCaracByName(caracName); let carac = this.findCaracByName(caracName);
if (carac) { if (carac) {
carac = duplicate(carac); carac = foundry.utils.duplicate(carac);
const fromXp = Number(carac.xp); const fromXp = Number(carac.xp);
const fromValue = Number(carac.value); const fromValue = Number(carac.value);
let toXp = fromXp; let toXp = fromXp;
@ -827,7 +827,7 @@ export class RdDActor extends RdDBaseActorSang {
async deleteExperienceLog(from, count) { async deleteExperienceLog(from, count) {
if (from >= 0 && count > 0) { if (from >= 0 && count > 0) {
let expLog = duplicate(this.system.experiencelog); let expLog = foundry.utils.duplicate(this.system.experiencelog);
expLog.splice(from, count); expLog.splice(from, count);
await this.update({ [`system.experiencelog`]: expLog }); await this.update({ [`system.experiencelog`]: expLog });
} }
@ -1312,7 +1312,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
async saouler(forceAlcool, alcool = undefined) { async saouler(forceAlcool, alcool = undefined) {
let ethylisme = duplicate(this.system.compteurs.ethylisme); let ethylisme = foundry.utils.duplicate(this.system.compteurs.ethylisme);
const etat = this.getEtatGeneral({ ethylisme: true }); const etat = this.getEtatGeneral({ ethylisme: true });
const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0); const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
@ -1489,7 +1489,7 @@ export class RdDActor extends RdDBaseActorSang {
const niveauSuivant = Number(carac.value) + 1; const niveauSuivant = Number(carac.value) + 1;
let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant); let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
if (carac.xp >= xpNeeded) { if (carac.xp >= xpNeeded) {
carac = duplicate(carac); carac = foundry.utils.duplicate(carac);
carac.value = niveauSuivant; carac.value = niveauSuivant;
let checkXp = { let checkXp = {
@ -1519,7 +1519,7 @@ export class RdDActor extends RdDBaseActorSang {
if (compData && newXP > 0) { if (compData && newXP > 0) {
let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1); let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1);
if (newXP >= xpNeeded) { if (newXP >= xpNeeded) {
let newCompData = duplicate(compData); let newCompData = foundry.utils.duplicate(compData);
newCompData.system.niveau += 1; newCompData.system.niveau += 1;
newCompData.system.xp = newXP; newCompData.system.xp = newXP;
let checkXp = { let checkXp = {
@ -1625,14 +1625,14 @@ export class RdDActor extends RdDBaseActorSang {
return; return;
} }
// Duplication car les pts de reve sont modifiés dans le sort // Duplication car les pts de reve sont modifiés dans le sort
let sorts = duplicate(this.$filterSortList(this.itemTypes['sort'], coord)); let sorts = foundry.utils.duplicate(this.$filterSortList(this.itemTypes['sort'], coord));
if (sorts.length == 0) { if (sorts.length == 0) {
ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`); ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`);
return; return;
} }
const draconicList = this.computeDraconicAndSortIndex(sorts); const draconicList = this.computeDraconicAndSortIndex(sorts);
const reve = duplicate(this.system.carac.reve); const reve = foundry.utils.duplicate(this.system.carac.reve);
const dialog = await this.openRollDialog({ const dialog = await this.openRollDialog({
name: 'lancer-un-sort', name: 'lancer-un-sort',
@ -1873,7 +1873,7 @@ export class RdDActor extends RdDBaseActorSang {
diffConditions: 0, diffConditions: 0,
use: { libre: false, conditions: true }, use: { libre: false, conditions: true },
carac: { carac: {
[tacheData.system.carac]: duplicate(this.system.carac[tacheData.system.carac]) [tacheData.system.carac]: foundry.utils.duplicate(this.system.carac[tacheData.system.carac])
} }
}, },
callbackAction: r => this._tacheResult(r, options) callbackAction: r => this._tacheResult(r, options)
@ -1884,7 +1884,7 @@ export class RdDActor extends RdDBaseActorSang {
async _tacheResult(rollData, options) { async _tacheResult(rollData, options) {
// Mise à jour de la tache // Mise à jour de la tache
rollData.appliquerFatigue = ReglesOptionnelles.isUsing("appliquer-fatigue"); rollData.appliquerFatigue = ReglesOptionnelles.isUsing("appliquer-fatigue");
rollData.tache = duplicate(rollData.tache); rollData.tache = foundry.utils.duplicate(rollData.tache);
rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache; rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache;
if (rollData.rolled.isETotal) { if (rollData.rolled.isETotal) {
rollData.tache.system.difficulte--; rollData.tache.system.difficulte--;
@ -1912,17 +1912,17 @@ export class RdDActor extends RdDBaseActorSang {
{ {
oeuvre: oeuvre, oeuvre: oeuvre,
art: oeuvre.type, art: oeuvre.type,
competence: duplicate(this.getCompetence(artData.compName ?? oeuvre.system.competence ?? artData.art)), competence: foundry.utils.duplicate(this.getCompetence(artData.compName ?? oeuvre.system.competence ?? artData.art)),
diffLibre: - oeuvre.system.niveau, diffLibre: - oeuvre.system.niveau,
diffConditions: 0, diffConditions: 0,
use: { libre: false, conditions: true, surenc: false }, use: { libre: false, conditions: true, surenc: false },
selectedCarac: duplicate(this.system.carac[selected]) selectedCarac: foundry.utils.duplicate(this.system.carac[selected])
}, },
{ overwrite: false }); { overwrite: false });
artData.competence.system.defaut_carac = selected; artData.competence.system.defaut_carac = selected;
if (!artData.forceCarac) { if (!artData.forceCarac) {
artData.forceCarac = {}; artData.forceCarac = {};
artData.forceCarac[selected] = duplicate(this.system.carac[selected]); artData.forceCarac[selected] = foundry.utils.duplicate(this.system.carac[selected]);
} }
await this.openRollDialog({ await this.openRollDialog({
@ -1946,19 +1946,19 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
async rollChant(id) { async rollChant(id) {
const artData = { art: 'chant', verbe: 'Chanter' }; const artData = { art: 'chant', verbe: 'Chanter' };
const oeuvre = duplicate(this.getChant(id)); const oeuvre = foundry.utils.duplicate(this.getChant(id));
await this._rollArt(artData, "ouie", oeuvre); await this._rollArt(artData, "ouie", oeuvre);
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
async rollDanse(id) { async rollDanse(id) {
const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} }; const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
const oeuvre = duplicate(this.findItemLike(id, artData.art)); const oeuvre = foundry.utils.duplicate(this.findItemLike(id, artData.art));
if (oeuvre.system.agilite) { if (oeuvre.system.agilite) {
artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite); artData.forceCarac['agilite'] = foundry.utils.duplicate(this.system.carac.agilite);
} }
if (oeuvre.system.apparence) { if (oeuvre.system.apparence) {
artData.forceCarac['apparence'] = duplicate(this.system.carac.apparence); artData.forceCarac['apparence'] = foundry.utils.duplicate(this.system.carac.apparence);
} }
const selectedCarac = this._getCaracDanse(oeuvre); const selectedCarac = this._getCaracDanse(oeuvre);
await this._rollArt(artData, selectedCarac, oeuvre); await this._rollArt(artData, selectedCarac, oeuvre);
@ -2061,7 +2061,7 @@ export class RdDActor extends RdDBaseActorSang {
const artData = { const artData = {
art: 'jeu', verbe: 'Jeu', art: 'jeu', verbe: 'Jeu',
use: { libre: true, conditions: true, }, use: { libre: true, conditions: true, },
competence: duplicate(this.getCompetence('jeu')), competence: foundry.utils.duplicate(this.getCompetence('jeu')),
forceCarac: {} forceCarac: {}
}; };
listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]); listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]);
@ -2072,14 +2072,14 @@ export class RdDActor extends RdDBaseActorSang {
async rollOeuvre(id) { async rollOeuvre(id) {
const artData = { art: 'oeuvre', verbe: 'Interpréter' } const artData = { art: 'oeuvre', verbe: 'Interpréter' }
const oeuvre = duplicate(this.findItemLike(id, artData.art)) const oeuvre = foundry.utils.duplicate(this.findItemLike(id, artData.art))
await this._rollArt(artData, oeuvre.system.default_carac, oeuvre) await this._rollArt(artData, oeuvre.system.default_carac, oeuvre)
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
async rollMeditation(id) { async rollMeditation(id) {
const meditation = duplicate(this.getMeditation(id)); const meditation = foundry.utils.duplicate(this.getMeditation(id));
const competence = duplicate(this.getCompetence(meditation.system.competence)); const competence = foundry.utils.duplicate(this.getCompetence(meditation.system.competence));
competence.system.defaut_carac = "intellect"; // Meditation = toujours avec intellect competence.system.defaut_carac = "intellect"; // Meditation = toujours avec intellect
let meditationData = { let meditationData = {
competence: competence, competence: competence,
@ -2145,7 +2145,7 @@ export class RdDActor extends RdDBaseActorSang {
} }
let draconicList = this.getDraconicList() let draconicList = this.getDraconicList()
.map(draconic => { .map(draconic => {
let draconicLecture = duplicate(draconic); let draconicLecture = foundry.utils.duplicate(draconic);
draconicLecture.system.defaut_carac = "intellect"; draconicLecture.system.defaut_carac = "intellect";
return draconicLecture; return draconicLecture;
}); });
@ -2314,7 +2314,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
async _xpCarac(xpData) { async _xpCarac(xpData) {
if (xpData.xpCarac > 0) { if (xpData.xpCarac > 0) {
const carac = duplicate(this.system.carac) const carac = foundry.utils.duplicate(this.system.carac)
const code = RdDBaseActor._findCaracNode(carac, xpData.caracName) const code = RdDBaseActor._findCaracNode(carac, xpData.caracName)
const selectedCarac = carac[code] const selectedCarac = carac[code]
if (this.isCaracMax(code)) { if (this.isCaracMax(code)) {
@ -2618,7 +2618,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
async incDecItemUse(itemId, inc = 1) { async incDecItemUse(itemId, inc = 1) {
let itemUse = duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {}); let itemUse = foundry.utils.duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {});
itemUse[itemId] = (itemUse[itemId] ?? 0) + inc; itemUse[itemId] = (itemUse[itemId] ?? 0) + inc;
await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse); await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
console.log("ITEM USE INC", inc, itemUse); console.log("ITEM USE INC", inc, itemUse);
@ -2712,7 +2712,7 @@ export class RdDActor extends RdDBaseActorSang {
} }
async setPointsCoeur(subActorId, coeurs, options = { immediat: false }) { async setPointsCoeur(subActorId, coeurs, options = { immediat: false }) {
const newSuivants = duplicate(this.system.subacteurs.suivants) const newSuivants = foundry.utils.duplicate(this.system.subacteurs.suivants)
const amoureux = newSuivants.find(it => it.id == subActorId); const amoureux = newSuivants.find(it => it.id == subActorId);
if (amoureux) { if (amoureux) {
amoureux[options.immediat ? 'coeur' : 'prochainCoeur'] = coeurs amoureux[options.immediat ? 'coeur' : 'prochainCoeur'] = coeurs
@ -3066,7 +3066,7 @@ export class RdDActor extends RdDBaseActorSang {
incarnation.name = 'Réincarnation de ' + incarnation.name incarnation.name = 'Réincarnation de ' + incarnation.name
incarnation.system = { incarnation.system = {
carac: duplicate(this.system.carac), carac: foundry.utils.duplicate(this.system.carac),
heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key, heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
age: 18, age: 18,
biographie: '', biographie: '',

4
module/actor/base-actor-reve.js
View File

@ -286,7 +286,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
getCarac() { getCarac() {
// TODO: le niveau d'une entité de cauchemar devrait être exclu... // TODO: le niveau d'une entité de cauchemar devrait être exclu...
const carac = foundry.utils.mergeObject(duplicate(this.system.carac), const carac = foundry.utils.mergeObject(foundry.utils.duplicate(this.system.carac),
{ {
'reve-actuel': this.getCaracReveActuel(), 'reve-actuel': this.getCaracReveActuel(),
'chance-actuelle': this.getCaracChanceActuelle() 'chance-actuelle': this.getCaracChanceActuelle()
@ -471,7 +471,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
}); });
if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) { if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
encaissement = duplicate(encaissement); encaissement = foundry.utils.duplicate(encaissement);
encaissement.isGM = true; encaissement.isGM = true;
ChatMessage.create({ ChatMessage.create({
whisper: ChatMessage.getWhisperRecipients("GM"), whisper: ChatMessage.getWhisperRecipients("GM"),

4
module/actor/base-actor-sang.js
View File

@ -89,7 +89,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
/* -------------------------------------------- */ /* -------------------------------------------- */
async onAppliquerJetEncaissement(encaissement, attacker) { async onAppliquerJetEncaissement(encaissement, attacker) {
const santeOrig = duplicate(this.system.sante); const santeOrig = foundry.utils.duplicate(this.system.sante);
const blessure = await this.ajouterBlessure(encaissement, attacker); // Will update the result table const blessure = await this.ajouterBlessure(encaissement, attacker); // Will update the result table
const perteVie = await this.santeIncDec("vie", -encaissement.vie); const perteVie = await this.santeIncDec("vie", -encaissement.vie);
const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, blessure?.isCritique()); const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, blessure?.isCritique());
@ -108,7 +108,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) { if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
return; return;
} }
const sante = duplicate(this.system.sante) const sante = foundry.utils.duplicate(this.system.sante)
let compteur = sante[name]; let compteur = sante[name];
if (!compteur) { if (!compteur) {
return; return;

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

@ -312,7 +312,7 @@ export class RdDBaseActorSheet extends ActorSheet {
async _onSplitItem(item, split) { async _onSplitItem(item, split) {
if (split >= 1 && split < item.system.quantite) { if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split); await item.diminuerQuantite(split);
const splitItem = duplicate(item); const splitItem = foundry.utils.duplicate(item);
splitItem.system.quantite = split; splitItem.system.quantite = split;
await this.actor.createEmbeddedDocuments('Item', [splitItem]) await this.actor.createEmbeddedDocuments('Item', [splitItem])
} }

4
module/actor/base-actor.js
View File

@ -377,7 +377,7 @@ export class RdDBaseActor extends Actor {
if (cout > 0) { if (cout > 0) {
RdDAudio.PlayContextAudio("argent"); RdDAudio.PlayContextAudio("argent");
} }
const chatAchatItem = duplicate(achat.vente); const chatAchatItem = foundry.utils.duplicate(achat.vente);
chatAchatItem.quantiteTotal = quantite; chatAchatItem.quantiteTotal = quantite;
ChatMessage.create({ ChatMessage.create({
user: achat.userId, user: achat.userId,
@ -649,7 +649,7 @@ export class RdDBaseActor extends Actor {
sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
const itemsDataToCreate = itemsList.map(it => sourceActor.getItem(it.id)) const itemsDataToCreate = itemsList.map(it => sourceActor.getItem(it.id))
.map(it => duplicate(it)) .map(it => foundry.utils.duplicate(it))
.map(it => { it.system.contenu = []; return it; }); .map(it => { it.system.contenu = []; return it; });
let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate); let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);

2
module/actor/creature.js
View File

@ -48,7 +48,7 @@ export class RdDCreature extends RdDBaseActorSang {
/* -------------------------------------------- */ /* -------------------------------------------- */
async setEntiteReveAccordee(attacker) { async setEntiteReveAccordee(attacker) {
if (this.isEntite([ENTITE_INCARNE])) { if (this.isEntite([ENTITE_INCARNE])) {
let resonnance = duplicate(this.system.sante.resonnance); let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
if (resonnance.actors.find(it => it == attacker.id)) { if (resonnance.actors.find(it => it == attacker.id)) {
// déjà accordé // déjà accordé
return; return;

2
module/actor/entite.js
View File

@ -93,7 +93,7 @@ export class RdDEntite extends RdDBaseActorReve {
/* -------------------------------------------- */ /* -------------------------------------------- */
async setEntiteReveAccordee(attacker) { async setEntiteReveAccordee(attacker) {
if (this.isEntite([ENTITE_INCARNE])) { if (this.isEntite([ENTITE_INCARNE])) {
let resonnance = duplicate(this.system.sante.resonnance); let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
if (resonnance.actors.find(it => it == attacker.id)) { if (resonnance.actors.find(it => it == attacker.id)) {
// déjà accordé // déjà accordé
return; return;

2
module/chat-utility.js
View File

@ -131,7 +131,7 @@ export class ChatUtility {
/* -------------------------------------------- */ /* -------------------------------------------- */
static blindMessageToGM(chatOptions) { static blindMessageToGM(chatOptions) {
let chatGM = duplicate(chatOptions); let chatGM = foundry.utils.duplicate(chatOptions);
chatGM.whisper = ChatUtility.getUsers(user => user.isGM); chatGM.whisper = ChatUtility.getUsers(user => user.isGM);
chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content; chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content;
console.log("blindMessageToGM", chatGM); console.log("blindMessageToGM", chatGM);

2
module/coeur/rdd-coeur.js
View File

@ -69,7 +69,7 @@ export class RdDCoeur {
} }
static async applyCoeurChateauDormant(actor, message) { static async applyCoeurChateauDormant(actor, message) {
const newSuivants = duplicate(actor.system.subacteurs.suivants) const newSuivants = foundry.utils.duplicate(actor.system.subacteurs.suivants)
let count = 0 let count = 0
newSuivants.forEach(async link => { newSuivants.forEach(async link => {
const suivant = game.actors.get(link.id) const suivant = game.actors.get(link.id)

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

@ -21,7 +21,7 @@ export class DialogFabriquerPotion extends Dialog {
/* -------------------------------------------- */ /* -------------------------------------------- */
static prepareData(actor, item) { static prepareData(actor, item) {
let potionData = duplicate(item) let potionData = foundry.utils.duplicate(item)
potionData.nbBrinsSelect = RdDUtility.buildListOptions( potionData.nbBrinsSelect = RdDUtility.buildListOptions(
DialogFabriquerPotion.nombreBrinsMinimum(item), DialogFabriquerPotion.nombreBrinsMinimum(item),
DialogFabriquerPotion.nombreBrinsOptimal(item)); DialogFabriquerPotion.nombreBrinsOptimal(item));

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

@ -47,7 +47,7 @@ export class DialogConsommer extends Dialog {
/* -------------------------------------------- */ /* -------------------------------------------- */
static prepareData(actor, item) { static prepareData(actor, item) {
let consommerData = { let consommerData = {
item: duplicate(item), item: foundry.utils.duplicate(item),
cuisine: actor.getCompetence('cuisine'), cuisine: actor.getCompetence('cuisine'),
choix: { choix: {
doses: 1, doses: 1,

2
module/item-arme.js
View File

@ -139,7 +139,7 @@ export class RdDItemArme extends Item {
const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains; const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/"); const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
if (containsSlash) { // Sanity check if (containsSlash) { // Sanity check
armeData = duplicate(armeData); armeData = foundry.utils.duplicate(armeData);
const tableauDegats = armeData.system.dommages.split("/"); const tableauDegats = armeData.system.dommages.split("/");
if (aUneMain) if (aUneMain)

2
module/item-competence.js
View File

@ -257,7 +257,7 @@ export class RdDItemCompetence extends Item {
/* -------------------------------------------- */ /* -------------------------------------------- */
static computeResumeArchetype(competences) { static computeResumeArchetype(competences) {
const computed = duplicate(limitesArchetypes); const computed = foundry.utils.duplicate(limitesArchetypes);
computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; }); computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; });
competences.map(it => Math.max(0, it.system.niveau_archetype)) competences.map(it => Math.max(0, it.system.niveau_archetype))

2
module/item-monnaie.js
View File

@ -57,7 +57,7 @@ export class Monnaie {
} }
static creerDeniers(fortune) { static creerDeniers(fortune) {
const deniers = duplicate(MONNAIE_ETAIN); const deniers = foundry.utils.duplicate(MONNAIE_ETAIN);
deniers.system.quantite = fortune; deniers.system.quantite = fortune;
return deniers; return deniers;
} }

6
module/item-sheet.js
View File

@ -108,8 +108,8 @@ export class RdDItemSheet extends ItemSheet {
const competences = await SystemCompendiums.getCompetences('personnage'); const competences = await SystemCompendiums.getCompetences('personnage');
formData.categories = this.item.getCategories() formData.categories = this.item.getCategories()
if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') { if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
formData.caracList = duplicate(game.system.model.Actor.personnage.carac) formData.caracList = foundry.utils.duplicate(game.system.model.Actor.personnage.carac)
formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve) formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.system.model.Actor.personnage.reve.reve)
formData.competences = competences; formData.competences = competences;
} }
if (this.item.type == 'arme') { if (this.item.type == 'arme') {
@ -228,7 +228,7 @@ export class RdDItemSheet extends ItemSheet {
}); });
} }
const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) }) const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: foundry.utils.duplicate(timestamp) })
RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp); RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp); RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);

4
module/item.js
View File

@ -317,8 +317,8 @@ export class RdDItem extends Item {
const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut); const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut);
await actor.updateEmbeddedDocuments('Item', [{ await actor.updateEmbeddedDocuments('Item', [{
_id: this.id, _id: this.id,
'system.temporel.debut': duplicate(timestampDebut), 'system.temporel.debut': foundry.utils.duplicate(timestampDebut),
'system.temporel.fin': duplicate(timestampFin), 'system.temporel.fin': foundry.utils.duplicate(timestampFin),
}]) }])
} }
} }

2
module/item/blessure.js
View File

@ -39,7 +39,7 @@ export class RdDItemBlessure extends RdDItem {
ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`) ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`)
return undefined; return undefined;
} }
return foundry.utils.mergeObject(duplicate(BASE_TACHE_SOIN_BLESSURE), tache) return foundry.utils.mergeObject(foundry.utils.duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
} }
static async applyFullBlessure(actor, gravite) { static async applyFullBlessure(actor, gravite) {

2
module/item/maladie.js
View File

@ -38,7 +38,7 @@ export class RdDItemMaladie extends RdDItem {
await mal.actor.updateEmbeddedDocuments('Item', [{ await mal.actor.updateEmbeddedDocuments('Item', [{
_id: mal.id, _id: mal.id,
'system.temporel.fin': duplicate(timestampFin), 'system.temporel.fin': foundry.utils.duplicate(timestampFin),
}]) }])
} }
} }

4
module/rdd-combat.js
View File

@ -218,7 +218,7 @@ export class RdDCombatManager extends Combat {
static $prepareAttaqueArme(infoAttaque) { static $prepareAttaqueArme(infoAttaque) {
const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence); const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence);
const attaque = duplicate(infoAttaque.arme); const attaque = foundry.utils.duplicate(infoAttaque.arme);
attaque.action = 'attaque'; attaque.action = 'attaque';
attaque.system.competence = infoAttaque.competence; attaque.system.competence = infoAttaque.competence;
attaque.system.dommagesReels = infoAttaque.dommagesReel; attaque.system.dommagesReels = infoAttaque.dommagesReel;
@ -890,7 +890,7 @@ export class RdDCombat {
// # utilisation esquive // # utilisation esquive
const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) }); const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) });
const esquives = duplicate(this.defender.getCompetencesEsquive()) const esquives = foundry.utils.duplicate(this.defender.getCompetencesEsquive())
esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0); esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
const paramChatDefense = { const paramChatDefense = {

6
module/rdd-empoignade.js
View File

@ -98,7 +98,7 @@ export class RdDEmpoignade {
/* -------------------------------------------- */ /* -------------------------------------------- */
static getEmpoignadeById(actor, id) { static getEmpoignadeById(actor, id) {
let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id) let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
return emp && duplicate(emp) || undefined; return emp && foundry.utils.duplicate(emp) || undefined;
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
@ -108,7 +108,7 @@ export class RdDEmpoignade {
(it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id) (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
) )
if (emp) { if (emp) {
return duplicate(emp); return foundry.utils.duplicate(emp);
} }
return undefined; return undefined;
} }
@ -267,7 +267,7 @@ export class RdDEmpoignade {
return return
} }
empoignade = duplicate(empoignade) empoignade = foundry.utils.duplicate(empoignade)
let defenderRoll = { let defenderRoll = {
mode, attacker, defender, empoignade, attackerRoll, mode, attacker, defender, empoignade, attackerRoll,
diffLibre: attackerRoll.diffLibre, diffLibre: attackerRoll.diffLibre,

6
module/rdd-possession.js
View File

@ -24,7 +24,7 @@ export class RdDPossession {
if (!poss) { if (!poss) {
poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id); poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
} }
return poss && duplicate(poss) || undefined; return poss && foundry.utils.duplicate(poss) || undefined;
} }
/* -------------------------------------------- */ /* -------------------------------------------- */
@ -52,7 +52,7 @@ export class RdDPossession {
/* -------------------------------------------- */ /* -------------------------------------------- */
static async onConjurerPossession(attacker, possession) { static async onConjurerPossession(attacker, possession) {
possession = duplicate(possession); possession = foundry.utils.duplicate(possession);
RdDPossession.$updateEtatPossession(possession) RdDPossession.$updateEtatPossession(possession)
const defender = game.actors.get(possession.system.entite.actorid); const defender = game.actors.get(possession.system.entite.actorid);
@ -80,7 +80,7 @@ export class RdDPossession {
ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!") ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
return return
} }
possession = duplicate(possession) possession = foundry.utils.duplicate(possession)
// Update for draconic roll // Update for draconic roll
let rollData = { let rollData = {
mode: "defense", mode: "defense",

2
module/rdd-resolution-table.js
View File

@ -114,7 +114,7 @@ export class RdDResolutionTable {
/* -------------------------------------------- */ /* -------------------------------------------- */
static async roll(caracValue, finalLevel, rollData = {}) { static async roll(caracValue, finalLevel, rollData = {}) {
let chances = duplicate(this.computeChances(caracValue, finalLevel)); let chances = foundry.utils.duplicate(this.computeChances(caracValue, finalLevel));
this._updateChancesWithBonus(chances, rollData.bonus, finalLevel); this._updateChancesWithBonus(chances, rollData.bonus, finalLevel);
this._updateChancesFactor(chances, rollData.diviseurSignificative); this._updateChancesFactor(chances, rollData.diviseurSignificative);
chances.showDice = rollData.showDice; chances.showDice = rollData.showDice;

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

@ -76,7 +76,7 @@ export class RdDSheetUtility {
static async _onSplitItem(item, split, actor) { static async _onSplitItem(item, split, actor) {
if (split >= 1 && split < item.system.quantite) { if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split); await item.diminuerQuantite(split);
const splitItem = duplicate(item); const splitItem = foundry.utils.duplicate(item);
// todo: ajouter dans le même conteneur? // todo: ajouter dans le même conteneur?
splitItem.system.quantite = split; splitItem.system.quantite = split;
await actor.createEmbeddedDocuments('Item', [splitItem]) await actor.createEmbeddedDocuments('Item', [splitItem])

8
module/rdd-tmr-dialog.js
View File

@ -70,7 +70,7 @@ export class RdDTMRDialog extends Dialog {
'z-index': 40 'z-index': 40
} }
super(dialogConf, dialogOptions); super(dialogConf, dialogOptions);
this.tmrdata = duplicate(tmrData); this.tmrdata = foundry.utils.duplicate(tmrData);
this.actor = actor; this.actor = actor;
this.actor.tmrApp = this; // reference this app in the actor structure this.actor.tmrApp = this; // reference this app in the actor structure
this.viewOnly = tmrData.mode == "visu" this.viewOnly = tmrData.mode == "visu"
@ -407,7 +407,7 @@ export class RdDTMRDialog extends Dialog {
/* -------------------------------------------- */ /* -------------------------------------------- */
$marquerCasesTMR(listCoordTMR) { $marquerCasesTMR(listCoordTMR) {
this.currentRencontre.locList = duplicate(listCoordTMR); // And track of allowed location this.currentRencontre.locList = foundry.utils.duplicate(listCoordTMR); // And track of allowed location
this.currentRencontre.graphics = listCoordTMR.map(coordTMR => this.pixiTMR.addMarkTMR(coordTMR)) this.currentRencontre.graphics = listCoordTMR.map(coordTMR => this.pixiTMR.addMarkTMR(coordTMR))
} }
@ -679,7 +679,7 @@ export class RdDTMRDialog extends Dialog {
if (this.isCaseHumide(tmr)) { if (this.isCaseHumide(tmr)) {
let rollData = { let rollData = {
actor: this.actor, actor: this.actor,
competence: duplicate(this.actor.getBestDraconic()), competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
tmr: tmr, tmr: tmr,
canClose: false, canClose: false,
diffLibre: -7, diffLibre: -7,
@ -804,7 +804,7 @@ export class RdDTMRDialog extends Dialog {
async _conquerir(tmr, options) { async _conquerir(tmr, options) {
let rollData = { let rollData = {
actor: this.actor, actor: this.actor,
competence: duplicate(this.actor.getBestDraconic()), competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
tmr: tmr, tmr: tmr,
canClose: options.canClose ?? false, canClose: options.canClose ?? false,
diffLibre: options.difficulte ?? -7, diffLibre: options.difficulte ?? -7,

8
module/rdd-utility.js
View File

@ -31,7 +31,7 @@ function _buildAllSegmentsFatigue(max) {
const cycle = [5, 2, 4, 1, 3, 0]; const cycle = [5, 2, 4, 1, 3, 0];
const fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]; const fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];
for (let i = 0; i <= max; i++) { for (let i = 0; i <= max; i++) {
const ligneFatigue = duplicate(fatigue[i]); const ligneFatigue = foundry.utils.duplicate(fatigue[i]);
const caseIncrementee = cycle[i % 6]; const caseIncrementee = cycle[i % 6];
ligneFatigue[caseIncrementee]++; ligneFatigue[caseIncrementee]++;
ligneFatigue[caseIncrementee + 6]++; ligneFatigue[caseIncrementee + 6]++;
@ -45,7 +45,7 @@ function _buildAllSegmentsFatigue(max) {
function _cumulSegmentsFatigue(matrix) { function _cumulSegmentsFatigue(matrix) {
let cumulMatrix = []; let cumulMatrix = [];
for (let line of matrix) { for (let line of matrix) {
let cumul = duplicate(line); let cumul = foundry.utils.duplicate(line);
for (let i = 1; i < 12; i++) { for (let i = 1; i < 12; i++) {
cumul[i] += cumul[i - 1]; cumul[i] += cumul[i - 1];
@ -607,10 +607,10 @@ export class RdDUtility {
for (let encaissement of table) { for (let encaissement of table) {
if ((encaissement.minimum === undefined || encaissement.minimum <= degats) if ((encaissement.minimum === undefined || encaissement.minimum <= degats)
&& (encaissement.maximum === undefined || degats <= encaissement.maximum)) { && (encaissement.maximum === undefined || degats <= encaissement.maximum)) {
return duplicate(encaissement); return foundry.utils.duplicate(encaissement);
} }
} }
return duplicate(table[0]); return foundry.utils.duplicate(table[0]);
} }
/* -------------------------------------------- */ /* -------------------------------------------- */

2
module/settings/regles-optionnelles.js
View File

@ -86,7 +86,7 @@ export class ReglesOptionnelles extends FormApplication {
getData() { getData() {
let formData = super.getData(); let formData = super.getData();
const regles = listeReglesOptionnelles.filter(it => game.user.isGM || it.scope == "client").map(it => { const regles = listeReglesOptionnelles.filter(it => game.user.isGM || it.scope == "client").map(it => {
it = duplicate(it); it = foundry.utils.duplicate(it);
it.id = ReglesOptionnelles._getIdRegle(it.name); it.id = ReglesOptionnelles._getIdRegle(it.name);
it.active = ReglesOptionnelles.isSet(it.name); it.active = ReglesOptionnelles.isSet(it.name);
return it; return it;

4
module/settings/status-effects.js
View File

@ -94,7 +94,7 @@ export class StatusEffects extends FormApplication {
static prepareActiveEffect(effectId) { static prepareActiveEffect(effectId) {
let status = rddStatusEffects.find(it => it.id == effectId) let status = rddStatusEffects.find(it => it.id == effectId)
if (status) { if (status) {
status = duplicate(status) status = foundry.utils.duplicate(status)
status.statuses = [effectId] status.statuses = [effectId]
} }
return status; return status;
@ -125,7 +125,7 @@ export class StatusEffects extends FormApplication {
getData() { getData() {
const used = StatusEffects._getUseStatusEffects(); const used = StatusEffects._getUseStatusEffects();
let formData = super.getData(); let formData = super.getData();
formData.effects = duplicate(CONFIG.RDD.allEffects); formData.effects = foundry.utils.duplicate(CONFIG.RDD.allEffects);
formData.effects.forEach(it => it.active = used.includes(it.id)) formData.effects.forEach(it => it.active = used.includes(it.id))
return formData; return formData;
} }

2
module/sommeil/app-astrologie.js
View File

@ -104,7 +104,7 @@ export class AppAstrologie extends Application {
} }
getDetailNombreAstral(nombreAstral) { getDetailNombreAstral(nombreAstral) {
const detail = duplicate(nombreAstral); const detail = foundry.utils.duplicate(nombreAstral);
const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index }); const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 }; detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
detail.valeursFausses.forEach(fausse => fausse.actorName = game.actors.get(fausse.actorId).name ?? "Inconnu"); detail.valeursFausses.forEach(fausse => fausse.actorName = game.actors.get(fausse.actorId).name ?? "Inconnu");

2
module/time/rdd-calendrier-editor.js
View File

@ -61,7 +61,7 @@ export class RdDCalendrierEditor extends Dialog {
/* -------------------------------------------- */ /* -------------------------------------------- */
updateData(calendrierData) { updateData(calendrierData) {
this.calendrierData = duplicate(calendrierData); this.calendrierData = foundry.utils.duplicate(calendrierData);
} }
} }

2
module/time/rdd-timestamp.js
View File

@ -202,7 +202,7 @@ export class RdDTimestamp {
} }
static setWorldTime(timestamp) { static setWorldTime(timestamp) {
game.settings.set(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, duplicate(timestamp)); game.settings.set(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, foundry.utils.duplicate(timestamp));
} }
/** construit un RdDTimestamp à partir de l'année/mois/jour/heure?/minute? */ /** construit un RdDTimestamp à partir de l'année/mois/jour/heure?/minute? */

2
module/tirage/fenetre-recherche-tirage.js
View File

@ -133,7 +133,7 @@ export class FenetreRechercheTirage extends Application {
const parameters = { const parameters = {
milieux: milieux, milieux: milieux,
filterMilieux: $filterMilieux(milieux), filterMilieux: $filterMilieux(milieux),
filterGroups: duplicate(FILTER_GROUPS).filter(it => it.group), filterGroups: foundry.utils.duplicate(FILTER_GROUPS).filter(it => it.group),
} }
const options = {} const options = {}
$loadFilters(parameters); $loadFilters(parameters);