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

Preparation du passage en v12

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)
const actor = this.actor;
formData.combat = duplicate(formData.armes);
formData.combat = foundry.utils.duplicate(formData.armes);
RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
formData.combat.push(RdDItemArme.mainsNues(actor));
formData.combat.push(RdDItemArme.empoignade(actor));
@ -221,7 +221,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
// Points de reve actuel
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('.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
this.html.find('.arme-initiative a').click(async event => {
@ -388,7 +388,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
async _onSplitItem(item, split) {
if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split);
const splitItem = duplicate(item);
const splitItem = foundry.utils.duplicate(item);
splitItem.system.quantite = split;
await this.actor.createEmbeddedDocuments('Item', [splitItem])
}

54
module/actor.js
View File

@ -120,7 +120,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
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 }
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() {
return [...this.getDraconicList().filter(it => it.system.niveau >= 0),
super.getDraconicOuPossession()]
@ -691,7 +691,7 @@ export class RdDActor extends RdDBaseActorSang {
}
let carac = this.findCaracByName(caracName);
if (carac) {
carac = duplicate(carac);
carac = foundry.utils.duplicate(carac);
const fromXp = Number(carac.xp);
const fromValue = Number(carac.value);
let toXp = fromXp;
@ -827,7 +827,7 @@ export class RdDActor extends RdDBaseActorSang {
async deleteExperienceLog(from, count) {
if (from >= 0 && count > 0) {
let expLog = duplicate(this.system.experiencelog);
let expLog = foundry.utils.duplicate(this.system.experiencelog);
expLog.splice(from, count);
await this.update({ [`system.experiencelog`]: expLog });
}
@ -1312,7 +1312,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
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 nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
@ -1489,7 +1489,7 @@ export class RdDActor extends RdDBaseActorSang {
const niveauSuivant = Number(carac.value) + 1;
let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
if (carac.xp >= xpNeeded) {
carac = duplicate(carac);
carac = foundry.utils.duplicate(carac);
carac.value = niveauSuivant;
let checkXp = {
@ -1519,7 +1519,7 @@ export class RdDActor extends RdDBaseActorSang {
if (compData && newXP > 0) {
let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1);
if (newXP >= xpNeeded) {
let newCompData = duplicate(compData);
let newCompData = foundry.utils.duplicate(compData);
newCompData.system.niveau += 1;
newCompData.system.xp = newXP;
let checkXp = {
@ -1625,14 +1625,14 @@ export class RdDActor extends RdDBaseActorSang {
return;
}
// 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) {
ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`);
return;
}
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({
name: 'lancer-un-sort',
@ -1873,7 +1873,7 @@ export class RdDActor extends RdDBaseActorSang {
diffConditions: 0,
use: { libre: false, conditions: true },
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)
@ -1884,7 +1884,7 @@ export class RdDActor extends RdDBaseActorSang {
async _tacheResult(rollData, options) {
// Mise à jour de la tache
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;
if (rollData.rolled.isETotal) {
rollData.tache.system.difficulte--;
@ -1912,17 +1912,17 @@ export class RdDActor extends RdDBaseActorSang {
{
oeuvre: oeuvre,
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,
diffConditions: 0,
use: { libre: false, conditions: true, surenc: false },
selectedCarac: duplicate(this.system.carac[selected])
selectedCarac: foundry.utils.duplicate(this.system.carac[selected])
},
{ overwrite: false });
artData.competence.system.defaut_carac = selected;
if (!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({
@ -1946,19 +1946,19 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
async rollChant(id) {
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);
}
/* -------------------------------------------- */
async rollDanse(id) {
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) {
artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite);
artData.forceCarac['agilite'] = foundry.utils.duplicate(this.system.carac.agilite);
}
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);
await this._rollArt(artData, selectedCarac, oeuvre);
@ -2061,7 +2061,7 @@ export class RdDActor extends RdDBaseActorSang {
const artData = {
art: 'jeu', verbe: 'Jeu',
use: { libre: true, conditions: true, },
competence: duplicate(this.getCompetence('jeu')),
competence: foundry.utils.duplicate(this.getCompetence('jeu')),
forceCarac: {}
};
listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]);
@ -2072,14 +2072,14 @@ export class RdDActor extends RdDBaseActorSang {
async rollOeuvre(id) {
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)
}
/* -------------------------------------------- */
async rollMeditation(id) {
const meditation = duplicate(this.getMeditation(id));
const competence = duplicate(this.getCompetence(meditation.system.competence));
const meditation = foundry.utils.duplicate(this.getMeditation(id));
const competence = foundry.utils.duplicate(this.getCompetence(meditation.system.competence));
competence.system.defaut_carac = "intellect"; // Meditation = toujours avec intellect
let meditationData = {
competence: competence,
@ -2145,7 +2145,7 @@ export class RdDActor extends RdDBaseActorSang {
}
let draconicList = this.getDraconicList()
.map(draconic => {
let draconicLecture = duplicate(draconic);
let draconicLecture = foundry.utils.duplicate(draconic);
draconicLecture.system.defaut_carac = "intellect";
return draconicLecture;
});
@ -2314,7 +2314,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
async _xpCarac(xpData) {
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 selectedCarac = carac[code]
if (this.isCaracMax(code)) {
@ -2618,7 +2618,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
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;
await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
console.log("ITEM USE INC", inc, itemUse);
@ -2712,7 +2712,7 @@ export class RdDActor extends RdDBaseActorSang {
}
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);
if (amoureux) {
amoureux[options.immediat ? 'coeur' : 'prochainCoeur'] = coeurs
@ -3066,7 +3066,7 @@ export class RdDActor extends RdDBaseActorSang {
incarnation.name = 'Réincarnation de ' + incarnation.name
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,
age: 18,
biographie: '',

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

@ -286,7 +286,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
getCarac() {
// 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(),
'chance-actuelle': this.getCaracChanceActuelle()
@ -471,7 +471,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
});
if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
encaissement = duplicate(encaissement);
encaissement = foundry.utils.duplicate(encaissement);
encaissement.isGM = true;
ChatMessage.create({
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) {
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 perteVie = await this.santeIncDec("vie", -encaissement.vie);
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")) {
return;
}
const sante = duplicate(this.system.sante)
const sante = foundry.utils.duplicate(this.system.sante)
let compteur = sante[name];
if (!compteur) {
return;

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

@ -312,7 +312,7 @@ export class RdDBaseActorSheet extends ActorSheet {
async _onSplitItem(item, split) {
if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split);
const splitItem = duplicate(item);
const splitItem = foundry.utils.duplicate(item);
splitItem.system.quantite = split;
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) {
RdDAudio.PlayContextAudio("argent");
}
const chatAchatItem = duplicate(achat.vente);
const chatAchatItem = foundry.utils.duplicate(achat.vente);
chatAchatItem.quantiteTotal = quantite;
ChatMessage.create({
user: achat.userId,
@ -649,7 +649,7 @@ export class RdDBaseActor extends Actor {
sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
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; });
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) {
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)) {
// déjà accordé
return;

2
module/actor/entite.js
View File

@ -93,7 +93,7 @@ export class RdDEntite extends RdDBaseActorReve {
/* -------------------------------------------- */
async setEntiteReveAccordee(attacker) {
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)) {
// déjà accordé
return;

2
module/chat-utility.js
View File

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

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

@ -69,7 +69,7 @@ export class RdDCoeur {
}
static async applyCoeurChateauDormant(actor, message) {
const newSuivants = duplicate(actor.system.subacteurs.suivants)
const newSuivants = foundry.utils.duplicate(actor.system.subacteurs.suivants)
let count = 0
newSuivants.forEach(async link => {
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) {
let potionData = duplicate(item)
let potionData = foundry.utils.duplicate(item)
potionData.nbBrinsSelect = RdDUtility.buildListOptions(
DialogFabriquerPotion.nombreBrinsMinimum(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) {
let consommerData = {
item: duplicate(item),
item: foundry.utils.duplicate(item),
cuisine: actor.getCompetence('cuisine'),
choix: {
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 containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
if (containsSlash) { // Sanity check
armeData = duplicate(armeData);
armeData = foundry.utils.duplicate(armeData);
const tableauDegats = armeData.system.dommages.split("/");
if (aUneMain)

2
module/item-competence.js
View File

@ -257,7 +257,7 @@ export class RdDItemCompetence extends Item {
/* -------------------------------------------- */
static computeResumeArchetype(competences) {
const computed = duplicate(limitesArchetypes);
const computed = foundry.utils.duplicate(limitesArchetypes);
computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; });
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) {
const deniers = duplicate(MONNAIE_ETAIN);
const deniers = foundry.utils.duplicate(MONNAIE_ETAIN);
deniers.system.quantite = fortune;
return deniers;
}

6
module/item-sheet.js
View File

@ -108,8 +108,8 @@ export class RdDItemSheet extends ItemSheet {
const competences = await SystemCompendiums.getCompetences('personnage');
formData.categories = this.item.getCategories()
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["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
formData.caracList = foundry.utils.duplicate(game.system.model.Actor.personnage.carac)
formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.system.model.Actor.personnage.reve.reve)
formData.competences = competences;
}
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.fin', updateItemTimestamp);

4
module/item.js
View File

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

2
module/item/maladie.js
View File

@ -38,7 +38,7 @@ export class RdDItemMaladie extends RdDItem {
await mal.actor.updateEmbeddedDocuments('Item', [{
_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) {
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.system.competence = infoAttaque.competence;
attaque.system.dommagesReels = infoAttaque.dommagesReel;
@ -890,7 +890,7 @@ export class RdDCombat {
// # utilisation esquive
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);
const paramChatDefense = {

6
module/rdd-empoignade.js
View File

@ -98,7 +98,7 @@ export class RdDEmpoignade {
/* -------------------------------------------- */
static getEmpoignadeById(actor, 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)
)
if (emp) {
return duplicate(emp);
return foundry.utils.duplicate(emp);
}
return undefined;
}
@ -267,7 +267,7 @@ export class RdDEmpoignade {
return
}
empoignade = duplicate(empoignade)
empoignade = foundry.utils.duplicate(empoignade)
let defenderRoll = {
mode, attacker, defender, empoignade, attackerRoll,
diffLibre: attackerRoll.diffLibre,

6
module/rdd-possession.js
View File

@ -24,7 +24,7 @@ export class RdDPossession {
if (!poss) {
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) {
possession = duplicate(possession);
possession = foundry.utils.duplicate(possession);
RdDPossession.$updateEtatPossession(possession)
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 !!")
return
}
possession = duplicate(possession)
possession = foundry.utils.duplicate(possession)
// Update for draconic roll
let rollData = {
mode: "defense",

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

@ -114,7 +114,7 @@ export class RdDResolutionTable {
/* -------------------------------------------- */
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._updateChancesFactor(chances, rollData.diviseurSignificative);
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) {
if (split >= 1 && split < item.system.quantite) {
await item.diminuerQuantite(split);
const splitItem = duplicate(item);
const splitItem = foundry.utils.duplicate(item);
// todo: ajouter dans le même conteneur?
splitItem.system.quantite = split;
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
}
super(dialogConf, dialogOptions);
this.tmrdata = duplicate(tmrData);
this.tmrdata = foundry.utils.duplicate(tmrData);
this.actor = actor;
this.actor.tmrApp = this; // reference this app in the actor structure
this.viewOnly = tmrData.mode == "visu"
@ -407,7 +407,7 @@ export class RdDTMRDialog extends Dialog {
/* -------------------------------------------- */
$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))
}
@ -679,7 +679,7 @@ export class RdDTMRDialog extends Dialog {
if (this.isCaseHumide(tmr)) {
let rollData = {
actor: this.actor,
competence: duplicate(this.actor.getBestDraconic()),
competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
tmr: tmr,
canClose: false,
diffLibre: -7,
@ -804,7 +804,7 @@ export class RdDTMRDialog extends Dialog {
async _conquerir(tmr, options) {
let rollData = {
actor: this.actor,
competence: duplicate(this.actor.getBestDraconic()),
competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
tmr: tmr,
canClose: options.canClose ?? false,
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 fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];
for (let i = 0; i <= max; i++) {
const ligneFatigue = duplicate(fatigue[i]);
const ligneFatigue = foundry.utils.duplicate(fatigue[i]);
const caseIncrementee = cycle[i % 6];
ligneFatigue[caseIncrementee]++;
ligneFatigue[caseIncrementee + 6]++;
@ -45,7 +45,7 @@ function _buildAllSegmentsFatigue(max) {
function _cumulSegmentsFatigue(matrix) {
let cumulMatrix = [];
for (let line of matrix) {
let cumul = duplicate(line);
let cumul = foundry.utils.duplicate(line);
for (let i = 1; i < 12; i++) {
cumul[i] += cumul[i - 1];
@ -607,10 +607,10 @@ export class RdDUtility {
for (let encaissement of table) {
if ((encaissement.minimum === undefined || encaissement.minimum <= degats)
&& (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() {
let formData = super.getData();
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.active = ReglesOptionnelles.isSet(it.name);
return it;

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

@ -94,7 +94,7 @@ export class StatusEffects extends FormApplication {
static prepareActiveEffect(effectId) {
let status = rddStatusEffects.find(it => it.id == effectId)
if (status) {
status = duplicate(status)
status = foundry.utils.duplicate(status)
status.statuses = [effectId]
}
return status;
@ -125,7 +125,7 @@ export class StatusEffects extends FormApplication {
getData() {
const used = StatusEffects._getUseStatusEffects();
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))
return formData;
}

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

@ -104,7 +104,7 @@ export class AppAstrologie extends Application {
}
getDetailNombreAstral(nombreAstral) {
const detail = duplicate(nombreAstral);
const detail = foundry.utils.duplicate(nombreAstral);
const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
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) {
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) {
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? */

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

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