${this.name} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !`
@@ -3992,109 +3973,64 @@ export class RdDActor extends Actor {
async onUpdateActor(update, options, actorId) {
const updatedEndurance = update?.data?.sante?.endurance;
if (updatedEndurance && options.diff) {
- this.forceStatusEffectId('unconscious', updatedEndurance.value == 0);
- }
- }
- /* -------------------------------------------- */
- async onCreateActiveEffect(effect, options) {
- switch (StatusEffects.statusId(effect)) {
- case 'sonne':
- await this.setStateSonne(true);
- return;
+ await this.setStatusEffect("EFFECT.StatusUnconscious", updatedEndurance.value == 0);
}
}
/* -------------------------------------------- */
async onDeleteActiveEffect(effect, options) {
- switch (StatusEffects.statusId(effect)) {
- case 'sonne':
- await this.setStateSonne(false);
+ switch (effect.label) {
+ case 'EFFECT.StatusStunned':
return;
}
}
/* -------------------------------------------- */
- enleverTousLesEffets() {
- const ids = Array.from(this.effects?.keys() ?? []);
- this.deleteEmbeddedDocuments('ActiveEffect', ids);
+ getActiveEffects(matching = it => true) {
+ return Array.from(this.getEmbeddedCollection("ActiveEffect").values()).filter(it => matching(it));
}
/* -------------------------------------------- */
- listeEffets(matching = it => true) {
- const all = Array.from(this.effects?.values() ?? []);
- const filtered = all.filter(it => matching(it.data));
- return filtered;
+ getEffectByLabel(label) {
+ return this.getActiveEffects().find(it => it.data.label == label);
}
/* -------------------------------------------- */
- async setStatusDemiReve(status) {
- const demiReve = StatusEffects.demiReve();
- if (status) {
- await this.addStatusEffect(demiReve)
- } else {
- await this.deleteStatusEffect(demiReve)
- }
+ getEffectById(id) {
+ return this.getActiveEffects().find(it => it.id == id);
}
/* -------------------------------------------- */
- async setStatusSonne(sonne) {
- if (this.isEntiteCauchemar()) {
+ async setStatusEffect(label, status, updates = {}) {
+ if (this.isEntiteCauchemar() || this.data.type == 'vehicule') {
return;
}
- await this.forceStatusEffectId('sonne', sonne);
- }
-
- /* -------------------------------------------- */
- async forceStatusEffectId(statusId, isSet) {
- if (isSet) {
- await this.addStatusEffectById(statusId);
+ console.log("setStatusEffect", label, status, updates)
+ const existing = this.getEffectByLabel(label);
+ if (existing) {
+ existing.delete();
}
- else {
- await this.deleteStatusEffectById(statusId);
+ if (status) {
+ const statusEffect = mergeObject(duplicate(StatusEffects.status(label)), updates);
+ await this.createEmbeddedDocuments("ActiveEffect", [statusEffect]);
}
}
- /* -------------------------------------------- */
- async deleteStatusEffectById(id) {
-
- const ids = Array.from(this.effects?.values())
- .filter(it => it.data.flags.core?.statusId == id)
- .map(it => it.id);
- console.log("Delete effect IDS1: ", this.effects, ids);
- if (ids.length > 0) {
- await this.deleteEmbeddedDocuments('ActiveEffect', ids);
+ enleverActiveEffectById(id) {
+ if (game.user.isGM){
+ const existing = this.getEffectById(id);
+ if (existing) {
+ existing.delete();
+ }
}
}
-
/* -------------------------------------------- */
- async deleteStatusEffect(effect) {
- const ids = Array.from(this.effects?.values())
- .filter(it => StatusEffects.statusId(it.data) == StatusEffects.statusId(effect))
- .map(it => it.id);
- console.log("Delete effect 1: ", this.effects, ids);
- if (ids.length > 0) {
- await this.deleteEmbeddedDocuments('ActiveEffect', ids);
+ enleverTousLesEffets() {
+ if (game.user.isGM){
+ this.deleteEmbeddedDocuments('ActiveEffect', this.getActiveEffects().map(it => it.id));
}
}
- /* -------------------------------------------- */
- async addStatusEffectById(id) {
- const statusEffect = CONFIG.statusEffects.find(it => it.id == id);
- await this.addStatusEffect(statusEffect);
- }
-
- /* -------------------------------------------- */
- async addStatusEffect(statusEffect) {
- const effet = Misc.data(statusEffect);
- await this.deleteStatusEffectById(effet.id);
- effet.flags = effet.flags ?? { core: {} };
- effet.flags.core.statusId = effet.id;
- let effectArray = await this.createEmbeddedDocuments('ActiveEffect', [effet]);
- //if (effectArray[0]) {
- //await effectArray[0].setFlag('core', 'statusId', effet.id);
- //}
- }
-
/* -------------------------------------------- */
async onPreUpdateItem(item, change, options, id) {
const itemData = Misc.data(item);
diff --git a/module/item-arme.js b/module/item-arme.js
index 4eed2dca..f18bb712 100644
--- a/module/item-arme.js
+++ b/module/item-arme.js
@@ -3,7 +3,8 @@ import { Misc } from "./misc.js";
import { RdDCombatManager } from "./rdd-combat.js";
const nomCategorieParade = {
- "sans-armes": "Sans arme / armes naturelles",
+ "sans-armes": "Sans arme",
+ "armes-naturelles": "Sans arme",
"hast": "Armes d'hast",
"batons": "Bâtons",
"boucliers": "Boucliers",
@@ -71,7 +72,7 @@ export class RdDItemArme extends Item {
}
// pour compatibilité avec des personnages existants
if (armeData.type == 'competencecreature' || armeData.data.categorie == 'creature') {
- return armeData.data.categorie_parade || (armeData.data.isparade ? 'sans-armes' : '');
+ return armeData.data.categorie_parade || (armeData.data.isparade ? 'armes-naturelles' : '');
}
if (!armeData.type.match(/arme|competencecreature/)) {
return '';
@@ -137,7 +138,7 @@ export class RdDItemArme extends Item {
/* -------------------------------------------- */
static armeUneOuDeuxMains(armeData, aUneMain) {
armeData = Misc.data(armeData);
- if (armeData) {
+ if (armeData && !armeData.data.cac) {
armeData.data.unemain = armeData.data.unemain || !armeData.data.deuxmains;
const uneOuDeuxMains = armeData.data.unemain && armeData.data.deuxmains;
const containsSlash = !Number.isInteger(armeData.data.dommages) && armeData.data.dommages.includes("/");
@@ -170,11 +171,12 @@ export class RdDItemArme extends Item {
let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { data: { niveau: -6 } };
let init = RdDCombatManager.calculInitiative(corpsACorps.data.niveau, carac['melee'].value);
armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.data.niveau, initiative: init }));
+ armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.data.niveau, initiative: init }));
}
- static mainsNues(actorData = {}) {
- const mainsNues = {
- name: 'Mains nues',
+ static corpsACorps(actorData) {
+ const corpsACorps = {
+ name: 'Corps à corps',
data: {
equipe: true,
rapide: true,
@@ -186,9 +188,24 @@ export class RdDItemArme extends Item {
categorie_parade: 'sans-armes'
}
};
- if (actorData) {
- mergeObject(mainsNues.data, actorData, { overwrite: false });
- }
- return mainsNues
+ mergeObject(corpsACorps.data, actorData ??{}, { overwrite: false });
+ return corpsACorps;
+ }
+
+ static mainsNues(actorData) {
+ const mainsNues = RdDItemArme.corpsACorps(actorData);
+ mainsNues.name = 'Mains nues';
+ mainsNues.data.cac = 'pugilat';
+ mainsNues.data.baseInit = 4;
+ return mainsNues;
+ }
+
+ static empoignade(actorData) {
+ const empoignade = RdDItemArme.corpsACorps(actorData);
+ empoignade.name = 'Empoignade';
+ empoignade.data.cac = 'empoignade';
+ empoignade.data.baseInit = 3;
+ empoignade.data.mortalite = 'empoignade';
+ return empoignade;
}
}
diff --git a/module/misc.js b/module/misc.js
index 3c115740..da74c589 100644
--- a/module/misc.js
+++ b/module/misc.js
@@ -13,6 +13,10 @@ export class Misc {
return text.charAt(0).toUpperCase() + text.slice(1);
}
+ static lowerFirst(text) {
+ return text.charAt(0).toLowerCase() + text.slice(1);
+ }
+
static toSignedString(number) {
const value = parseInt(number)
const isPositiveNumber = value != NaN && value > 0;
diff --git a/module/rdd-combat.js b/module/rdd-combat.js
index 34ca5ec0..3105ade7 100644
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -11,23 +11,23 @@ import { ReglesOptionelles } from "./regles-optionelles.js";
/* -------------------------------------------- */
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 },
+ { pattern: 'hast', init: 5.90 },
+ { pattern: 'lance', init: 5.85 },
+ { pattern: 'baton', init: 5.80 },
+ { pattern: 'doubledragonne', init: 5.75 },
+ { pattern: 'esparlongue', init: 5.70 },
+ { pattern: 'epeedragonne', init: 5.65 },
+ { pattern: 'epeebatarde', init: 5.60 },
+ { pattern: 'epeecyane', init: 5.55 },
+ { pattern: 'epeesorde', init: 5.50 },
+ { pattern: 'grandehache', init: 5.45 },
+ { pattern: 'bataille', init: 5.40 },
+ { pattern: 'epeegnome', init: 5.35 },
+ { pattern: 'masse', init: 5.30 },
+ { pattern: 'gourdin', init: 5.25 },
+ { pattern: 'fléau', init: 5.20 },
+ { pattern: 'dague', init: 5.15 },
+ { pattern: 'autre', init: 5.10 },
];
/* -------------------------------------------- */
@@ -38,6 +38,9 @@ export class RdDCombatManager extends Combat {
Hooks.on("getCombatTrackerEntryContext", (html, options) => {
RdDCombatManager.pushInitiativeOptions(html, options);
});
+ Hooks.on("preDeleteCombat", (combat, html, id) => {
+ combat.onPreDeleteCombat()
+ });
}
/* -------------------------------------------- */
@@ -48,10 +51,22 @@ export class RdDCombatManager extends Combat {
}
/* -------------------------------------------- */
- cleanSonne() {
+ async nextRound() {
+ this.cleanItemUse();
+ await this.finDeRound();
+ return await super.nextRound();
+ }
+
+ /* -------------------------------------------- */
+ async onPreDeleteCombat() {
+ await this.finDeRound({ terminer: true });
+ }
+
+ /* -------------------------------------------- */
+ async finDeRound(options = { terminer: false }) {
for (let combatant of this.data.combatants) {
if (combatant.actor) {
- combatant.actor.verifierSonneRound(this.current.round);
+ await combatant.actor.finDeRound(options);
}
else {
ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur!`)
@@ -59,14 +74,6 @@ export class RdDCombatManager extends Combat {
}
}
- /* -------------------------------------------- */
- async nextRound() {
- //console.log('New round !');s
- this.cleanItemUse();
- this.cleanSonne();
- return super.nextRound();
- }
-
/************************************************************************************/
async rollInitiative(ids, formula = undefined, messageOptions = {}) {
console.log(`${game.data.system.data.title} | Combat.rollInitiative()`, ids, formula, messageOptions);
@@ -148,7 +155,8 @@ export class RdDCombatManager extends Combat {
let compData = competences.map(c => Misc.data(c)).find(c => c.name == armeData.data.competence);
armesEquipe.push(armeData);
- armeData.data.initiative = RdDCombatManager.calculInitiative(armeData.data.niveau, carac[compData.data.defaut_carac].value);
+ armeData.data.niveau = compData.data.niveau;
+ armeData.data.initiative = RdDCombatManager.calculInitiative(compData.data.niveau, carac[compData.data.defaut_carac].value);
// Dupliquer les armes pouvant être à 1 main et 2 mains en patchant la compétence
if (armeData.data.unemain && !armeData.data.deuxmains) {
armeData.data.mainInfo = "(1m)";
@@ -185,7 +193,8 @@ export class RdDCombatManager extends Combat {
} else {
// Recupération des items 'arme'
let armes = items.filter(it => RdDItemArme.isArmeUtilisable(it))
- .concat(RdDItemArme.mainsNues());
+ .concat(RdDItemArme.mainsNues())
+ .concat(RdDItemArme.empoignade());
let competences = items.filter(it => it.type == 'competence');
actions = actions.concat(RdDCombatManager.finalizeArmeList(armes, competences, actorData.data.carac));
@@ -277,30 +286,23 @@ export class RdDCombatManager extends Combat {
initOffset = 2;
initInfo = "Autre Action"
} else if (arme.name == "Draconic") {
- initOffset = 7;
+ initOffset = 9;
initInfo = "Draconic"
} else {
- initOffset = 3; // Melée = 3.XX
compData = Misc.data(RdDItemCompetence.findCompetence(combatant.actor.data.items, arme.data.competence));
compNiveau = compData.data.niveau;
initInfo = arme.name + " / " + arme.data.competence;
-
if (combatant.actor.data.type == 'creature' || combatant.actor.data.type == 'entite') {
caracForInit = compData.data.carac_value;
if (compData.data.categorie == "lancer") {
+ initOffset = 7;
+ }
+ else {
initOffset = 5;
}
} else {
caracForInit = Misc.data(combatant.actor).data.carac[compData.data.defaut_carac].value;
- if (compData.data.categorie == "lancer") { // Offset de principe pour les armes de jet
- initOffset = 4;
- }
- if (compData.data.categorie == "tir") { // Offset de principe pour les armes de jet
- initOffset = 5;
- }
- if (compData.data.categorie == "melee") { // Offset de principe pour les armes de jet
- initOffset = 3;
- }
+ initOffset = RdDCombatManager._baseInitOffset(compData.data.categorie, arme);
}
}
let malus = combatant.actor.getEtatGeneral(); // Prise en compte état général
@@ -311,6 +313,21 @@ export class RdDCombatManager extends Combat {
game.combat.rollInitiative(combatantId, rollFormula, { initInfo: initInfo });
}
+ static _baseInitOffset(categorie, arme) {
+ if (categorie == "tir") { // Offset de principe pour les armes de jet
+ return 8;
+ }
+ if (categorie == "lancer") { // Offset de principe pour les armes de jet
+ return 7;
+ }
+ // Offset de principe pour les armes de jet
+ switch (arme.data.cac) {
+ case "empoignade": return 3;
+ case "pugilat": return 4;
+ }
+ return 5;
+ }
+
/* -------------------------------------------- */
static displayInitiativeMenu(html, combatantId) {
console.log("Combatant ; ", combatantId);
@@ -706,10 +723,21 @@ export class RdDCombat {
}
/* -------------------------------------------- */
- async attaque(competence, arme = undefined) {
+ async attaque(competence, arme) {
if (!await this.accorderEntite('avant-attaque')) {
return;
}
+ if (arme.data.cac == 'empoignade' && this.attacker.isCombatTouche()) {
+ ChatMessage.create({
+ alias: this.attacker.name,
+ whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
+ content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-actor-perte-empoignade.html', {
+ attacker: this.attacker,
+ competence: competence
+ })
+ });
+ return;
+ }
let rollData = this._prepareAttaque(competence, arme);
console.log("RdDCombat.attaque >>>", rollData);
@@ -742,6 +770,7 @@ export class RdDCombat {
_prepareAttaque(competence, arme) {
let rollData = {
passeArme: randomID(16),
+ mortalite: arme?.data.mortalite,
coupsNonMortels: false,
competence: competence,
surprise: this.attacker.getSurprise(true),
@@ -758,7 +787,9 @@ export class RdDCombat {
}
else {
// sans armes: à mains nues
- rollData.arme = RdDItemArme.mainsNues({ niveau: competence.data.niveau });
+ const niveau = competence.data.niveau;
+ const init = RdDCombatManager.calculInitiative(niveau, Misc.templateData(this.attacker).carac['melee'].value);
+ rollData.arme = RdDItemArme.mainsNues({ niveau: niveau, initiative: init });
}
return rollData;
}
@@ -767,8 +798,24 @@ export class RdDCombat {
async _onAttaqueParticuliere(rollData) {
RdDCombat._storeAttaque(this.attackerId, rollData);
- // Finesse et Rapidité seulement en mêlée et si la difficulté libre est de -1 minimum
const isMeleeDiffNegative = (rollData.competence.type == 'competencecreature' || rollData.selectedCarac.label == "Mêlée") && rollData.diffLibre < 0;
+ // force toujours, sauf empoignade
+ // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
+ // rapidité seulement en mêlée, si l'arme le permet, et si la difficulté libre est de -1 minimum
+ const isForce = !rollData.arme.data.empoignade;
+ const isFinesse = rollData.arme.data.empoignade || isMeleeDiffNegative;
+ const isRapide = !rollData.arme.data.empoignade && isMeleeDiffNegative && rollData.arme.data.rapide;
+ // si un seul choix possible, le prendre
+ if (isForce && !isFinesse && !isRapide) {
+ return await this.choixParticuliere(rollData, "force");
+ }
+ else if (!isForce && isFinesse && !isRapide) {
+ return await this.choixParticuliere(rollData, "finesse");
+ }
+ else if (!isForce && !isFinesse && isRapide) {
+ return await this.choixParticuliere(rollData, "rapidite");
+ }
+
ChatMessage.create({
alias: this.attacker.name,
whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
@@ -776,8 +823,9 @@ export class RdDCombat {
alias: this.attacker.name,
attackerId: this.attackerId,
defenderTokenId: this.defenderTokenId,
- isFinesse: isMeleeDiffNegative,
- isRapide: isMeleeDiffNegative && rollData.arme.data.rapide,
+ isForce: isForce,
+ isFinesse: isFinesse,
+ isRapide: isRapide,
passeArme: rollData.passeArme
})
});
@@ -915,7 +963,7 @@ export class RdDCombat {
console.log("RdDCombat._onEchecTotal >>>", rollData);
const arme = rollData.arme;
- const avecArme = arme && arme.data.categorie_parade != 'sans-armes';
+ const avecArme = !['', 'sans-armes', 'armes-naturelles'].includes(arme?.data.categorie_parade ?? '');
const action = (rollData.attackerRoll ? (arme ? "la parade" : "l'esquive") : "l'attaque");
ChatUtility.createChatWithRollMode(this.defender.name, {
content: `Maladresse à ${action}! ` + await RdDRollTables.getMaladresse({ arme: avecArme })
@@ -1176,7 +1224,7 @@ export class RdDCombat {
defenderRoll.show.recul = 'encaisse';
} else if (rollRecul.rolled.isETotal || this._isReculCauseChute(impact)) {
defenderRoll.show.recul = 'chute';
- await this.defender.addStatusEffectById('prone');
+ await this.defender.setStatusEffect("EFFECT.StatusProne", true);
}
else {
defenderRoll.show.recul = 'recul';
diff --git a/module/rdd-hotbar-drop.js b/module/rdd-hotbar-drop.js
index a3efd6b6..2f4e6343 100644
--- a/module/rdd-hotbar-drop.js
+++ b/module/rdd-hotbar-drop.js
@@ -1,3 +1,4 @@
+import { Misc } from "./misc.js";
export class RdDHotbar {
@@ -67,15 +68,14 @@ export class RdDHotbar {
let actor;
if (speaker.token) actor = game.actors.tokens[speaker.token];
if (!actor) actor = game.actors.get(speaker.actor);
- let item = actor ? actor.items.find(i => i.name === itemName && i.type == itemType) : null;
- if (!item) return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
- item = item.data;
+ let item = Misc.data(actor?.items.find(it => it.name === itemName && it.type == itemType));
+ if (!item) return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
// Trigger the item roll
switch (item.type) {
case "arme":
- return actor.rollArme(item.data.competence, itemName);
+ return actor.rollArme(item);
case "competence":
return actor.rollCompetence( itemName );
}
diff --git a/module/rdd-roll-encaisser.js b/module/rdd-roll-encaisser.js
index a8e0d6e5..8e87e284 100644
--- a/module/rdd-roll-encaisser.js
+++ b/module/rdd-roll-encaisser.js
@@ -8,8 +8,9 @@ export class RdDEncaisser extends Dialog {
constructor(html, actor) {
// Common conf
const buttonsCreatures = {
- "mortel": { label: "mortel", callback: html => this.performEncaisser("mortel") },
- "non-mortel": { label: "non-mortel", callback: html => this.performEncaisser("non-mortel") },
+ "mortel": { label: "Mortel", callback: html => this.performEncaisser("mortel") },
+ "non-mortel": { label: "Non-mortel", callback: html => this.performEncaisser("non-mortel") },
+ "sonne": { label: "Sonné", callback: html => this.actor.setSonne() },
};
const buttonsEntitesCauchemar = {
"cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
diff --git a/module/rdd-roll.js b/module/rdd-roll.js
index 335c2082..243d5b6a 100644
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@@ -221,7 +221,7 @@ export class RdDRoll extends Dialog {
console.log("RdDRollSelectDialog - Cout reve", ptreve);
this.updateRollResult();
});
- html.find('#coupsNonMortels').change((event) => {
+ html.find("[name='coupsNonMortels']").change((event) => {
this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
this.updateRollResult();
});
@@ -300,12 +300,14 @@ export class RdDRoll extends Dialog {
rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat());
rollData.caracValue = parseInt(rollData.selectedCarac.value);
+ rollData.mortalite = rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite ?? 'mortel';
rollData.coupsNonMortels = (rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite) == 'non-mortel';
rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);
let dmgText = Misc.toSignedString(rollData.dmg.total);
- if (rollData.coupsNonMortels) {
- dmgText = `(${dmgText}) non-mortel`
+ switch (rollData.mortalite){
+ case 'non-mortel': dmgText = `(${dmgText}) non-mortel`; break;
+ case 'empoignade': dmgText = `empoignade`; break;
}
RollDataAjustements.calcul(rollData, this.actor);
@@ -318,7 +320,7 @@ export class RdDRoll extends Dialog {
// Mise à jour valeurs
$(".dialog-roll-title").text(this._getTitle(rollData));
- $('#coupsNonMortels').prop('checked', rollData.coupsNonMortels);
+ $("[name='coupsNonMortels']").prop('checked', rollData.mortalite == 'non-mortel');
$(".dmg-arme-actor").text(dmgText);
$('.table-ajustement').remove();
$(".table-resolution").remove();
diff --git a/module/rdd-tmr-dialog.js b/module/rdd-tmr-dialog.js
index 48770b48..41c3ac73 100644
--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@@ -274,7 +274,7 @@ export class RdDTMRDialog extends Dialog {
if ( this.actor.tmrApp ) {
this.actor.tmrApp = undefined; // Cleanup reference
if ( !this.viewOnly ) {
- this.actor.setStatusDemiReve(false);
+ this.actor.setStatusEffect("EFFECT.StatusDemiReve", false);
this._tellToGM(this.actor.name + " a quitté les terres médianes");
}
this.actor.santeIncDec("fatigue", this.cumulFatigue).then(super.close()); // moving 1 cell costs 1 fatigue
diff --git a/module/rdd-token-hud.js b/module/rdd-token-hud.js
index d748964f..a754512f 100644
--- a/module/rdd-token-hud.js
+++ b/module/rdd-token-hud.js
@@ -53,8 +53,7 @@ export class RdDTokenHud {
await RdDTokenHud._configureSubMenu(controlIconTarget, 'systems/foundryvtt-reve-de-dragon/templates/hud-actor-attaque.html', hudData,
(event) => {
let armeIndex = event.currentTarget.attributes['data-arme-id'].value;
- let arme = armesList[armeIndex];
- actor.rollArme(arme.data.competence, arme.name);
+ actor.rollArme(armesList[armeIndex]);
});
}
diff --git a/module/rdd-utility.js b/module/rdd-utility.js
index 6de5f96c..40f64b44 100644
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@@ -115,6 +115,7 @@ export class RdDUtility {
'systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.html',
'systems/foundryvtt-reve-de-dragon/templates/actor-sheet-competence-partial.html',
'systems/foundryvtt-reve-de-dragon/templates/actor-sheet-categorie-competences-partial.html',
+ 'systems/foundryvtt-reve-de-dragon/templates/actor-sheet-effects-partial.html',
'systems/foundryvtt-reve-de-dragon/templates/actor-sheet-oeuvre-partial.html',
'systems/foundryvtt-reve-de-dragon/templates/actor-liste-blessures-partial.html',
'systems/foundryvtt-reve-de-dragon/templates/actor-blessure-partial.html',
diff --git a/module/status-effects.js b/module/status-effects.js
index 5b05324b..b8f838c1 100644
--- a/module/status-effects.js
+++ b/module/status-effects.js
@@ -1,23 +1,31 @@
-const demiReveStatusEffect = { id: 'demi-reve', rdd: true, label: 'Demi-rêve', icon: 'systems/foundryvtt-reve-de-dragon/icons/heures/hd12.svg' };
const rddStatusEffects = [
- { id: 'sonne', rdd: true, label: 'Sonné', icon: 'icons/svg/stoned.svg' },
- demiReveStatusEffect
+ { rdd: true, id: 'stun', label: 'EFFECT.StatusStunned', icon: 'icons/svg/stoned.svg', "duration.rounds": 1 },
+ { rdd: true, id: 'bleeding', label: 'EFFECT.StatusBleeding', icon: 'icons/svg/blood.svg' },
+ { rdd: true, id: 'prone', label: 'EFFECT.StatusProne', icon: 'icons/svg/falling.svg' },
+ { rdd: true, id: 'grappling', tint: '#33cc33', label: 'EFFECT.StatusGrappling', icon: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp' },
+ { rdd: true, id: 'grappled', tint: '#ff9900', label: 'EFFECT.StatusGrappled', icon: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp' },
+ { rdd: true, id: 'restrain', label: 'EFFECT.StatusRestrained', icon: 'icons/svg/net.svg' },
+ { rdd: true, id: 'unconscious', label: 'EFFECT.StatusUnconscious', icon: 'icons/svg/unconscious.svg' },
+ { rdd: true, id: 'blind', label: 'EFFECT.StatusBlind', icon: 'icons/svg/blind.svg' },
+ { rdd: true, id: 'comma', label: 'EFFECT.StatusComma', icon: 'icons/svg/skull.svg' },
+ { rdd: true, id: 'dead', label: 'EFFECT.StatusDead', icon: 'icons/svg/skull.svg' },
+ { rdd: true, id: 'demi-reve', label: 'EFFECT.StatusDemiReve', icon: 'systems/foundryvtt-reve-de-dragon/icons/heures/hd12.svg' }
];
-const statusDemiSurprise = new Set(['sonne', 'prone', 'restrain']);
-const statusSurpriseTotale = new Set(['unconscious', 'blind', 'dead']);
+const demiReveStatusEffect = rddStatusEffects.find(it => it.label == 'EFFECT.StatusDemiReve');
+
+const statusDemiSurprise = new Set(['EFFECT.StatusStunned', 'EFFECT.StatusProne', 'EFFECT.StatusRestrain']);
+const statusSurpriseTotale = new Set(['EFFECT.StatusUnconscious', 'EFFECT.StatusBlind', 'EFFECT.StatusComma']);
export class StatusEffects {
static onReady() {
- StatusEffects.setCoreStatusId([demiReveStatusEffect]);
- StatusEffects.setCoreStatusId(rddStatusEffects);
- StatusEffects.setMandatoryRdd();
- const defaultUseStatusEffect = CONFIG.statusEffects.map(it => it.id).join();
+ const rddStatusIds = rddStatusEffects.map(it => it.id);
+ const defaultStatusEffectIds = CONFIG.statusEffects.map(it => it.id);
game.settings.register("foundryvtt-reve-de-dragon", "use-status-effects", {
name: "use-status-effects",
scope: "world",
config: false,
- default: defaultUseStatusEffect,
+ default: defaultStatusEffectIds.join(),
type: String
});
@@ -29,30 +37,21 @@ export class StatusEffects {
type: StatusEffectsSettings,
restricted: true
});
- CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects);
-
+
+ CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects.filter(it => !rddStatusIds.includes(it.id)));
+
StatusEffects._setUseStatusEffects(StatusEffects._getUseStatusEffects());
console.log('statusEffects', CONFIG.statusEffects);
}
static valeurSurprise(effect, isCombat) {
- const id = StatusEffects.statusId(effect);
- if (statusSurpriseTotale.has(id)) {
+ // const id = StatusEffects.statusId(effect);
+ if (statusSurpriseTotale.has(effect.label)) {
return 2;
}
- return statusDemiSurprise.has(id) || (isCombat && id == demiReveStatusEffect.id) ? 1 : 0;
+ return statusDemiSurprise.has(effect.label) || (isCombat && effect.label == demiReveStatusEffect.label) ? 1 : 0;
}
- static statusId(effectData) {
- return effectData.flags?.core?.statusId ?? effectData["flags.core.statusId"];
- }
-
- static setCoreStatusId(list) {
- list.forEach(it => {
- it.flags = { core: { statusId: it.id } };
- it["flags.core.statusId"] = it.id;
- });
- }
static setMandatoryRdd() {
CONFIG.statusEffects.filter(it => statusDemiSurprise.has(it.id) || statusSurpriseTotale.has(it.id))
.forEach(it => it.rdd = true);
@@ -78,6 +77,9 @@ export class StatusEffects {
return Array.from(useStatusEffects).join();
}
+ static status(label) {
+ return rddStatusEffects.find(it => it.label == label) ?? { label: label };
+ }
static demiReve() {
return demiReveStatusEffect;
}
diff --git a/styles/simple.css b/styles/simple.css
index ff9b32a0..e925f788 100644
--- a/styles/simple.css
+++ b/styles/simple.css
@@ -271,6 +271,11 @@ table {border: 1px solid #7a7971;}
height: 16;
border-width: 0;
}
+.button-effect-img:hover {
+ color: rgba(255, 255, 128, 0.7);
+ border: 1px solid rgba(255, 128, 0, 0.8);
+ cursor: pointer;
+}
.small-button-container {
height: 16px;
diff --git a/template.json b/template.json
index c5bee0fa..14df291c 100644
--- a/template.json
+++ b/template.json
@@ -164,11 +164,6 @@
"value": 10,
"label": "Endurance",
"derivee": false
- },
- "sonne": {
- "value": false,
- "round": -1,
- "label": "Sonné"
}
},
"blessures": {
@@ -374,10 +369,6 @@
"value": 0,
"label": "Fatigue",
"derivee": true
- },
- "sonne": {
- "value": false,
- "label": "Sonné"
}
},
"blessures": {
diff --git a/templates/actor-creature-sheet.html b/templates/actor-creature-sheet.html
index 70b233a5..2ba0ebca 100644
--- a/templates/actor-creature-sheet.html
+++ b/templates/actor-creature-sheet.html
@@ -18,19 +18,7 @@
{{calc.resumeBlessures}}