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

Simplify ChatMessage whispers

Browse Source 
Les messages dans les TMRs sont envoyés au GM

Simplification des messages de tchat liés à un actor: on peut
utiliser les Owners (car les GMs sont owner).

Au lieu de passer le name de l'Actor (qui peut être incorrect si deux
actors ont le même, mais pas les mêmes propriétaires), on passe
directement l'actor pour déterminer mles destinataires de messages
This commit is contained in:
Vincent Vandemeulebrouck 2024-10-16 23:18:15 +02:00
parent 501f1f2e4f
commit 582df7e290
25 changed files with 256 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
changelog.md
View File

@ -1,6 +1,8 @@
# 12.0
## 12.0.15 - Le messager d'Astrobazzarh
- Les messages de maladies ne sont plus publics
- Les messages privés dans les TMR sont aussi envoyés au GM
## 12.0.14 - Les légions d'Astrobazzarh
- Feuille de PNJ:
- boutons standard (encaissement, ...)

50
module/actor.js
View File

@ -159,7 +159,7 @@ export class RdDActor extends RdDBaseActorSang {
const potionUpdates = await Promise.all(potions.map(async it => {
const nouveauReve = Math.max(it.system.pr - 1, 0)
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
pr: nouveauReve,
alias: this.name,
@ -210,7 +210,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
async grisReve(nbJours) {
let message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: `${nbJours} jours de gris rêve sont passés. `
};
for (let i = 0; i < nbJours; i++) {
@ -264,7 +264,7 @@ export class RdDActor extends RdDBaseActorSang {
async dormirChateauDormant() {
if (!ReglesOptionnelles.isUsing("chateau-dormant-gardien") || !this.system.sommeil || this.system.sommeil.nouveaujour) {
const message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: ""
};
@ -400,7 +400,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
async remiseANeuf() {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: 'Remise à neuf de ' + this.name
});
await this.supprimerBlessures(it => true);
@ -417,7 +417,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
async dormir(heures, options = { grisReve: false, chateauDormant: false }) {
const message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: this.name + ': '
};
const insomnie = this.system.sommeil?.insomnie || heures == 0;
@ -488,7 +488,7 @@ export class RdDActor extends RdDBaseActorSang {
else {
if (!ReglesOptionnelles.isUsing("recuperation-reve")) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: `Pas de récupération de rêve (${reve} points ignorés)`
});
jetsReve.push(0);
@ -919,7 +919,7 @@ export class RdDActor extends RdDBaseActorSang {
await this.createEmbeddedDocuments('Item', [souffle]);
if (options.chat) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: this.name + " subit un Souffle de Dragon : " + souffle.name
});
}
@ -939,7 +939,7 @@ export class RdDActor extends RdDBaseActorSang {
await this.createEmbeddedDocuments('Item', [queue]);
if (options.chat) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: this.name + " subit une Queue de Dragon : " + queue.name
});
}
@ -977,7 +977,7 @@ export class RdDActor extends RdDBaseActorSang {
let tmr = await TMRUtility.getTMRAleatoire(tmr => accessible(tmr) && !innaccessible.includes(tmr.coord));
ChatMessage.create({
content: `${raison} : ré-insertion aléatoire.`,
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name)
whisper: ChatUtility.getOwners(this)
});
await this.forcerPositionTMRInconnue(tmr);
return tmr;
@ -1082,7 +1082,7 @@ export class RdDActor extends RdDBaseActorSang {
const jetMoral = await this._jetDeMoral(situation);
const finMessage = (jetMoral.succes ? messageReussi : messageManque) ?? (jetMoral.ajustement == 0 ? "Vous gardez votre moral" : jetMoral.ajustement > 0 ? "Vous gagnez du moral" : "Vous perdez du moral");
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: `${finMessage} - jet ${jetMoral.succes ? "réussi" : "manqué"} en situation ${situation} (${jetMoral.jet}/${jetMoral.difficulte}).`
});
return jetMoral.ajustement;
@ -1419,7 +1419,7 @@ export class RdDActor extends RdDBaseActorSang {
};
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-transformer-stress.html`, stressRollData)
});
@ -1505,7 +1505,7 @@ export class RdDActor extends RdDBaseActorSang {
}
if (display) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html`, checkXp)
});
}
@ -1537,7 +1537,7 @@ export class RdDActor extends RdDBaseActorSang {
}
if (display) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html`, checkXp)
});
}
@ -1563,7 +1563,7 @@ export class RdDActor extends RdDBaseActorSang {
}
else {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: content
});
}
@ -1666,7 +1666,7 @@ export class RdDActor extends RdDBaseActorSang {
}
ChatMessage.create({
content: "Vous êtes sous le coup d'une Mauvaise Rencontre en Persective." + addMsg,
whisper: ChatMessage.getWhisperRecipients(this.name)
whisper: ChatUtility.getOwners(this)
});
}
return rencSpecial;
@ -1678,7 +1678,7 @@ export class RdDActor extends RdDBaseActorSang {
if (countInertieDraconique > 0) {
ChatMessage.create({
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(this.name)
whisper: ChatUtility.getOwners(this)
});
}
return countInertieDraconique + 1;
@ -1690,7 +1690,7 @@ export class RdDActor extends RdDBaseActorSang {
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).",
whisper: ChatMessage.getWhisperRecipients(this.name)
whisper: ChatUtility.getOwners(this)
});
}
}
@ -2270,7 +2270,7 @@ export class RdDActor extends RdDBaseActorSang {
// Cas de désir lancinant, pas d'expérience sur particulière
ChatMessage.create({
content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
whisper: ChatMessage.getWhisperRecipients(this.name)
whisper: ChatUtility.getOwners(this)
});
return []
}
@ -2405,7 +2405,7 @@ export class RdDActor extends RdDBaseActorSang {
if (countMonteeLaborieuse > 0) {
ChatMessage.create({
content: `Vous êtes sous le coup d'une Montée Laborieuse : vos montées en TMR coûtent ${countMonteeLaborieuse} Point de Rêve de plus.`,
whisper: ChatMessage.getWhisperRecipients(this.name)
whisper: ChatUtility.getOwners(this)
});
}
return countMonteeLaborieuse;
@ -2453,7 +2453,7 @@ export class RdDActor extends RdDBaseActorSang {
if (this.getReveActuel() < minReveValue) {
ChatMessage.create({
content: `Vous n'avez les ${minReveValue} Points de Reve nécessaires pour monter dans les Terres Médianes`,
whisper: ChatMessage.getWhisperRecipients(this.name)
whisper: ChatUtility.getOwners(this)
});
return;
}
@ -2850,7 +2850,7 @@ export class RdDActor extends RdDBaseActorSang {
await this.setBonusPotionSoin(potionData.system.herbebonus);
}
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-soin.html`, potionData)
});
}
@ -2887,7 +2887,7 @@ export class RdDActor extends RdDBaseActorSang {
this.bonusRepos = potionData.system.herbebonus;
}
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.html`, potionData)
});
}
@ -2919,7 +2919,7 @@ export class RdDActor extends RdDBaseActorSang {
this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins);
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, messageData)
});
}
@ -2944,7 +2944,7 @@ export class RdDActor extends RdDBaseActorSang {
}
}
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-generique.html`, potionData)
});
}
@ -3044,7 +3044,7 @@ export class RdDActor extends RdDBaseActorSang {
/* -------------------------------------------- */
notifyGestionTeteSouffleQueue(item, manualMessage = true) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: `${this.name} a reçu un/une ${item.type}: ${item.name}, qui ${manualMessage ? "n'est pas" : "est"} géré(e) automatiquement. ${manualMessage ? manualMessage : ''}`
});
}

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

@ -296,7 +296,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
/* -------------------------------------------- */
async rollCarac(caracName, jetResistance = undefined) {
if (Grammar.equalsInsensitive(caracName, 'taille')){
if (Grammar.equalsInsensitive(caracName, 'taille')) {
return
}
RdDEmpoignade.checkEmpoignadeEnCours(this)
@ -418,7 +418,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
return;
}
const armure = await this.computeArmure(rollData);
if (ReglesOptionnelles.isUsing('validation-encaissement-gr')){
if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
await this.encaisserDommagesValidationGR(rollData, armure, attacker?.id, show);
}
else {
@ -456,16 +456,19 @@ export class RdDBaseActorReve extends RdDBaseActor {
show: show ?? {}
});
await ChatUtility.createChatWithRollMode(this.name, {
await ChatUtility.createChatWithRollMode(
{
roll: encaissement.roll,
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
});
},
this
)
if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
encaissement = foundry.utils.duplicate(encaissement);
encaissement.isGM = true;
encaissement = foundry.utils.duplicate(encaissement)
encaissement.isGM = true
ChatMessage.create({
whisper: ChatMessage.getWhisperRecipients("GM"),
whisper: ChatUtility.getGMs(),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
});
}

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

@ -39,8 +39,8 @@ export class RdDBaseActorSangSheet extends RdDBaseActorReveSheet {
ChatMessage.create({
content: `Jet d'Endurance : ${result.jetEndurance} / ${endurance}
<br>${this.actor.name} a ${result.sonne ? 'échoué' : 'réussi'} son Jet d'Endurance ${result.sonne ? 'et devient Sonné' : ''}`,
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.actor.name)
});
whisper: ChatUtility.getOwners(this.actor)
})
}
}

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

@ -5,6 +5,7 @@ import { ITEM_TYPES } from "../item.js";
import { RdDBaseActorReve } from "./base-actor-reve.js";
import { RdDDice } from "../rdd-dice.js";
import { RdDItemBlessure } from "../item/blessure.js";
import { ChatUtility } from "../chat-utility.js";
/**
* Classe de base pour les acteurs qui peuvent subir des blessures
@ -180,7 +181,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
}
}
const endActuelle = this.getEnduranceActuelle();
const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg?.loc.label ??'', attacker);
const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg?.loc.label ?? '', attacker);
if (blessure.isCritique()) {
encaissement.endurance = endActuelle;
}
@ -196,9 +197,9 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
return blessure;
}
async supprimerBlessure({gravite}) {
async supprimerBlessure({ gravite }) {
const toDelete = this.itemTypes[ITEM_TYPES.blessure].find(it => it.system.gravite == gravite)?.id
if (toDelete){
if (toDelete) {
await this.deleteEmbeddedDocuments('Item', [toDelete]);
}
}
@ -216,7 +217,10 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
/* -------------------------------------------- */
async jetDeVie() {
if (this.isDead()) {
ChatMessage.create({ content: `Jet de Vie: ${this.name} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`, whisper: ChatMessage.getWhisperRecipients(this.name) });
ChatMessage.create({
content: `Jet de Vie: ${this.name} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`,
whisper: ChatUtility.getOwners(this)
})
return
}
const jetDeVie = await RdDDice.roll("1d20");
@ -243,7 +247,10 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
else if (prochainJet > 0) {
msgText += `<br>Prochain jet de vie dans ${prochainJet} ${isCritique ? 'round' : 'minute'}${prochainJet > 1 ? 's' : ''} ${isCritique ? '(état critique)' : '(état grave)'}`
}
ChatMessage.create({ content: msgText, whisper: ChatMessage.getWhisperRecipients(this.name) });
ChatMessage.create({
content: msgText,
whisper: ChatUtility.getOwners(this)
});
}
/* -------------------------------------------- */

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

@ -270,6 +270,7 @@ export class RdDBaseActor extends Actor {
}
let fortune = this.getFortune();
console.log("payer", game.user.character, depense, fortune);
// TODO: passer en handlebars
let msg = "";
if (fortune >= depense) {
await Monnaie.optimiserFortune(this, fortune - depense);
@ -279,11 +280,10 @@ export class RdDBaseActor extends Actor {
msg = "Vous n'avez pas assez d'argent pour payer cette somme !";
}
let message = {
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
ChatMessage.create({
whisper: ChatUtility.getOwners(this),
content: msg
};
ChatMessage.create(message);
})
}
async depenserSols(sols) {
@ -317,7 +317,7 @@ export class RdDBaseActor extends Actor {
RdDAudio.PlayContextAudio("argent"); // Petit son
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this.name),
content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
});
}
@ -371,7 +371,7 @@ export class RdDBaseActor extends Actor {
ChatMessage.create({
user: achat.userId,
speaker: { alias: (acheteur ?? vendeur).name },
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(this),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-achat-item.html', chatAchatItem)
});

122
module/chat-utility.js
View File

@ -8,15 +8,20 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
*/
export class ChatUtility {
static async init() {
Hooks.on("renderChatMessage", async (app, html, msg) => await ChatUtility.onRenderChatMessage(app, html, msg))
Hooks.on("createChatMessage", async (chatMessage, options, id) => await ChatUtility.onCreateChatMessage(chatMessage, options, id))
}
/* -------------------------------------------- */
static onSocketMessage(sockmsg) {
switch (sockmsg.msg) {
case "msg_delete_chat_message": return ChatUtility.onRemoveMessages(sockmsg.data);
case "msg_user_ui_notifications": return ChatUtility.onNotifyUser(sockmsg.data);
case "msg_gm_chat_message": return ChatUtility.handleGMChatMessage(sockmsg.data)
case "msg_delete_chat_message": return ChatUtility.onRemoveMessages(sockmsg.data)
case "msg_user_ui_notifications": return ChatUtility.onNotifyUser(sockmsg.data)
}
}
/* -------------------------------------------- */
static notifyUser(userId, level = 'info', message) {
const socketData = {
@ -78,77 +83,90 @@ export class ChatUtility {
}
/* -------------------------------------------- */
static async createChatWithRollMode(name, chatOptions) {
let rollMode = game.settings.get("core", "rollMode")
switch (rollMode) {
static async createChatWithRollMode(messageData, actor = undefined) {
switch (game.settings.get("core", "rollMode")) {
case "blindroll": // GM only
if (!game.user.isGM) {
ChatUtility.blindMessageToGM(chatOptions);
chatOptions.whisper = [game.user.id];
chatOptions.content = "Message envoyé en aveugle au Gardien";
ChatUtility.blindMessageToGM(messageData)
messageData.whisper = [game.user];
messageData.content = "Message envoyé en aveugle au Gardien"
}
else {
chatOptions.whisper = ChatUtility.getUsers(user => user.isGM);
messageData.whisper = ChatUtility.getGMs()
}
break;
default:
chatOptions.whisper = ChatUtility.getWhisperRecipients(rollMode, name);
break;
break
case "gmroll":
messageData.whisper = ChatUtility.getOwners(actor)
break
case "selfroll":
messageData.whisper = [game.user]
break
}
chatOptions.alias = chatOptions.alias || name;
return await ChatMessage.create(chatOptions);
messageData.alias = messageData.alias ?? actor?.name ?? game.user.name
return await ChatMessage.create(messageData)
}
static getOwners(document) {
return game.users.filter(it => document.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
}
static getUserAndGMs() {
return [game.user, ...ChatUtility.getGMs()]
}
/* -------------------------------------------- */
static prepareChatMessage(rollMode, name) {
return {
user: game.user.id,
whisper: ChatUtility.getWhisperRecipients(rollMode, name)
}
}
/* -------------------------------------------- */
static getWhisperRecipients(rollMode, name) {
switch (rollMode) {
case "blindroll": return ChatUtility.getUsers(user => user.isGM);
case "gmroll": return ChatUtility.getWhisperRecipientsAndGMs(name);
case "selfroll": return [game.user.id];
}
return undefined;
}
static getOwners(actor) {
return game.users.filter(it => actor.getUserLevel(it) == CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
}
/* -------------------------------------------- */
static getWhisperRecipientsAndGMs(...names) {
let recipients = [...ChatMessage.getWhisperRecipients('GM')]
names.forEach(name => recipients.push(...ChatMessage.getWhisperRecipients(name)))
return recipients
static getMultipleActorsOwners(...actors) {
return Misc.concat(actors.map(it => it == undefined ? [] : ChatUtility.getOwners(it)))
}
/* -------------------------------------------- */
static getUsers(filter) {
return game.users.filter(filter).map(user => user.id);
return game.users.filter(filter)
}
static getGMs() {
return game.users.filter(user => user.isGM)
}
static applyRollMode(chatMessageData = {}, rollMode = game.settings.get("core", "rollMode")) {
switch (rollMode) {
case "blindroll":
chatMessageData.blind = true
chatMessageData.whisper = ChatUtility.getGMs()
break
case "gmroll":
chatMessageData.whisper = ChatUtility.getGMs()
chatMessageData.blind = false
break
case "roll":
chatMessageData.whisper = ChatUtility.getUsers(user => user.active)
chatMessageData.blind = false
break
case "selfroll":
chatMessageData.whisper = [game.user]
chatMessageData.blind = false
break
}
return chatMessageData
}
/* -------------------------------------------- */
static blindMessageToGM(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);
game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_gm_chat_message", data: chatGM });
const chatGM = foundry.utils.duplicate(chatOptions)
chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content
console.log("blindMessageToGM", chatGM)
game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_gm_chat_message", data: chatGM })
}
/* -------------------------------------------- */
static handleGMChatMessage(socketData) {
console.log("blindMessageToGM", socketData);
if (game.user.isGM) { // message privé pour GM only
socketData.user = game.user.id;
ChatMessage.create(socketData);
if (Misc.firstConnectedGM()) {
ChatMessage.create({
user: game.user.id,
whisper: ChatUtility.getGMs(),
content: socketData.content
})
}
}

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

@ -30,7 +30,8 @@ export class RdDCoeur {
}
static extractInfoCoeur(event) {
return ChatUtility.getMessageData(ChatUtility.getChatMessage(event), INFO_COEUR)
const chatMesage = ChatUtility.getChatMessage(event);
return ChatUtility.getMessageData(chatMesage, INFO_COEUR)
}
static getInfoCoeur(sourceActorId, targetActorId) {
@ -98,12 +99,11 @@ export class RdDCoeur {
static async startSubActeurTendreMoment(actorId, subActeurId) {
const infoCoeur = RdDCoeur.getInfoCoeur(actorId, subActeurId)
if (infoCoeur.target?.actor.id) {
if (infoCoeur.target?.actor?.id) {
// TODO: passer par une fenêtre pour saisir sa proposition (lieu, heure, ...)
const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-proposer-tendre-moment.hbs`, infoCoeur)
const chatMessage = await ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.target?.actor.name),
content: chatHtml
whisper: ChatUtility.getOwners(infoCoeur.target.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-proposer-tendre-moment.hbs`, infoCoeur)
})
RdDCoeur.addTagsInfoCoeur(infoCoeur, chatMessage)
}
@ -127,7 +127,7 @@ export class RdDCoeur {
}
const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-accepter-tendre-moment.hbs`, infoCoeur)
const chatMessage = await ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.source?.actor.name, infoCoeur.target?.actor.name),
whisper: ChatUtility.getMultipleActorsOwners(infoCoeur.source?.actor, infoCoeur.target?.actor),
content: chatHtml
})
RdDCoeur.addTagsInfoCoeur(infoCoeur, chatMessage)
@ -142,7 +142,7 @@ export class RdDCoeur {
ChatUtility.removeChatMessageId(infoCoeur.chatMessageId)
const chatHtml = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/coeur/chat-refuser-tendre-moment.hbs`, infoCoeur)
await ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(infoCoeur.source?.actor.name, infoCoeur.target?.actor.name),
whisper: ChatUtility.getMultipleActorsOwners(infoCoeur.source?.actor, infoCoeur.target?.actor),
content: chatHtml
});
}

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

@ -48,7 +48,7 @@ export class DialogCreateSigneDraconique extends Dialog {
async _createSigneForActor(actor, signe) {
actor.createEmbeddedDocuments("Item", [signe]);
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
whisper: ChatUtility.getOwners(actor),
content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html", {
signe: signe,
alias: actor.name

2
module/item/blessure.js
View File

@ -62,7 +62,7 @@ export class RdDItemBlessure extends RdDItem {
content: `Blessure ${definition.label} appliquée à ${actor.name}`+
`<br>Perte d'endurance : ${lostEndurance}`+
`<br>Perte de Vie : ${lostVie}`,
whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name)
whisper: ChatUtility.getOwners(actor)
});
}

36
module/rdd-combat.js
View File

@ -54,10 +54,10 @@ export class RdDCombatManager extends Combat {
/* -------------------------------------------- */
async onPreDeleteCombat() {
if (Misc.isUniqueConnectedGM()) {
await this.finDeRound({ terminer: true });
await this.finDeRound({ terminer: true })
ChatUtility.removeChatMessageContaining(`<div data-combatid="${this.id}" data-combatmessage="actor-turn-summary">`)
game.messages.filter(m => ChatUtility.getMessageData(m, 'attacker-roll') != undefined && ChatUtility.getMessageData(m, 'defender-roll') != undefined)
.forEach(it => it.delete());
.forEach(it => it.delete())
RdDEmpoignade.deleteAllEmpoignades()
}
}
@ -698,7 +698,7 @@ export class RdDCombat {
if (this.defender.isEntite([ENTITE_BLURETTE])) {
ChatMessage.create({
content: `<strong>La cible est une blurette, l'arme à distance sera perdue dans le blurêve`,
whisper: ChatMessage.getWhisperRecipients("GM")
whisper: ChatUtility.getGMs()
})
}
else {
@ -721,7 +721,7 @@ export class RdDCombat {
activite: activite,
total: total
}),
whisper: ChatMessage.getWhisperRecipients("GM")
whisper: ChatUtility.getGMs()
})
}
}
@ -846,7 +846,7 @@ export class RdDCombat {
const choixParticuliere = await ChatMessage.create({
alias: this.attacker.name,
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
whisper: ChatUtility.getOwners(this.attacker),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html', {
alias: this.attacker.name,
attackerId: this.attackerId,
@ -933,7 +933,7 @@ export class RdDCombat {
// message privé: du défenseur à lui même (et aux GMs)
speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
alias: this.attacker.name,
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.defender.name),
whisper: ChatUtility.getOwners(this.defender),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html', paramDemandeDefense),
});
// flag pour garder les jets d'attaque/defense
@ -976,7 +976,7 @@ export class RdDCombat {
/* -------------------------------------------- */
async _onAttaqueEchecTotal(attackerRoll) {
const choixEchecTotal = await ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
whisper: ChatUtility.getOwners(this.attacker),
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.html', {
attackerId: this.attackerId,
attacker: this.attacker,
@ -994,9 +994,9 @@ export class RdDCombat {
const arme = rollData.arme;
const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.system.categorie_parade ?? '');
const action = (rollData.attackerRoll ? (arme ? "la parade" : "l'esquive") : "l'attaque");
ChatUtility.createChatWithRollMode(this.defender.name, {
content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme })
});
ChatUtility.createChatWithRollMode(
{ content: `<strong>Maladresse à ${action}!</strong> ` + await RdDRollTables.getMaladresse({ arme: avecArme }) },
this.defender)
}
/* -------------------------------------------- */
@ -1076,9 +1076,9 @@ export class RdDCombat {
console.log("RdDCombat._onParadeParticuliere >>>", defenderRoll);
if (!defenderRoll.attackerRoll.isPart) {
// TODO: attaquant doit jouer résistance et peut être désarmé p132
ChatUtility.createChatWithRollMode(this.defender.name, {
content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)`
});
ChatUtility.createChatWithRollMode(
{ content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)` },
this.defender)
}
}
@ -1152,9 +1152,9 @@ export class RdDCombat {
/* -------------------------------------------- */
_onEsquiveParticuliere(rollData) {
console.log("RdDCombat._onEsquiveParticuliere >>>", rollData);
ChatUtility.createChatWithRollMode(this.defender.name, {
content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>"
});
ChatUtility.createChatWithRollMode(
{ content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>" },
this.defender);
}
/* -------------------------------------------- */
@ -1322,10 +1322,10 @@ export class RdDCombat {
await ChatMessage.create({
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs`, formData),
alias: actor.name
});
})
await ChatMessage.create({
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs`, formData),
whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
whisper: ChatUtility.getOwners(actor),
alias: actor.name
});
}

19
module/rdd-commands.js
View File

@ -17,6 +17,7 @@ import { RdDUtility } from "./rdd-utility.js";
import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
import { TMRUtility } from "./tmr-utility.js";
import { DialogFatigueVoyage } from "./voyage/dialog-fatigue-voyage.js";
import { ChatUtility } from "./chat-utility.js";
const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
@ -206,26 +207,20 @@ export class RdDCommands {
/* Manage chat commands */
processChatCommand(commandLine, content = '', msg = {}) {
// Setup new message's visibility
let rollMode = game.settings.get("core", "rollMode");
if (["gmroll", "blindroll"].includes(rollMode)) {
msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
}
if (rollMode === "blindroll") {
msg["blind"] = true;
}
msg["type"] = 0;
ChatUtility.applyRollMode(msg)
msg.type = 0;
if (!this.commandsTable) {
this._registerCommands();
this._registerCommands()
}
let command = commandLine[0].toLowerCase();
if (this._isCommandHandled(command)) {
let params = commandLine.slice(1);
this._processCommand(this.commandsTable, command, params, content, msg);
return true;
this._processCommand(this.commandsTable, command, params, content, msg)
return true
}
return false;
return false
}
_isCommandHandled(command) {

22
module/rdd-dice.js
View File

@ -169,7 +169,7 @@ export class RdDDice {
return;
}
let { whisper, blind } = RdDDice._getWhisperBlind(options);
let { whisper, blind } = ChatUtility.applyRollMode({}, options?.rollMode);
if (options.forceDiceResult?.total) {
let terms = await RdDDice._getForcedTerms(options);
if (terms) {
@ -223,24 +223,4 @@ export class RdDDice {
await roll.evaluate();
return roll.total;
}
static _getWhisperBlind(options) {
let whisper = undefined;
let blind = false;
let rollMode = options.rollMode ?? game.settings.get("core", "rollMode");
switch (rollMode) {
case "blindroll": //GM only
blind = true;
case "gmroll": //GM + rolling player
whisper = ChatUtility.getUsers(user => user.isGM);
break;
case "roll": //everybody
whisper = ChatUtility.getUsers(user => user.active);
break;
case "selfroll":
whisper = [game.user.id];
break;
}
return { whisper, blind };
}
}

9
module/rdd-empoignade.js
View File

@ -158,9 +158,12 @@ export class RdDEmpoignade {
empoignade = empoignade ?? (await RdDEmpoignade.createEmpoignade(attacker, defender))
//console.log("W.", empoignade, defender.hasArmeeMeleeEquipee())
if ((isNouvelle || empoignade.system.pointsemp == 0) && defender.hasArmeeMeleeEquipee()) {
ChatUtility.createChatWithRollMode(attacker.name, {
ChatUtility.createChatWithRollMode(
{
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-valider.html`, { attacker: attacker, defender: defender })
})
},
attacker
)
} else {
await this.onAttaqueEmpoignadeValidee(attacker, defender)
}
@ -213,7 +216,7 @@ export class RdDEmpoignade {
competence: attacker.getCompetenceCorpsACorps()
}
const msg = await ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
whisper: ChatUtility.getOwners(attacker),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-empoignade-immobilise.html`, rollData)
})
RdDEmpoignade.$storeRollEmpoignade(msg, rollData);

3
module/rdd-main.js
View File

@ -204,7 +204,8 @@ export class SystemReveDeDragon {
// préparation des différents modules
console.log(`Initializing Reve de Dragon Hooks and handlers`)
CONFIG.Combat.documentClass = RdDCombatManager
RdDUtility.init()
ChatUtility.init()
RdDUtility.initHooks()
RdDDice.init()
RdDCommands.init()
RdDCombatManager.init()

3
module/rdd-meteo.js
View File

@ -1,3 +1,4 @@
import { ChatUtility } from "./chat-utility.js"
const vents = [
{ min: 0, max: 0, valeur: 'Calme' },
@ -117,7 +118,7 @@ export class RdDMeteo {
ChatMessage.create({
content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-meteo.html', meteo),
whisper: ChatMessage.getWhisperRecipients('GM')
whisper: ChatUtility.getGMs()
});
}

3
module/rdd-namegen.js
View File

@ -1,4 +1,5 @@
import { RdDBaseActor } from "./actor/base-actor.js";
import { ChatUtility } from "./chat-utility.js";
import { Misc } from "./misc.js";
import { RdDDice } from "./rdd-dice.js";
@ -15,7 +16,7 @@ export class RdDNameGen {
const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
nom: await RdDNameGen.generate()
});
ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
ChatMessage.create({ content: html, whisper: ChatUtility.getGMs() });
}
static async generate() {

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

@ -91,13 +91,14 @@ export class RdDResolutionTable {
/* -------------------------------------------- */
static async displayRollData(rollData, actor = undefined, template = 'chat-resultat-general.html') {
return await ChatUtility.createChatWithRollMode(RdDResolutionTable.actorChatName(actor), {
content: await RdDResolutionTable.buildRollDataHtml(rollData, template)
});
return await ChatUtility.createChatWithRollMode(
{ content: await RdDResolutionTable.buildRollDataHtml(rollData, template) },
actor
)
}
static actorChatName(actor) {
return actor?.name ?? game.user.name;
return actor ?? game.user.name;
}
/* -------------------------------------------- */
@ -138,14 +139,14 @@ export class RdDResolutionTable {
if (carac == 0) {
return NaN;
}
if (rolled >= carac){
const upper = Math.ceil(rolled/carac);
return 2*upper -10
if (rolled >= carac) {
const upper = Math.ceil(rolled / carac);
return 2 * upper - 10
}
if (rolled > Math.floor(carac/2)) {
if (rolled > Math.floor(carac / 2)) {
return -8
}
if (rolled > Math.floor(carac/4)) {
if (rolled > Math.floor(carac / 4)) {
return -9
}
if (rolled > 1) {
@ -265,7 +266,7 @@ export class RdDResolutionTable {
}
/* -------------------------------------------- */
static subTable(carac, level, delta = { carac: 2, level: 5}) {
static subTable(carac, level, delta = { carac: 2, level: 5 }) {
return {
carac,
level,
@ -287,8 +288,8 @@ export class RdDResolutionTable {
carac: carac,
difficulte: level,
min: minLevel,
rows: Misc.intArray(minCarac, maxCarac+1),
cols: Misc.intArray(minLevel, maxLevel+1)
rows: Misc.intArray(minCarac, maxCarac + 1),
cols: Misc.intArray(minLevel, maxLevel + 1)
});
}

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

@ -50,7 +50,7 @@ export class RdDTMRDialog extends Dialog {
await PixiTMR.init()
let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html', tmrData);
if (tmrData.mode != 'visu' && !game.user.isGM) {
ChatMessage.create({ content: actor.name + " est monté dans les TMR en mode : " + tmrData.mode, whisper: ChatMessage.getWhisperRecipients("GM") });
ChatMessage.create({ content: actor.name + " est monté dans les TMR en mode : " + tmrData.mode, whisper: ChatUtility.getGMs() });
}
return new RdDTMRDialog(html, actor, tmrData)
}
@ -82,7 +82,7 @@ export class RdDTMRDialog extends Dialog {
this.rencontreState = 'aucune';
this.subdialog = undefined
this.displaySize = undefined
if (!this.viewOnly) {
if (!this.viewOnly && !game.user.isGM) {
this._tellToGM(this.actor.name + " monte dans les terres médianes (" + tmrData.mode + ")");
}
this.callbacksOnAnimate = [];
@ -496,7 +496,7 @@ export class RdDTMRDialog extends Dialog {
rencData.message = this.formatMessageRencontre(rencData, result.message);
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(this.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-rencontre-tmr.html`, rencData)
});
@ -571,12 +571,20 @@ export class RdDTMRDialog extends Dialog {
/* -------------------------------------------- */
_tellToGM(message) {
ChatMessage.create({ content: message, user: game.user.id, whisper: ChatMessage.getWhisperRecipients("GM") });
ChatMessage.create({
user: game.user.id,
content: message,
whisper: ChatUtility.getGMs()
});
}
/* -------------------------------------------- */
_tellToUserAndGM(message) {
ChatMessage.create({ content: message, user: game.user.id, whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients("GM")) });
ChatMessage.create({
user: game.user.id,
content: message,
whisper: ChatUtility.getUserAndGMs()
})
}
/* -------------------------------------------- */
@ -715,7 +723,7 @@ export class RdDTMRDialog extends Dialog {
}
rollData.poesie = await Poetique.getExtrait();
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(this.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-maitrise-tmr.html`, rollData)
});
if (rollData.rolled.isEchec) {
@ -739,7 +747,7 @@ export class RdDTMRDialog extends Dialog {
if (this.isCaseMaitrisee(tmr.coord)) {
ChatMessage.create({
content: tmr.label + ": cette case humide est déja maitrisée grâce à votre Tête <strong>Quête des Eaux</strong>",
whisper: ChatMessage.getWhisperRecipients(game.user.name)
whisper: ChatUtility.getOwners(this.actor)
});
return false;
}
@ -751,14 +759,14 @@ export class RdDTMRDialog extends Dialog {
if (tmr.type == 'pont' && EffetsDraconiques.isPontImpraticable(this.actor)) {
ChatMessage.create({
content: tmr.label + ": Vous êtes sous le coup d'une Impraticabilité des Ponts : ce pont doit être maîtrisé comme une case humide.",
whisper: ChatMessage.getWhisperRecipients(game.user.name)
whisper: ChatUtility.getOwners(this.actor)
});
return true;
}
if (this.isCaseInondee(tmr.coord)) {
ChatMessage.create({
content: tmr.label + ": cette case est inondée, elle doit être maîtrisée comme une case humide.",
whisper: ChatMessage.getWhisperRecipients(game.user.name)
whisper: ChatUtility.getOwners(this.actor)
});
return true;
}
@ -832,7 +840,7 @@ export class RdDTMRDialog extends Dialog {
}
rollData.poesie = await Poetique.getExtrait();
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(this.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-maitrise-tmr.html`, rollData)
});
if (rollData.rolled.isEchec) {
@ -882,17 +890,16 @@ export class RdDTMRDialog extends Dialog {
const reserveSecurite = EffetsDraconiques.isReserveEnSecurite(this.actor);
const reserveExtensible = this.isReserveExtensible(coord);
if (!EffetsDraconiques.isUrgenceDraconique(this.actor) && (reserveSecurite || reserveExtensible)) {
const msg = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-demande-declencher-sort.hbs`, {
ChatMessage.create({
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-demande-declencher-sort.hbs`, {
actor: this.actor,
sorts: sorts,
coord: coord,
tete: { reserveSecurite: reserveSecurite, reserveExtensible: reserveExtensible }
}),
whisper: ChatUtility.getOwners(this.actor)
})
ChatMessage.create({
content: msg,
whisper: ChatMessage.getWhisperRecipients(game.user.name)
});
return;
return
}
await this.processSortReserve(sorts[0]);
}
@ -906,9 +913,8 @@ export class RdDTMRDialog extends Dialog {
this.processSortReserve(sort);
} else {
ChatMessage.create({
content:
"Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
whisper: ChatMessage.getWhisperRecipients(game.user.name),
content: "Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
whisper: ChatUtility.getOwners(this.actor)
});
}
}
@ -1091,7 +1097,7 @@ export class RdDTMRDialog extends Dialog {
async notifierResonanceSigneDraconique(coord) {
if (!this.viewOnly && this.actor.isResonanceSigneDraconique(coord)) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(this.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-resonance.html`, { alias: this.actor.name, typeTMR: TMRUtility.getTMRType(coord) })
});
}

32
module/rdd-utility.js
View File

@ -99,9 +99,7 @@ export class RdDUtility {
// persistent handling of conteneur show/hide
static afficheContenu = {}
/* -------------------------------------------- */
static async init() {
Hooks.on("renderChatMessage", async (app, html, msg) => await ChatUtility.onRenderChatMessage(app, html, msg))
Hooks.on("createChatMessage", async (chatMessage, options, id) => await ChatUtility.onCreateChatMessage(chatMessage, options, id))
static async initHooks() {
Hooks.on('renderChatLog', (log, html, chatLog) => RdDUtility.chatListeners(html))
}
@ -292,7 +290,7 @@ export class RdDUtility {
Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
Handlebars.registerHelper('isLastIndex', (index, list) => index+1 >= list.length);
Handlebars.registerHelper('isLastIndex', (index, list) => index + 1 >= list.length);
Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
Handlebars.registerHelper('filtreTriCompetences', competences => RdDItemCompetence.triVisible(competences));
@ -645,18 +643,16 @@ export class RdDUtility {
/* -------------------------------------------- */
static onSocketMessage(sockmsg) {
switch (sockmsg.msg) {
case "msg_gm_chat_message":
return ChatUtility.handleGMChatMessage(sockmsg.data);
case "msg_app_astrologie_refresh":
return Hooks.callAll(APP_ASTROLOGIE_REFRESH);
return Hooks.callAll(APP_ASTROLOGIE_REFRESH)
case "msg_request_nombre_astral":
return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data)
case "msg_tmr_move":
let actor = game.actors.get(sockmsg.data.actorId);
if (actor.isOwner || game.user.isGM) {
actor.refreshTMRView();
actor.refreshTMRView()
}
break;
break
}
}
@ -808,17 +804,13 @@ export class RdDUtility {
user: game.user.id,
rollMode: modeOverride || game.settings.get("core", "rollMode"),
content: content
};
if (["gmroll", "blindroll"].includes(chatData.rollMode)) chatData["whisper"] = ChatMessage.getWhisperRecipients("GM").map(u => u.id);
if (chatData.rollMode === "blindroll") chatData["blind"] = true;
else if (chatData.rollMode === "selfroll") chatData["whisper"] = [game.user];
}
ChatUtility.applyRollMode(chatData)
if (forceWhisper) { // Final force !
chatData["speaker"] = ChatMessage.getSpeaker();
chatData["whisper"] = ChatMessage.getWhisperRecipients(forceWhisper);
chatData.speaker = ChatMessage.getSpeaker();
chatData.whisper = ChatMessage.getWhisperRecipients(forceWhisper);
}
return chatData;
}
@ -881,7 +873,7 @@ export class RdDUtility {
const current = game.system.rdd.calendrier.heureCourante();
ChatMessage.create({
content: `A l'heure de <strong>${current.label}</strong>, le modificateur de Chance/Malchance est de <strong>${Misc.toSignedString(ajustement)}</strong> pour l'heure de naissance <strong>${heure.label}</strong>.`,
whisper: ChatMessage.getWhisperRecipients("GM")
whisper: ChatUtility.getGMs()
});
}
else if (heureNaissance) {
@ -900,7 +892,7 @@ export class RdDUtility {
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),
whisper: ChatUtility.getUserAndGMs(),
content: message
});
}

6
module/settings/system-compendiums.js
View File

@ -291,7 +291,7 @@ export class CompendiumTableHelpers {
sound: CONFIG.sounds.dice,
content: flavorContent
};
await ChatUtility.createChatWithRollMode(game.user.id, messageData)
await ChatUtility.createChatWithRollMode(messageData)
}
/* -------------------------------------------- */
@ -304,10 +304,10 @@ export class CompendiumTableHelpers {
});
const messageData = {
user: game.user.id,
whisper: game.user.id,
whisper: [game.user],
content: flavorContent
};
await ChatUtility.createChatWithRollMode(game.user.id, messageData)
await ChatUtility.createChatWithRollMode(messageData)
}
}

6
module/tmr/effets-rencontres.js
View File

@ -30,7 +30,7 @@ export class EffetsRencontre {
static $reve_plus = async (actor, reve) => {
if (!ReglesOptionnelles.isUsing("recuperation-reve") && reve < 0) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
whisper: ChatUtility.getOwners(actor),
content: `Pas de récupération de rêve (${reve} points ignorés)`
});
return
@ -112,7 +112,7 @@ export class EffetsRencontre {
poesie: await Poetique.getExtrait()
})
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(context.actor.name),
whisper: ChatUtility.getOwners(context.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-reve-de-dragon.html`, context)
});
}
@ -127,7 +127,7 @@ export class EffetsRencontre {
}
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
whisper: ChatUtility.getOwners(context.actor),
content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-resultat-reve-de-dragon.html`, context)
});
}

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

@ -28,7 +28,7 @@ export class PresentCites extends Draconique {
let existants = actor.items.filter(it => this.isCase(it)).map(it => it.system.coord);
if (existants.length > 0) {
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(actor),
content: "Vous avez encore des présents dans des cités, vous devrez tirer une autre tête pour remplacer celle ci!"
})
}

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

@ -19,7 +19,7 @@ export class UrgenceDraconique extends Draconique {
// La queue se transforme en idée fixe
const ideeFixe = await RdDRollTables.getIdeeFixe();
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
whisper: ChatUtility.getOwners(actor),
content: `En l'absence de sorts en réserve, l'urgence draconique de ${actor.name} se transforme en ${ideeFixe.name}`
});
await actor.createEmbeddedDocuments('Item', [ideeFixe]);

2
module/voyage/dialog-fatigue-voyage.js
View File

@ -175,7 +175,7 @@ export class DialogFatigueVoyage extends Dialog {
.forEach(async it => {
const perteFatigue = fatigueBase + it.ajustement
ChatMessage.create({
whisper: ChatUtility.getWhisperRecipientsAndGMs(it.actor.name),
whisper: ChatUtility.getOwners(it.actor),
content: await renderTemplate(
'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs',
foundry.utils.mergeObject(it,