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

:wqMerge branch 'v1.3' into feature/UIappelAuMoral

Browse Source
This commit is contained in:
LeFelis
2021-02-12 22:41:04 +01:00
parent 5a7dc1d437 1ea940a975
commit 1f8608c902
32 changed files with 1046 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
module/actor.js
View File

@ -1143,12 +1143,6 @@ export class RdDActor extends Actor {
displayTMRQueueSouffleInformation() {
let messages = [];
for (let item of this.data.items) {
if (EffetsDraconiques.isConquete(item)) {
messages.push("Vous souffrez d'une <strong>Conquête</strong> : " + item.data.description);
}
if (EffetsDraconiques.isPelerinage(item)) {
messages.push("Vous souffrez d'un <strong>Pélerinage</strong> : " + item.data.description);
}
if (EffetsDraconiques.isUrgenceDraconique(item)) {
messages.push("Vous souffrez d'une <strong>Urgence Draconique</strong> : " + item.data.description);
}
@ -1811,8 +1805,8 @@ export class RdDActor extends Actor {
ui.notifications.info("Aucun sort disponible pour cette case !");
return;
}
if (EffetsDraconiques.isConquete(this)) {
ui.notifications.error("Vous ne pouvez pas lancer de sort sous l'effet d'une conquête!");
if (EffetsDraconiques.isSortImpossible(this)) {
ui.notifications.error("Une queue ou un souffle vous empèche de lancer de sort!");
return;
}
if (this.currentTMR) this.currentTMR.minimize(); // Hide
@ -1880,7 +1874,7 @@ export class RdDActor extends Actor {
let countInertieDraconique = EffetsDraconiques.countInertieDraconique(this);
if (countInertieDraconique > 0) {
ChatMessage.create({
content: `Vous êtes sous le coup d'une Inertie Draconique : vous perdez ${countInertieDraconique + 1} cases de Fatigue par déplacement au lieu d'une.`,
content: `Vous êtes sous le coup d'Inertie Draconique : vous perdrez ${countInertieDraconique + 1} cases de Fatigue par déplacement au lieu d'une.`,
whisper: ChatMessage.getWhisperRecipients(game.user.name)
});
}
@ -1888,9 +1882,9 @@ export class RdDActor extends Actor {
}
/* -------------------------------------------- */
async checkSoufflePeage(cellDescr) {
async checkSoufflePeage(tmr) {
let peage = this.data.items.find(item => EffetsDraconiques.isPeage(item));
if (peage && (cellDescr.type == 'pont' || cellDescr.type == 'cite')) {
if (peage && (tmr.type == 'pont' || tmr.type == 'cite')) {
await this.reveActuelIncDec(-1);
ChatMessage.create({
content: "Vous êtes sous le coup d'un Péage : l'entrée sur cette case vous a coûté 1 Point de Rêve (déduit automatiquement).",

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

@ -138,18 +138,24 @@ export class RdDResolutionTable {
mergeObject(chances, this._computeCell(null, newScore), { overwrite: true });
}
}
static significativeRequise(chances) {
chances.roll = Math.floor(chances.score / 2);
mergeObject(chances, reussites.find(x => x.code == 'sign'), { overwrite: true });
}
static succesRequis(chances) {
chances.roll = chances.score;
mergeObject(chances, reussites.find(x => x.code == 'norm'), { overwrite: true });
}
/* -------------------------------------------- */
static async rollChances(chances) {
let myRoll = new Roll("1d100").roll();
myRoll.showDice = chances.showDice;
await RdDDice.show(myRoll);
chances.roll = myRoll.total;
mergeObject(chances, this._computeReussite(chances, chances.roll), { overwrite: true });
mergeObject(chances, this.computeReussite(chances, chances.roll), { overwrite: true });
return chances;
}
@ -210,7 +216,7 @@ export class RdDResolutionTable {
}
/* -------------------------------------------- */
static _computeReussite(chances, roll) {
static computeReussite(chances, roll) {
return reussites.find(x => x.condition(chances, roll));
}

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

@ -81,7 +81,7 @@ export class RdDTMRDialog extends Dialog {
/* -------------------------------------------- */
createPixiSprites() {
EffetsDraconiques.carteTmr._createSprite(this.pixiTMR);
EffetsDraconiques.carteTmr.createSprite(this.pixiTMR);
this.updateTokens();
@ -123,9 +123,9 @@ export class RdDTMRDialog extends Dialog {
_tokenRencontre(rencontre) {
return EffetsDraconiques.rencontre.token(this.pixiTMR, rencontre, () => rencontre.coord);
}
_tokenCaseSpeciale(caseSpeciale) {
const draconique = Draconique.get(caseSpeciale.data.specific);
return draconique?.token(this.pixiTMR, caseSpeciale, () => caseSpeciale.data.coord);
_tokenCaseSpeciale(casetmr) {
const draconique = Draconique.get(casetmr.data.specific);
return draconique?.token(this.pixiTMR, casetmr, () => casetmr.data.coord);
}
_tokenSortEnReserve(sortEnReserve) {
return EffetsDraconiques.sortReserve.token(this.pixiTMR, sortEnReserve.sort, () => sortEnReserve.coord);
@ -313,7 +313,7 @@ export class RdDTMRDialog extends Dialog {
}
/* -------------------------------------------- */
async _tentativeMaitrise(rencontreData) {
async _tentativeMaitrise(rencontreData, presentCite) {
console.log("-> matriser", rencontreData);
rencontreData.reve = this.actor.getReveActuel();
@ -321,7 +321,10 @@ export class RdDTMRDialog extends Dialog {
RollDataAjustements.calcul(rencontreData, this.actor);
rencontreData.rolled = await RdDResolutionTable.roll(rencontreData.reve, RollDataAjustements.sum(rencontreData.ajustements));
rencontreData.rolled = rencontreData.presentCite
? this._rollPresentCite(rencontreData)
: await RdDResolutionTable.roll(rencontreData.reve, RollDataAjustements.sum(rencontreData.ajustements));
let postProcess = await TMRRencontres.gererRencontre(this, rencontreData);
ChatMessage.create({
@ -351,6 +354,13 @@ export class RdDTMRDialog extends Dialog {
}
}
_rollPresentCite(rencontreData) {
let rolled = RdDResolutionTable.computeChances(rencontreData.reve, 0);
mergeObject(rolled, { caracValue: rencontreData.reve, finalLevel: 0, roll: rolled.score });
RdDResolutionTable.succesRequis(rolled);
return rolled;
}
/* -------------------------------------------- */
_deleteTmrMessages(actor, nbRounds = -1) {
setTimeout(() => {
@ -381,6 +391,9 @@ export class RdDTMRDialog extends Dialog {
return;
}
this.currentRencontre = undefined;
if (this._presentCite(tmr, postRencontre)) {
return;
}
let rencontre = await this._jetDeRencontre(tmr);
if (rencontre) { // Manages it
@ -396,19 +409,43 @@ export class RdDTMRDialog extends Dialog {
}
}
_presentCite(tmr, postRencontre) {
const presentCite = this.casesSpeciales.find(c => EffetsDraconiques.presentCites.isCase(c, tmr.coord));
if (presentCite) {
this.minimize();
EffetsDraconiques.presentCites.choisirUnPresent(presentCite, (type => this._utiliserPresentCite(presentCite, type, tmr, postRencontre)));
}
return presentCite;
}
async _utiliserPresentCite(presentCite, typeRencontre, tmr, postRencontre) {
this.currentRencontre = TMRRencontres.getRencontre(typeRencontre);
await TMRRencontres.evaluerForceRencontre(this.currentRencontre);
await EffetsDraconiques.presentCites.ouvrirLePresent(this.actor, presentCite);
this.removeToken(tmr, presentCite);
// simuler une rencontre
let rencontreData = {
actor: this.actor,
alias: this.actor.name,
reveDepart: this.actor.getReveActuel(),
competence: this.actor.getBestDraconic(),
rencontre: this.currentRencontre,
tmr: tmr,
presentCite: presentCite
};
await this._tentativeMaitrise(rencontreData);
this.maximize();
postRencontre();
}
/* -------------------------------------------- */
async _jetDeRencontre(tmr) {
let rencontre = this.rencontresExistantes.find(prev => prev.coord == tmr.coord);
if (rencontre) {
return rencontre;
}
if (this.casesSpeciales.find(c => EffetsDraconiques.isPresentCite(c, tmr.coord))) {
// TODO: dialog pour remplacer la rencontre par un présent
}
let myRoll = new Roll("1d7").evaluate().total;
if (TMRUtility.isForceRencontre() || myRoll == 7) {
return await this.rencontreTMRRoll(tmr, this.actor.isRencontreSpeciale());
@ -416,7 +453,6 @@ export class RdDTMRDialog extends Dialog {
this._tellToUser(myRoll + ": Pas de rencontre en " + tmr.label + " (" + tmr.coord + ")");
}
/* -------------------------------------------- */
async rencontreTMRRoll(tmr, isMauvaise = false) {
let rencontre = TMRUtility.utiliseForceRencontre() ??
@ -450,8 +486,8 @@ export class RdDTMRDialog extends Dialog {
forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: this.actor.getReveActuel() } },
maitrise: { verbe: 'maîtriser', action: 'Maîtriser le fleuve' }
}
rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true: undefined,
rollData.competence.data.defaut_carac = 'reve-actuel';
rollData.double = EffetsDraconiques.isDoubleResistanceFleuve(this.actor) ? true : undefined,
rollData.competence.data.defaut_carac = 'reve-actuel';
await this._rollMaitriseCaseHumide(rollData);
}
}
@ -522,7 +558,7 @@ export class RdDTMRDialog extends Dialog {
await this._conquerir(tmr, {
difficulte: -9,
action: 'Conquérir la cité',
onConqueteReussie: r => EffetsDraconiques.fermetureCites.onConquete(r.actor, tmr.coord),
onConqueteReussie: r => EffetsDraconiques.fermetureCites.onConquete(r.actor, tmr, (casetmr) => this.removeToken(tmr, casetmr)),
onConqueteEchec: r => this.close(),
canClose: false
});
@ -540,8 +576,8 @@ export class RdDTMRDialog extends Dialog {
await this._conquerir(tmr, {
difficulte: -7,
action: 'Conquérir',
onConqueteReussie: r => EffetsDraconiques.conquete.onConquete(r.actor, tmr.coord, (casetmr) => this.removeToken(tmr, casetmr)),
onConqueteEchec: r => {},
onConqueteReussie: r => EffetsDraconiques.conquete.onConquete(r.actor, tmr, (casetmr) => this.removeToken(tmr, casetmr)),
onConqueteEchec: r => { },
canClose: false
});
}
@ -603,13 +639,18 @@ export class RdDTMRDialog extends Dialog {
dialog.render(true);
}
async validerPelerinage(tmr) {
await EffetsDraconiques.pelerinage.onFinPelerinage(this.actor, tmr, (casetmr) => this.removeToken(tmr, casetmr));
}
/* -------------------------------------------- */
async declencheSortEnReserve(coord) {
let sortReserveList = TMRUtility.getSortReserveList(this.sortsReserves, coord);
if (sortReserveList.length > 0) {
if (EffetsDraconiques.isConquete(this.actor)) {
ui.notifications.error("Vous ne pouvez pas déclencher de sort sous l'effet d'une conquête!");
if (EffetsDraconiques.isSortImpossible(this.actor)) {
ui.notifications.error("Une queue ou un souffle vous empèche de déclencher de sort!");
return;
}
if (EffetsDraconiques.isReserveEnSecurite(this.actor) || this.isReserveExtensible(coord)) {
@ -795,26 +836,23 @@ export class RdDTMRDialog extends Dialog {
await this.manageCaseHumide(tmr);
await this.conquerirCiteFermee(tmr);
await this.conquerirTMR(tmr);
await this.validerPelerinage(tmr);
await this.declencheSortEnReserve(tmr.coord);
await this.actor.checkSoufflePeage(tmr);
}
}
/* -------------------------------------------- */
async forceDemiRevePositionView() {
this._updateDemiReve();
}
/* -------------------------------------------- */
async forceDemiRevePosition(coord) {
await this.actor.updateCoordTMR(coord);
this._updateDemiReve();
let tmr = TMRUtility.getTMR(coord);
if (!(this.viewOnly || this.currentRencontre)) {
await this.manageCaseHumide(tmr);
await this.conquerirCiteFermee(tmr);
await this.declencheSortEnReserve(tmr.coord);
}
await this.postRencontre(tmr);
return tmr;
}

368
module/rdd-utility.js
View File

@ -31,60 +31,60 @@ const ajustementsEncaissement = [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, +1,
const tableCaracDerivee = {
// xp: coût pour passer du niveau inférieur à ce niveau
1: { xp: 3, poids: "moins de 1kg", plusdom:-5, sconst: 0.5, sust: 0.1 },
2: { xp: 3, poids: "1-5", plusdom:-4, sconst: 0.5, sust: 0.3 },
3: { xp: 4, poids: "6-10", plusdom:-3, sconst: 1, sust: 0.5 , beaute:'hideux'},
4: { xp: 4, poids: "11-20", plusdom:-3, sconst: 1, sust: 1 , beaute:'repoussant'},
5: { xp: 5, poids: "21-30", plusdom:-2, sconst: 1, sust: 1 , beaute:'franchement très laid'},
6: { xp: 5, poids: "31-40", plusdom:-1, sconst: 2, sust: 2 , beaute:'laid'},
7: { xp: 6, poids: "41-50", plusdom:-1, sconst: 2, sust: 2 , beaute:'très désavantagé'},
8: { xp: 6, poids: "51-60", plusdom:0, sconst: 2, sust: 2 , beaute:'désavantagé'},
9: { xp: 7, poids: "61-65", plusdom:0, sconst: 3, sust: 2 , beaute:'pas terrible'},
10: { xp: 7, poids: "66-70", plusdom:0, sconst: 3, sust: 3 , beaute:'commun'},
11: { xp: 8, poids: "71-75", plusdom:0, sconst: 3, sust: 3 , beaute:'pas mal'},
12: { xp: 8, poids: "76-80", plusdom:+1, sconst: 4, sust: 3 , beaute:'avantagé'},
13: { xp: 9, poids: "81-90", plusdom:+1, sconst: 4, sust: 3 , beaute:'mignon'},
14: { xp: 9, poids: "91-100", plusdom:+2, sconst: 4, sust: 4 , beaute:'beau'},
15: { xp: 10, poids: "101-110", plusdom:+2, sconst: 5, sust: 4 , beaute:'très beau'},
16: { xp: 20, poids: "111-120", plusdom:+3, sconst: 5, sust: 4 , beaute:'éblouissant'},
17: { xp: 30, poids: "121-131", plusdom:+3, sconst: 5, sust: 5 },
18: { xp: 40, poids: "131-141", plusdom:+4, sconst: 6, sust: 5 },
19: { xp: 50, poids: "141-150", plusdom:+4, sconst: 6, sust: 5 },
20: { xp: 60, poids: "151-160", plusdom:+4, sconst: 6, sust: 6 },
21: { xp: 70, poids: "161-180", plusdom:+5, sconst: 7, sust: 6 },
22: { xp: 80, poids: "181-200", plusdom:+5, sconst: 7, sust: 7 },
23: { xp: 90, poids: "201-300", plusdom:+6, sconst: 7, sust: 8 },
24: { xp: 100, poids: "301-400", plusdom:+6, sconst: 8, sust: 9 },
25: { xp: 110, poids: "401-500", plusdom:+7, sconst: 8, sust: 10 },
26: { xp: 120, poids: "501-600", plusdom:+7, sconst: 8, sust: 11 },
27: { xp: 130, poids: "601-700", plusdom:+8, sconst: 9, sust: 12 },
28: { xp: 140, poids: "701-800", plusdom:+8, sconst: 9, sust: 13 },
29: { xp: 150, poids: "801-900", plusdom:+9, sconst: 9, sust: 14 },
30: { xp: 160, poids: "901-1000", plusdom:+9, sconst: 10, sust: 15 },
31: { xp: 170, poids: "1001-1500", plusdom:+10, sconst: 10, sust: 16 },
32: { xp: 180, poids: "1501-2000", plusdom:+11, sconst: 10, sust: 17 }
1: { xp: 3, poids: "moins de 1kg", plusdom: -5, sconst: 0.5, sust: 0.1 },
2: { xp: 3, poids: "1-5", plusdom: -4, sconst: 0.5, sust: 0.3 },
3: { xp: 4, poids: "6-10", plusdom: -3, sconst: 1, sust: 0.5, beaute: 'hideux' },
4: { xp: 4, poids: "11-20", plusdom: -3, sconst: 1, sust: 1, beaute: 'repoussant' },
5: { xp: 5, poids: "21-30", plusdom: -2, sconst: 1, sust: 1, beaute: 'franchement très laid' },
6: { xp: 5, poids: "31-40", plusdom: -1, sconst: 2, sust: 2, beaute: 'laid' },
7: { xp: 6, poids: "41-50", plusdom: -1, sconst: 2, sust: 2, beaute: 'très désavantagé' },
8: { xp: 6, poids: "51-60", plusdom: 0, sconst: 2, sust: 2, beaute: 'désavantagé' },
9: { xp: 7, poids: "61-65", plusdom: 0, sconst: 3, sust: 2, beaute: 'pas terrible' },
10: { xp: 7, poids: "66-70", plusdom: 0, sconst: 3, sust: 3, beaute: 'commun' },
11: { xp: 8, poids: "71-75", plusdom: 0, sconst: 3, sust: 3, beaute: 'pas mal' },
12: { xp: 8, poids: "76-80", plusdom: +1, sconst: 4, sust: 3, beaute: 'avantagé' },
13: { xp: 9, poids: "81-90", plusdom: +1, sconst: 4, sust: 3, beaute: 'mignon' },
14: { xp: 9, poids: "91-100", plusdom: +2, sconst: 4, sust: 4, beaute: 'beau' },
15: { xp: 10, poids: "101-110", plusdom: +2, sconst: 5, sust: 4, beaute: 'très beau' },
16: { xp: 20, poids: "111-120", plusdom: +3, sconst: 5, sust: 4, beaute: 'éblouissant' },
17: { xp: 30, poids: "121-131", plusdom: +3, sconst: 5, sust: 5 },
18: { xp: 40, poids: "131-141", plusdom: +4, sconst: 6, sust: 5 },
19: { xp: 50, poids: "141-150", plusdom: +4, sconst: 6, sust: 5 },
20: { xp: 60, poids: "151-160", plusdom: +4, sconst: 6, sust: 6 },
21: { xp: 70, poids: "161-180", plusdom: +5, sconst: 7, sust: 6 },
22: { xp: 80, poids: "181-200", plusdom: +5, sconst: 7, sust: 7 },
23: { xp: 90, poids: "201-300", plusdom: +6, sconst: 7, sust: 8 },
24: { xp: 100, poids: "301-400", plusdom: +6, sconst: 8, sust: 9 },
25: { xp: 110, poids: "401-500", plusdom: +7, sconst: 8, sust: 10 },
26: { xp: 120, poids: "501-600", plusdom: +7, sconst: 8, sust: 11 },
27: { xp: 130, poids: "601-700", plusdom: +8, sconst: 9, sust: 12 },
28: { xp: 140, poids: "701-800", plusdom: +8, sconst: 9, sust: 13 },
29: { xp: 150, poids: "801-900", plusdom: +9, sconst: 9, sust: 14 },
30: { xp: 160, poids: "901-1000", plusdom: +9, sconst: 10, sust: 15 },
31: { xp: 170, poids: "1001-1500", plusdom: +10, sconst: 10, sust: 16 },
32: { xp: 180, poids: "1501-2000", plusdom: +11, sconst: 10, sust: 17 }
}
/* -------------------------------------------- */
const premierRoundInit = [
{ pattern: 'hast', init: 3.90},
{ pattern: 'lance', init: 3.85},
{ pattern: 'baton', init: 3.80},
{ pattern: 'doubledragonne', init: 3.75},
{ pattern: 'esparlongue', init: 3.70},
{ pattern: 'epeedragonne', init: 3.65},
{ pattern: 'epeebatarde', init: 3.60},
{ pattern: 'epeecyane', init: 3.55},
{ pattern: 'epeesorde', init: 3.50},
{ pattern: 'grandehache', init: 3.45},
{ pattern: 'bataille', init: 3.40},
{ pattern: 'epeegnome', init: 3.35},
{ pattern: 'masse', init: 3.30},
{ pattern: 'gourdin', init: 3.25},
{ pattern: 'fléau', init: 3.20},
{ pattern: 'dague', init: 3.15},
{ pattern: 'autre', init: 3.10},
];
/* -------------------------------------------- */
const premierRoundInit = [
{ pattern: 'hast', init: 3.90 },
{ pattern: 'lance', init: 3.85 },
{ pattern: 'baton', init: 3.80 },
{ pattern: 'doubledragonne', init: 3.75 },
{ pattern: 'esparlongue', init: 3.70 },
{ pattern: 'epeedragonne', init: 3.65 },
{ pattern: 'epeebatarde', init: 3.60 },
{ pattern: 'epeecyane', init: 3.55 },
{ pattern: 'epeesorde', init: 3.50 },
{ pattern: 'grandehache', init: 3.45 },
{ pattern: 'bataille', init: 3.40 },
{ pattern: 'epeegnome', init: 3.35 },
{ pattern: 'masse', init: 3.30 },
{ pattern: 'gourdin', init: 3.25 },
{ pattern: 'fléau', init: 3.20 },
{ pattern: 'dague', init: 3.15 },
{ pattern: 'autre', init: 3.10 },
];
/* -------------------------------------------- */
function _buildAllSegmentsFatigue(max) {
@ -235,7 +235,7 @@ export class RdDUtility {
'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.html',
// messages tchat
'systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html',
'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html',
'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html',
'systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html',
'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html',
'systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html',
@ -254,10 +254,10 @@ export class RdDUtility {
'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html'
];
Handlebars.registerHelper('upperFirst', str=> Misc.upperFirst(str ?? 'Null'));
Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? 'NULL' );
Handlebars.registerHelper('le', str => Grammar.articleDetermine(str) );
Handlebars.registerHelper('un', str => Grammar.articleIndetermine(str) );
Handlebars.registerHelper('upperFirst', str => Misc.upperFirst(str ?? 'Null'));
Handlebars.registerHelper('upper', str => str?.toUpperCase() ?? 'NULL');
Handlebars.registerHelper('le', str => Grammar.articleDetermine(str));
Handlebars.registerHelper('un', str => Grammar.articleIndetermine(str));
return loadTemplates(templatePaths);
}
@ -287,7 +287,7 @@ export class RdDUtility {
}
/* -------------------------------------------- */
static getAfficheContenu(conteneurId) {
if ( conteneurId )
if (conteneurId)
return this.afficheContenu[conteneurId];
return undefined;
}
@ -327,8 +327,8 @@ export class RdDUtility {
console.log(dragData, actorSheet.actor._id);
let dropID = $(event.target).parents(".item").attr("data-item-id"); // Only relevant if container drop
let objetId = dragData.id || dragData.data._id;
if ( dragData.type == 'Item') {
if ( dropID ) { // Dropped over an item !!!
if (dragData.type == 'Item') {
if (dropID) { // Dropped over an item !!!
if (actorSheet.objetVersConteneur[objetId] != dropID && objetId != dropID) {
if (actorSheet.actor.validateConteneur(objetId, dropID) && actorSheet.actor.testConteneurCapacite(objetId, dropID)) {
await actorSheet.actor.enleverDeConteneur(objetId, actorSheet.objetVersConteneur[objetId]);
@ -336,14 +336,14 @@ export class RdDUtility {
}
}
}
if (dragData.actorId && dragData.actorId != actorSheet.actor._id ) { // Un acteur est à l'origine de l'item -> deplacement
if (dragData.actorId && dragData.actorId != actorSheet.actor._id) { // Un acteur est à l'origine de l'item -> deplacement
console.log("Moving objects");
actorSheet.actor.moveItemsBetweenActors( objetId, dragData.actorId);
actorSheet.actor.moveItemsBetweenActors(objetId, dragData.actorId);
return false;
}
actorSheet.actor.computeEncombrementTotalEtMalusArmure();
} else if ( dragData.type == "Actor" ) {
actorSheet.actor.addSubacteur( objetId );
} else if (dragData.type == "Actor") {
actorSheet.actor.addSubacteur(objetId);
}
return true;
}
@ -434,7 +434,7 @@ export class RdDUtility {
}
static getCaracXp(targetValue) {
return tableCaracDerivee[targetValue]?.xp ?? 200 ;
return tableCaracDerivee[targetValue]?.xp ?? 200;
}
/* -------------------------------------------- */
@ -487,13 +487,13 @@ export class RdDUtility {
data.carac.derobee.value = Math.floor(parseInt(((21 - data.carac.taille.value)) + parseInt(data.carac.agilite.value)) / 2);
let bonusDomKey = Math.floor((parseInt(data.carac.force.value) + parseInt(data.carac.taille.value)) / 2);
bonusDomKey = Math.min( Math.max(bonusDomKey, 0), 32); // Clamp de securite
bonusDomKey = Math.min(Math.max(bonusDomKey, 0), 32); // Clamp de securite
let tailleData = tableCaracDerivee[bonusDomKey];
data.attributs.plusdom.value = tailleData.plusdom;
data.attributs.sconst.value = RdDUtility.calculSConst(data.carac.constitution.value);
data.attributs.sust.value = tableCaracDerivee[Number(data.carac.taille.value)].sust;
data.attributs.sconst.value = RdDUtility.calculSConst(data.carac.constitution.value);
data.attributs.sust.value = tableCaracDerivee[Number(data.carac.taille.value)].sust;
data.attributs.encombrement.value = (parseInt(data.carac.force.value) + parseInt(data.carac.taille.value)) / 2;
data.carac.melee.value = Math.floor((parseInt(data.carac.force.value) + parseInt(data.carac.agilite.value)) / 2);
@ -579,10 +579,10 @@ export class RdDUtility {
}
/* -------------------------------------------- */
static getLocalisation( type = 'personnage' ) {
static getLocalisation(type = 'personnage') {
let result = new Roll("1d20").roll().total;
let txt = ""
if ( type == 'personnage') {
if (type == 'personnage') {
if (result <= 3) txt = "Jambe, genou, pied, jarret";
else if (result <= 7) txt = "Hanche, cuisse, fesse";
else if (result <= 9) txt = "Ventre, reins";
@ -594,7 +594,7 @@ export class RdDUtility {
} else {
if (result <= 7) txt = "Jambes/Pattes";
else if (result <= 18) txt = "Corps";
else if (result <= 20) txt = "Tête";
else if (result <= 20) txt = "Tête";
}
return { result: result, label: txt };
@ -680,36 +680,36 @@ export class RdDUtility {
return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
case "msg_response_nombre_astral":
return RdDUtility.responseNombreAstral(sockmsg.data);
case "msg_tmr_move":
if ( game.user.isGM ) {
let actor = game.actors.get( sockmsg.data.actorId);
actor.refreshTMRView( sockmsg.data.tmrPos );
}
case "msg_tmr_move":
if (game.user.isGM) {
let actor = game.actors.get(sockmsg.data.actorId);
actor.refreshTMRView(sockmsg.data.tmrPos);
}
}
}
/* -------------------------------------------- */
static processPremierRoundInit() {
// Check if we have the whole init !
if ( game.user.isGM) {
if (game.user.isGM) {
let initDone = true;
for( let combatant of game.combat.data.combatants) {
if ( !combatant.initiative ) initDone = false;
for (let combatant of game.combat.data.combatants) {
if (!combatant.initiative) initDone = false;
}
if (initDone && game.combat.current.round == 1) { // Premier round !
for( let combatant of game.combat.data.combatants) {
for (let combatant of game.combat.data.combatants) {
let arme = combatant.initiativeData.arme;
//console.log("Parsed !!!", combatant, initDone, game.combat.current, arme);
if ( arme && arme.type == "arme" ) {
if (arme && arme.type == "arme") {
for (let initData of premierRoundInit) {
if ( arme.data.initpremierround.toLowerCase().includes(initData.pattern) ) {
if (arme.data.initpremierround.toLowerCase().includes(initData.pattern)) {
let msg = `<h4>L'initiative de ${combatant.actor.name} a été modifiée !</h4>
<hr>
<div>
Etant donné son ${arme.name}, son initative pour ce premier round est désormais de ${initData.init}.
</div>`
ChatMessage.create( { content: msg } );
game.combat.setInitiative(combatant._id, initData.init);
ChatMessage.create({ content: msg });
game.combat.setInitiative(combatant._id, initData.init);
}
}
}
@ -717,18 +717,18 @@ export class RdDUtility {
}
}
}
/* -------------------------------------------- */
static rollInitiativeCompetence(combatantId, arme) {
const combatant = game.combat.getCombatant(combatantId);
const actor = combatant.actor;
let initOffset = 0;
let initOffset = 0;
let caracForInit = 0;
let compNiveau = 0;
if ( actor.getSurprise() == "totale") {
let compNiveau = 0;
if (actor.getSurprise() == "totale") {
initOffset = -1; // To force 0
} else if ( actor.getSurprise() == "demi") {
} else if (actor.getSurprise() == "demi") {
initOffset = 0;
} else if (arme.name == "Autre action") {
initOffset = 2;
@ -738,10 +738,10 @@ export class RdDUtility {
initOffset = 3; // Melée = 3.XX
let competence = RdDItemCompetence.findCompetence(combatant.actor.data.items, arme.data.competence);
compNiveau = competence.data.niveau;
if (actor.data.type == 'creature' || actor.data.type == 'entite') {
caracForInit = competence.data.carac_value;
if ( competence.data.categorie == "lancer") {
if (competence.data.categorie == "lancer") {
initOffset = 5;
}
} else {
@ -759,7 +759,7 @@ export class RdDUtility {
}
let malus = actor.getEtatGeneral(); // Prise en compte état général
// Cas des créatures et entités vs personnages
let rollFormula = initOffset + "+ ( (" + RdDUtility.calculInitiative(compNiveau, caracForInit) + " + " + malus + ") /100)";
let rollFormula = initOffset + "+ ( (" + RdDUtility.calculInitiative(compNiveau, caracForInit) + " + " + malus + ") /100)";
// Garder la trace de l'arme/compétence utilisée pour l'iniative
combatant.initiativeData = { arme: arme } // pour reclasser l'init au round 0
game.combat.rollInitiative(combatantId, rollFormula);
@ -812,41 +812,41 @@ export class RdDUtility {
}
/* -------------------------------------------- */
static incDecInit(combatantId, incDecValue ) {
static incDecInit(combatantId, incDecValue) {
const combatant = game.combat.getCombatant(combatantId);
let initValue = combatant.initiative + incDecValue;
game.combat.setInitiative( combatantId, initValue );
game.combat.setInitiative(combatantId, initValue);
}
/* -------------------------------------------- */
static pushInitiativeOptions(html, options) {
for (let i =0; i<options.length; i++) {
for (let i = 0; i < options.length; i++) {
let option = options[i];
if ( option.name == 'COMBAT.CombatantReroll') { // Replace !
if (option.name == 'COMBAT.CombatantReroll') { // Replace !
option.name = "Sélectionner l'initiative...";
option.condition = true;
option.icon = '<i class="far fa-question-circle"></i>';
option.callback = target => {
option.condition = true;
option.icon = '<i class="far fa-question-circle"></i>';
option.callback = target => {
RdDUtility.displayInitiativeMenu(html, target.data('combatant-id'));
}
}
}
options.push( {
options.push({
name: "Incrémenter initiative",
condition: true,
icon: '<i class="fas fa-plus"></i>',
callback: target => {
condition: true,
icon: '<i class="fas fa-plus"></i>',
callback: target => {
RdDUtility.incDecInit(target.data('combatant-id'), +0.01);
}
} );
options.push( {
});
options.push({
name: "Décrémenter initiative",
condition: true,
icon: '<i class="fas fa-minus"></i>',
callback: target => {
condition: true,
icon: '<i class="fas fa-minus"></i>',
callback: target => {
RdDUtility.incDecInit(target.data('combatant-id'), -0.01);
}
} );
});
}
/* -------------------------------------------- */
@ -938,96 +938,96 @@ export class RdDUtility {
chatData["whisper"] = ChatMessage.getWhisperRecipients(forceWhisper);
}
return chatData;
return chatData;
}
/* -------------------------------------------- */
static confirmerSuppressionSubacteur(actorSheet, li ) {
let actorId = li.data("actor-id");
let actor = game.actors.get( actorId );
let msgTxt = "<p>Etes vous certain de vouloir supprimer le lien vers ce véhicule/monture/suivant : " + actor.data.name +" ?</p>";
let buttons = {
/* -------------------------------------------- */
static confirmerSuppressionSubacteur(actorSheet, li) {
let actorId = li.data("actor-id");
let actor = game.actors.get(actorId);
let msgTxt = "<p>Etes vous certain de vouloir supprimer le lien vers ce véhicule/monture/suivant : " + actor.data.name + " ?</p>";
let d = new Dialog({
title: "Confirmer la suppression du lien",
content: msgTxt,
buttons: {
delete: {
icon: '<i class="fas fa-check"></i>',
label: "Supprimer le lien",
callback: () => {
console.log("Delete : ", actorId);
actorSheet.actor.removeSubacteur( actorId );
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '<i class="fas fa-times"></i>',
label: "Annuler"
}
}
let d = new Dialog({
title: "Confirmer la suppression du lien",
content: msgTxt,
buttons: buttons,
default: "cancel"
});
d.render(true);
}
icon: '<i class="fas fa-check"></i>',
label: "Supprimer le lien",
callback: () => {
console.log("Delete : ", actorId);
actorSheet.actor.removeSubacteur(actorId);
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '<i class="fas fa-times"></i>',
label: "Annuler"
}
},
default: "cancel"
});
d.render(true);
}
/* -------------------------------------------- */
static async confirmerSuppression(actorSheet, li) {
let itemId = li.data("item-id");
let objet = actorSheet.actor.items.find( item => item._id == itemId );
let msgTxt = "<p>Etes vous certain de vouloir supprimer cet objet ?";
let buttons = { delete: {
icon: '<i class="fas fa-check"></i>',
label: "Supprimer l'objet",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteOwnedItem( itemId );
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '<i class="fas fa-times"></i>',
label: "Annuler"
}
}
if ( objet.data.type == 'conteneur' && objet.data.data.contenu.length > 0) {
msgTxt += "<br>Cet objet est aussi un conteneur avec du contenu : choisissez l'option de suppression";
buttons['deleteall'] = {
icon: '<i class="fas fa-check"></i>',
label: "Supprimer le conteneur et tout son contenu",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteAllConteneur( itemId );
li.slideUp(200, () => actorSheet.render(false));
}
}
let itemId = li.data("item-id");
let objet = actorSheet.actor.items.find(item => item._id == itemId);
let msgTxt = "<p>Etes vous certain de vouloir supprimer cet objet ?";
let buttons = {
delete: {
icon: '<i class="fas fa-check"></i>',
label: "Supprimer l'objet",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteOwnedItem(itemId);
li.slideUp(200, () => actorSheet.render(false));
}
},
cancel: {
icon: '<i class="fas fa-times"></i>',
label: "Annuler"
}
msgTxt += "</p>";
let d = new Dialog({
title: "Confirmer la suppression",
content: msgTxt,
buttons: buttons,
default: "cancel"
});
d.render(true);
}
if (objet.data.type == 'conteneur' && objet.data.data.contenu.length > 0) {
msgTxt += "<br>Cet objet est aussi un conteneur avec du contenu : choisissez l'option de suppression";
buttons['deleteall'] = {
icon: '<i class="fas fa-check"></i>',
label: "Supprimer le conteneur et tout son contenu",
callback: () => {
console.log("Delete : ", itemId);
actorSheet.actor.deleteAllConteneur(itemId);
li.slideUp(200, () => actorSheet.render(false));
}
}
}
msgTxt += "</p>";
let d = new Dialog({
title: "Confirmer la suppression",
content: msgTxt,
buttons: buttons,
default: "cancel"
});
d.render(true);
}
/* -------------------------------------------- */
static afficherHeuresChanceMalchance( heureNaissance ) {
static afficherHeuresChanceMalchance(heureNaissance) {
if (heureNaissance) {
let ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance);
ChatMessage.create( {
content: `A l'heure ${game.system.rdd.calendrier.getCurrentHeure()}, le modificateur de Chance/Malchance pour l'heure de naissance ${heureNaissance} est de : ${ajustement}.`,
ChatMessage.create({
content: `A l'heure ${game.system.rdd.calendrier.getCurrentHeure()}, le modificateur de Chance/Malchance pour l'heure de naissance ${heureNaissance} est de : ${ajustement}.`,
whisper: ChatMessage.getWhisperRecipients("MJ")
} );
});
}
else{
else {
ui.notifications.warn("Pas d'heure de naissance selectionnée")
}
}
/*-------------------------------------------- */
static checkThanatosXP(compName) {
if ( compName.includes('Thanatos') ) {
if (compName.includes('Thanatos')) {
let message = "Vous avez mis des points d'Expérience dans la Voie de Thanatos !<br>Vous devez réduire manuellement d'un même montant d'XP une autre compétence Draconique.";
ChatMessage.create({
whisper: ChatMessage.getWhisperRecipients(game.user.name),
@ -1037,7 +1037,7 @@ export class RdDUtility {
}
/*-------------------------------------------- */
static async onRenderChatMessage( app, html, msg ) {
static async onRenderChatMessage(app, html, msg) {
// TODO
//console.log(app, html, msg);
}

22
module/tmr-rencontres.js
View File

@ -272,11 +272,12 @@ const rencontresStandard = [
{ code: "rdd", name: "Rêve de Dragon", type: "rdd", genre: "m", force: "1ddr + 7", refoulement: 2, quitterTMR: true }
];
const presentsCite = [
const rencontresPresentCite = [
{ code: "messager2d6", name: "Messager des Rêves", type: "messager", genre: "m", force: "2d6", ignorer: true },
{ code: "passeur2d6", name: "Passeur des Rêves", type: "passeur", genre: "m", force: "2d6", ignorer: true },
{ code: "fleur2d6", name: "Fleur des Rêves", type: "fleur", genre: "f", force: "2d6", ignorer: true }
]
const rencontresAll = [].concat(rencontresStandard).concat(mauvaisesRencontres).concat(rencontresPresentCite);
const tableRencontres = {
cite: [{ code: 'messager', range: [1, 25] }, { code: 'passeur', range: [26, 50] }, { code: 'fleur', range: [51, 65] }, { code: 'mangeur', range: [66, 70] }, { code: 'changeur', range: [71, 80] }, { code: 'briseur', range: [81, 85] }, { code: 'reflet', range: [86, 90] }, { code: 'tbblanc', range: [91, 94] }, { code: 'tbnoir', range: [95, 97] }, { code: 'rdd', range: [98, 100] }],
@ -339,22 +340,17 @@ export class TMRRencontres {
static getRencontre(index) {
let rencontre;
if (isNaN(index)) {
rencontre = rencontresStandard.find(r => r.type == index)
if (!rencontre) {
rencontre = mauvaisesRencontres.find(r => r.type == index)
}
rencontre = rencontresAll.find(r => r.type == index) ?? rencontresAll.find(r => r.code == index)
}
else {
if (0 <= index && index < rencontresStandard.length) {
rencontre = rencontresStandard[index];
}
else if (rencontresStandard.length <= index && index < rencontresStandard.length + mauvaisesRencontres.length) {
rencontre = mauvaisesRencontres[index - rencontresStandard.length];
}
else if (0 <= index && index < rencontresAll.length) {
rencontre = rencontresAll[index];
}
if (rencontre) {
return duplicate(rencontre);
}
else {
ui.notifications.info(`Pas de rencontre pour ${index}, seulement ${rencontresAll.length} rencontres sont connues.<br>Vous pouvez aussi essayer par type (ie: mangeur, fleur, fleur2d6, ...)`)
}
return undefined;
}
@ -375,7 +371,7 @@ export class TMRRencontres {
/* -------------------------------------------- */
static async getMauvaiseRencontre(index = undefined) {
const rencontre = duplicate(
(index && index>=0 && index < mauvaisesRencontres.length)
(index && index >= 0 && index < mauvaisesRencontres.length)
? mauvaisesRencontres[index]
: Misc.rollOneOf(mauvaisesRencontres));
await TMRRencontres.evaluerForceRencontre(rencontre);

12
module/tmr-utility.js
View File

@ -274,7 +274,15 @@ export const tmrColors = {
rencontre: 0xFF0000,
casehumide: 0x1050F0,
}
export const tmrTokenZIndex = {
sort: 40,
tetes: 20,
casehumide: 10,
conquete: 30,
rencontre: 50,
trounoir: 60,
demireve: 70,
}
/* -------------------------------------------- */
@ -339,7 +347,7 @@ export class TMRUtility {
this.prochaineRencontre.force = force;
}
else {
await TMRRencontres.evaluerForceRencontre(this.prochaineRencontre)
await TMRRencontres.evaluerForceRencontre(this.prochaineRencontre);
}
console.log("La prochaine rencontre sera:", this.prochaineRencontre.name, " force:", this.prochaineRencontre.force);
}

2
module/tmr/carte-tmr.js
View File

@ -14,7 +14,7 @@ export class CarteTmr extends Draconique {
code() { return 'tmr' }
img() { return 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmp_main_r1.webp' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.carteTmr(this.code());
}
}

18
module/tmr/conquete.js
View File

@ -1,5 +1,6 @@
import { Grammar } from "../grammar.js";
import { Misc } from "../misc.js";
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class Conquete extends Draconique {
@ -9,7 +10,7 @@ export class Conquete extends Draconique {
}
type() { return 'queue' }
match(item) { return Draconique.isQueueDragon(item) && item.name.toLowerCase() == 'conquête'; }
match(item) { return Draconique.isQueueDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('conquete'); }
manualMessage() { return false }
async onActorCreateOwned(actor, item) { await this._creerConquete(actor, item); }
@ -17,10 +18,13 @@ export class Conquete extends Draconique {
tooltip(linkData) { return `La ${this.tmrLabel(linkData)} doit être conquise` }
img() { return 'icons/svg/combat.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.queues, taille: tmrConstants.full, decallage: { x: 2, y: 0 }
zIndex: tmrTokenZIndex.conquete,
color: tmrColors.queues,
taille: tmrConstants.full,
decallage: { x: 2, y: 0 }
});
}
@ -31,11 +35,11 @@ export class Conquete extends Draconique {
await this.createCaseTmr(actor, 'Conquête: ' + conquete.label, conquete, queue._id);
}
async onConquete(actor, coord) {
let existants = actor.data.items.filter(it => this.isCase(it, coord));
async onConquete(actor, tmr, onRemoveToken) {
let existants = actor.data.items.filter(it => this.isCase(it, tmr.coord));
for (let casetmr of existants) {
await actor.deleteOwnedItem(casetmr._id);
await actor.deleteOwnedItem(casetmr.data.sourceid);
onRemoveToken(tmr, casetmr);
}
}
}

30
module/tmr/debordement.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class Debordement extends Draconique {
@ -8,24 +9,25 @@ export class Debordement extends Draconique {
}
type() { return 'souffle' }
match(item) { return Draconique.isSouffleDragon(item) && item.name.toLowerCase().includes('trou noir'); }
match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('debordement'); }
manualMessage() { return false }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorCreateOwned(actor, souffle) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
await this.createCaseTmr(actor, 'Debordement: ' + tmr.label, tmr, souffle._id);
}
code() { return 'debordement' }
tooltip(linkData) { return `Débordement en ${this.tmrLabel(linkData)}` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/svg/wave.svg' }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/wave.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.casehumide, alpha: 0.5, taille: tmrConstants.twoThird, decallage: tmrConstants.bottom
});
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
color: tmrColors.casehumide,
zIndex: tmrTokenZIndex.casehumide,
taille: tmrConstants.twoThird,
decallage: tmrConstants.bottom
});
}
async _creerCaseTmr(actor) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
await this.createCaseTmr(actor, 'Debordement: ' + tmr.label, tmr);
}
}

7
module/tmr/demi-reve.js
View File

@ -1,4 +1,4 @@
import { tmrColors, tmrConstants } from "../tmr-utility.js";
import { tmrColors, tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class DemiReve extends Draconique {
@ -13,12 +13,13 @@ export class DemiReve extends Draconique {
async onActorCreateOwned(actor, item) { }
code() { return 'demi-reve' }
tooltip(linkData) { return `Demi-rêve` }
tooltip(actor) { return `Demi-rêve ${actor.name}` }
img() { return 'icons/svg/sun.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
const sprite = pixiTMR.sprite(this.code(), {
color: tmrColors.demireve,
zIndex: tmrTokenZIndex.demireve,
taille: (tmrConstants.full * 0.7)
});
pixiTMR.animate(pixiApp => pixiApp.ticker.add((delta) => sprite.rotation -= 0.01 * delta));

15
module/tmr/desorientation.js
View File

@ -1,7 +1,6 @@
import { Grammar } from "../grammar.js";
import { Misc } from "../misc.js";
import { RollDataAjustements } from "../rolldata-ajustements.js";
import { tmrColors, tmrConstants, TMRType, TMRUtility } from "../tmr-utility.js";
import { Debordement } from "./debordement.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRType, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class Desorientation extends Draconique {
@ -10,7 +9,7 @@ export class Desorientation extends Draconique {
}
type() { return 'souffle' }
match(item) { return Draconique.isSouffleDragon(item) && item.name.toLowerCase().includes('désorientation'); }
match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('desorientation'); }
manualMessage() { return false }
async onActorCreateOwned(actor, souffle) {
@ -33,10 +32,14 @@ export class Desorientation extends Draconique {
tooltip(linkData) { return `Désorientation, cette case n'existe plus !` }
img() { return 'icons/svg/explosion.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.trounoir, alpha: 1, taille: tmrConstants.full, decallage: { x: 2, y: 2 },
zIndex: tmrTokenZIndex.trounoir,
color: tmrColors.trounoir,
alpha: 1,
taille: tmrConstants.full,
decallage: { x: 2, y: 2 },
});
}

10
module/tmr/draconique.js
View File

@ -54,7 +54,12 @@ export class Draconique
async onActorCreateOwned(actor, item) {
return false;
}
async onActorDeleteOwned(actor, item) {
let caseTmrs = actor.data.items.filter(it => this.isCase(it) && it.data.sourceid == item._id);
for (let casetmr of caseTmrs) {
await actor.deleteOwnedItem(casetmr._id);
}
return false;
}
/**
@ -80,7 +85,7 @@ export class Draconique
*/
token(pixiTMR, linkData, coordTMR, type = undefined) {
const token = {
sprite: this._createSprite(pixiTMR),
sprite: this.createSprite(pixiTMR),
coordTMR: coordTMR
};
token[type ?? this.code()] = linkData;
@ -93,7 +98,7 @@ export class Draconique
* factory d'élément graphique PIXI correpsondant à l'objet draconique
* @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
*/
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
if (this.img()) {
return pixiTMR.sprite(this.code());
}
@ -115,7 +120,6 @@ export class Draconique
return list.find(c => this.isCase(c, coord));
}
async createCaseTmr(actor, label, tmr, sourceId=undefined) {
await actor.createOwnedItem({
name: label, type: 'casetmr', img: this.img(), _id: randomID(16),

15
module/tmr/effets-draconiques.js
View File

@ -13,7 +13,7 @@ import { Draconique } from "./draconique.js";
import { PresentCites } from "./present-cites.js";
import { Desorientation } from "./desorientation.js";
import { Conquete } from "./conquete.js";
import { Pelerinage } from "./pelerinage.js";
export class EffetsDraconiques {
@ -31,6 +31,7 @@ export class EffetsDraconiques {
static pontImpraticable = new PontImpraticable();
static desorientation = new Desorientation();
static conquete = new Conquete();
static pelerinage = new Pelerinage();
static init() {
Draconique.register(EffetsDraconiques.carteTmr);
@ -47,6 +48,7 @@ export class EffetsDraconiques {
Draconique.register(EffetsDraconiques.presentCites);
Draconique.register(EffetsDraconiques.desorientation);
Draconique.register(EffetsDraconiques.conquete);
Draconique.register(EffetsDraconiques.pelerinage);
}
/* -------------------------------------------- */
@ -59,10 +61,15 @@ export class EffetsDraconiques {
return EffetsDraconiques.trouNoir.isCase(caseTMR, coord) ||
EffetsDraconiques.desorientation.isCase(caseTMR, coord);
}
static isCaseTrouNoir(caseTMR, coord) {
return EffetsDraconiques.trouNoir.isCase(caseTMR, coord);
}
static isCasePelerinage(caseTMR, coord) {
return EffetsDraconiques.pelerinage.isCase(caseTMR, coord);
}
static isReserveExtensible(caseTMR, coord) {
return EffetsDraconiques.reserveExtensible.isCase(caseTMR, coord);
}
@ -114,12 +121,16 @@ export class EffetsDraconiques {
}
/* -------------------------------------------- */
static isSortImpossible(element) {
return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.conquete.match(it) || EffetsDraconiques.pelerinage.match(it));
}
static isConquete(element) {
return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.conquete.match(it));
}
static isPelerinage(element) {
return EffetsDraconiques.isMatching(element, it => Draconique.isQueueDragon(it) && it.name.toLowerCase() == 'pélerinage');
return EffetsDraconiques.isMatching(element, it => EffetsDraconiques.pelerinage.match(it));
}
static countInertieDraconique(element) {

26
module/tmr/fermeture-cites.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class FermetureCites extends Draconique {
@ -8,32 +9,37 @@ export class FermetureCites extends Draconique {
}
type() { return 'souffle' }
match(item) { return Draconique.isSouffleDragon(item) && item.name.toLowerCase() == 'fermeture des cités'; }
match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('fermeture des cites'); }
manualMessage() { return false }
async onActorCreateOwned(actor, item) { await this._fermerLesCites(actor); }
async onActorCreateOwned(actor, souffle) { await this._fermerLesCites(actor, souffle); }
code() { return 'fermeture' }
tooltip(linkData) { return `La ${this.tmrLabel(linkData)} est fermée` }
img() { return 'icons/svg/door-closed.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.souffle, alpha: 0.9, taille: tmrConstants.full, decallage: { x: 2, y: 0 }
zIndex: tmrTokenZIndex.conquete,
color: tmrColors.souffle,
alpha: 0.9,
taille: tmrConstants.full,
decallage: { x: 2, y: 0 }
});
}
async _fermerLesCites(actor) {
async _fermerLesCites(actor, souffle) {
let existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
let ouvertes = TMRUtility.filterTMR(it => it.type == 'cite' && !existants.includes(it.coord));
for (let tmr of ouvertes) {
await this.createCaseTmr(actor, 'Fermeture: ' + tmr.label, tmr);
await this.createCaseTmr(actor, 'Fermeture: ' + tmr.label, tmr, souffle._id);
}
}
async onConquete(actor, coord) {
const citeFermee = actor.data.items.find(it => this.isCase(it, coord));
await this.actor.deleteOwnedItem(citeFermee._id);
async onConquete(actor, tmr, onRemoveToken) {
const citeFermee = actor.data.items.find(it => this.isCase(it, tmr.coord));
await actor.deleteOwnedItem(citeFermee._id);
onRemoveToken(tmr, citeFermee);
}
}

42
module/tmr/pelerinage.js Normal file
View File

@ -0,0 +1,42 @@
import { Grammar } from "../grammar.js";
import { tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class Pelerinage extends Draconique {
constructor() {
super();
}
type() { return 'queue' }
match(item) { return Draconique.isQueueDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('pelerinage'); }
manualMessage() { return false }
async onActorCreateOwned(actor, queue) {
let tmr = TMRUtility.getTMRAleatoire();
await this.createCaseTmr(actor, 'Pèlerinage: ' + tmr.label, tmr, queue._id);
}
code() { return 'pelerinage' }
tooltip(linkData) { return `Votre pèlerinage en ${this.tmrLabel(linkData)}` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/pelerin.svg' }
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.conquete,
alpha: 1,
taille: tmrConstants.twoThird,
decallage: tmrConstants.right
});
}
async onFinPelerinage(actor, tmr, onRemoveToken) {
const pelerinages = actor.data.items.filter(it => this.isCase(it, tmr.coord));
for (let p of pelerinages){
await actor.deleteOwnedItem(p.data.sourceid);
onRemoveToken(tmr, p);
}
}
}

8
module/tmr/pixi-tmr.js
View File

@ -1,4 +1,4 @@
import { tmrConstants } from "../tmr-utility.js";
import { tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
const tooltipStyle = new PIXI.TextStyle({
fontFamily: 'CaslonAntique',
@ -16,6 +16,7 @@ export class PixiTMR {
constructor(tmrObject, pixiApp) {
this.tmrObject = tmrObject;
this.pixiApp = pixiApp ?? tmrObject.pixiApp;
this.pixiApp.stage.sortableChildren = true;
this.callbacksOnAnimate = [];
}
@ -76,7 +77,10 @@ export class PixiTMR {
sprite.width = options.taille ?? tmrConstants.half;
sprite.height = options.taille ?? tmrConstants.half;
sprite.anchor.set(0.5);
sprite.tint = options.color ?? 0x000000;
if (options.color) {
sprite.tint = options.color;
}
sprite.zIndex = options.zIndex ?? tmrTokenZIndex.casehumide+1;
sprite.alpha = options.alpha ?? 0.75;
sprite.decallage = options.decallage ?? tmrConstants.center;
this.pixiApp.stage.addChild(sprite);

33
module/tmr/pont-impraticable.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class PontImpraticable extends Draconique {
@ -8,33 +9,31 @@ export class PontImpraticable extends Draconique {
}
type() { return 'souffle' }
match(item) { return Draconique.isSouffleDragon(item) && item.name.toLowerCase().includes('impraticabilité des ponts'); }
match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('impraticabilite des ponts'); }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorDeleteOwned(actor, item) { await this._supprimerCaseTmr(actor); }
async onActorCreateOwned(actor, souffle) {
const ponts = TMRUtility.getListTMR('pont');
for (let tmr of ponts) {
await this.createCaseTmr(actor, 'Pont impraticable: ' + tmr.label, tmr, souffle._id);
}
}
code() { return 'pont-impraticable' }
tooltip(linkData) { return `${this.tmrLabel(linkData)} impraticable` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/svg/wave.svg' }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/wave.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.casehumide, alpha: 0.5, taille: tmrConstants.twoThird, decallage: tmrConstants.bottom
zIndex: tmrTokenZIndex.casehumide,
color: tmrColors.casehumide,
alpha: 0.5,
taille: tmrConstants.twoThird,
decallage: tmrConstants.bottom
});
}
async _creerCaseTmr(actor) {
const ponts = TMRUtility.getListTMR('pont');
for (let tmr of ponts) {
await this.createCaseTmr(actor, 'Pont impraticable: ' + tmr.label, tmr);
}
}
async _supprimerCaseTmr(actor) {
const existants = actor.data.items.filter(it => this.isCase(it));
for (let caseTMR of existants) {
await actor.deleteOwnedItem(caseTMR._id);
}
}
}

40
module/tmr/present-cites.js
View File

@ -1,5 +1,6 @@
import { ChatUtility } from "../chat-utility.js";
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class PresentCites extends Draconique {
@ -9,22 +10,26 @@ export class PresentCites extends Draconique {
}
type() { return 'tete' }
match(item) { return Draconique.isTeteDragon(item) && item.name.toLowerCase() == 'présent des cités'; }
match(item) { return Draconique.isTeteDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('present des cites'); }
manualMessage() { return false }
async onActorCreateOwned(actor, item) { await this._ajouterPresents(actor); }
async onActorCreateOwned(actor, tete) { await this._ajouterPresents(actor, tete); }
code() { return 'present-cites' }
tooltip(linkData) { return `La ${this.tmrLabel(linkData)} a un présent` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/svg/gift.svg' }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/gift.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.tetes, alpha: 0.7, taille: tmrConstants.third, decallage: tmrConstants.topRight
zIndex: tmrTokenZIndex.tetes,
color: 0xFEFEFE,
alpha: 0.8,
taille: tmrConstants.third,
decallage: tmrConstants.topRight
});
}
async _ajouterPresents(actor) {
async _ajouterPresents(actor, tete) {
let existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
if (existants.length > 0) {
ChatMessage.create({
@ -35,23 +40,26 @@ export class PresentCites extends Draconique {
else {
let cites = TMRUtility.filterTMR(it => it.type == 'cite');
for (let tmr of cites) {
await this.createCaseTmr(actor, 'Présent: ' + tmr.label, tmr);
await this.createCaseTmr(actor, 'Présent: ' + tmr.label, tmr, tete._id);
}
}
}
async choisirUnPresent(casetmr) {
async choisirUnPresent(casetmr, onChoixPresent) {
let d = new Dialog({
title: "Présent des cités",
content: `La ${casetmr.data.coord} vous offre un présent`,
content: `La ${this.tmrLabel(casetmr)} vous offre un présent, faite votre choix`,
buttons: {
fleur: {
icon: '<i class="fas fa-check"></i>',
label: "Fleur des rêves 2d6",
callback: () => this.creerObjet()
}
}
messager: { icon: '<i class="fas fa-check"></i>', label: "Un Messager des rêves", callback: () => onChoixPresent('messager2d6') },
passeur: { icon: '<i class="fas fa-check"></i>', label: "Un Passeur des rêves", callback: () => onChoixPresent('passeur2d6') },
fleur: { icon: '<i class="fas fa-check"></i>', label: "Une Fleur des rêves", callback: () => onChoixPresent('fleur2d6') },
},
default: "fleur"
});
d.render(true);
}
async ouvrirLePresent(actor, casetmr) {
await actor.deleteOwnedItem(casetmr._id);
}
}

21
module/tmr/quete-eaux.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class QueteEaux extends Draconique {
@ -7,19 +8,21 @@ export class QueteEaux extends Draconique {
}
type() { return 'tete' }
match(item) { return Draconique.isTeteDragon(item) && item.name.toLowerCase().includes("quête des eaux"); }
match(item) { return Draconique.isTeteDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes("quete des eaux"); }
manualMessage() { return "Vous devrez re-configurer votre Quête des Eaux une fois un lac ou marais vaincu" }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorCreateOwned(actor, tete) {
await this.createCaseTmr(actor, "Quête des eaux à déterminer", { coord: 'A0' }, tete._id);
}
code() { return 'maitrisee' }
tooltip(linkData) { return `Quête des eaux, le ${this.tmrLabel(linkData)} est maîtrisé` }
img() { return 'icons/svg/bridge.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), { color: tmrColors.tetes, decallage: tmrConstants.topRight });
}
async _creerCaseTmr(actor) {
await this.createCaseTmr(actor, "Quête des eaux à déterminer", {coord:'A0'});
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.casehumide + 1,
color: tmrColors.tetes,
decallage: tmrConstants.topRight
});
}
}

11
module/tmr/rencontre.js
View File

@ -1,4 +1,4 @@
import { tmrColors, tmrConstants } from "../tmr-utility.js";
import { tmrColors, tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class Rencontre extends Draconique {
@ -16,7 +16,12 @@ export class Rencontre extends Draconique {
tooltip(linkData) { return `${linkData.name} de force ${linkData.force}` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/heures/hd06.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), { color: tmrColors.rencontre, taille: tmrConstants.full, decallage: { x: 2, y: 2 } });
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.rencontre,
color: tmrColors.rencontre,
taille: tmrConstants.full,
decallage: { x: 2, y: 2 }
});
}
}

27
module/tmr/reserve-extensible.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class ReserveExtensible extends Draconique {
@ -7,22 +8,24 @@ export class ReserveExtensible extends Draconique {
}
type() { return 'tete' }
match(item) { return Draconique.isTeteDragon(item) && item.name.toLowerCase().includes("réserve extensible"); }
match(item) { return Draconique.isTeteDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes("reserve extensible"); }
manualMessage() { return "Vous pouvez re-configurer votre Réserve extensible" }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorCreateOwned(actor, tete) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(it.type == 'fleuve' || existants.includes(it.coord)));
await this.createCaseTmr(actor, "Nouvelle Réserve extensible", tmr, tete._id);
}
code() { return 'reserve_extensible' }
tooltip(linkData) { return `Réserve extensible en ${this.tmrLabel(linkData)} !` }
img() { return 'icons/svg/chest.svg' }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/treasure-chest.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), { color: tmrColors.tetes, decallage: tmrConstants.left});
}
async _creerCaseTmr(actor) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(it.type == 'fleuve' || existants.includes(it.coord)));
await this.createCaseTmr(actor, "Nouvelle Réserve extensible", tmr);
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.tetes,
alpha: 0.9,
decallage: tmrConstants.left
});
}
}

14
module/tmr/sort-reserve.js
View File

@ -1,4 +1,4 @@
import { tmrColors, tmrConstants } from "../tmr-utility.js";
import { tmrColors, tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class SortReserve extends Draconique {
@ -13,10 +13,14 @@ export class SortReserve extends Draconique {
async onActorCreateOwned(actor, item) { }
code() { return 'sort' }
tooltip(linkData) { return `${linkData.name}, r${linkData.data.ptreve_reel}` }
img() { return 'icons/svg/book.svg' }
tooltip(sort) { return `${sort.name}, r${sort.data.ptreve_reel}` }
img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/scroll.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), { color: tmrColors.sort, decallage: tmrConstants.right });
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.sort,
alpha: 0.5,
decallage: tmrConstants.right
});
}
}

21
module/tmr/terre-attache.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class TerreAttache extends Draconique {
@ -7,19 +8,23 @@ export class TerreAttache extends Draconique {
}
type() { return 'tete' }
match(item) { return Draconique.isTeteDragon(item) && item.name.toLowerCase().includes("terre d'attache"); }
match(item) { return Draconique.isTeteDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes("terre d'attache"); }
manualMessage() { return "Vous pouvez re-configurer votre Terre d'Attache" }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorCreateOwned(actor, tete) {
await this.createCaseTmr(actor, "Terre d'attache à déterminer", { coord: 'A0' }, tete._id);
}
code() { return 'attache' }
tooltip(linkData) { return `Terre d'attache en ${this.tmrLabel(linkData)} !` }
img() { return 'icons/svg/anchor.svg' }
_createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), { color: tmrColors.tetes, decallage: tmrConstants.topLeft });
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(), {
zIndex: tmrTokenZIndex.tetes,
color: tmrColors.tetes,
decallage: tmrConstants.topLeft
});
}
async _creerCaseTmr(actor) {
await this.createCaseTmr(actor, "Terre d'attache à déterminer", {coord:'A0'});
}
}

25
module/tmr/trou-noir.js
View File

@ -1,4 +1,5 @@
import { tmrColors, tmrConstants, TMRUtility } from "../tmr-utility.js";
import { Grammar } from "../grammar.js";
import { tmrColors, tmrConstants, tmrTokenZIndex, TMRUtility } from "../tmr-utility.js";
import { Draconique } from "./draconique.js";
export class TrouNoir extends Draconique {
@ -7,24 +8,28 @@ export class TrouNoir extends Draconique {
}
type() { return 'souffle' }
match(item) { return Draconique.isSouffleDragon(item) && item.name.toLowerCase().includes('trou noir'); }
match(item) { return Draconique.isSouffleDragon(item) && Grammar.toLowerCaseNoAccent(item.name).includes('trou noir'); }
manualMessage() { return false }
async onActorCreateOwned(actor, item) { await this._creerCaseTmr(actor); }
async onActorCreateOwned(actor, souffle) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
await this.createCaseTmr(actor, 'Trou noir: ' + tmr.label, tmr, souffle._id);
}
code() { return 'trounoir' }
tooltip(linkData) { return `Trou noir en ${this.tmrLabel(linkData)} !` }
img() { return 'icons/svg/explosion.svg' }
_createSprite(pixiTMR) {
createSprite(pixiTMR) {
return pixiTMR.sprite(this.code(),
{
color: tmrColors.trounoir, alpha: 1, taille: tmrConstants.full, decallage: { x: 2, y: 2 },
zIndex: tmrTokenZIndex.trounoir,
color: tmrColors.trounoir,
alpha: 1, taille:
tmrConstants.full,
decallage: { x: 2, y: 2 },
});
}
async _creerCaseTmr(actor) {
const existants = actor.data.items.filter(it => this.isCase(it)).map(it => it.data.coord);
const tmr = TMRUtility.getTMRAleatoire(it => !(TMRUtility.isCaseHumide(it) || existants.includes(it.coord)));
await this.createCaseTmr(actor, 'Trou noir: ' + tmr.label, tmr);
}
}