v0.5 fixes

Reviewed-on: #545

module/actor.js

@@ -33,7 +33,8 @@ import { RollDataAjustements } from "./rolldata-ajustements.js";
 import { DialogItemAchat } from "./dialog-item-achat.js";
 import { RdDItem } from "./item.js";
 import { RdDPossession } from "./rdd-possession.js";
-import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+
 
 /* -------------------------------------------- */
 /**
@@ -98,7 +99,6 @@ export class RdDActor extends Actor {
    * @param {Object} options     (Unused) Additional options which customize the creation workflow.
    *
    */
-
   static async create(actorData, options) {
     // Case of compendium global import
     if (actorData instanceof Array) {
@@ -135,13 +135,6 @@ export class RdDActor extends Actor {
     this.encTotal = 0;
     this.prixTotalEquipement = 0;
 
-    /*
-    // Auto-resize token
-    if (this.isToken) {
-      let tokenSize = actorData.data.carac.taille.value/10;
-      this.token.update({height: tokenSize, width: tokenSize } );
-    }*/
-
     // Make separate methods for each Actor type (character, npc, etc.) to keep
     // things organized.
     if (actorData.type === 'personnage') this._prepareCharacterData(actorData);
@@ -247,7 +240,7 @@ export class RdDActor extends Actor {
   }
   /* -------------------------------------------- */
   getForce() {
-    if (this.isEntiteCauchemar()) {
+    if (this.isEntite()) {
       return Misc.toInt(Misc.templateData(this).carac.reve?.value);
     }
     return Misc.toInt(Misc.templateData(this).carac.force?.value);
@@ -620,7 +613,10 @@ export class RdDActor extends Actor {
       content: "Remise à neuf de " + this.name
     };
     const actorData = Misc.data(this);
-    if (this.isEntiteCauchemar()) {
+    if (this.isEntite([ENTITE_NONINCARNE])) {
+      return;
+    }
+    if (this.isEntite([ENTITE_INCARNE, ENTITE_BLURETTE])) {
       await this.santeIncDec("endurance", actorData.data.sante.endurance.max - actorData.data.sante.endurance.value);
     }
     else {
@@ -1630,7 +1626,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async setSonne(sonne = true) {
-    if (this.isEntiteCauchemar()) {
+    if (this.isEntite()) {
       return;
     }
     if (!game.combat && sonne) {
@@ -1642,7 +1638,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   getSConst() {
-    if (this.isEntiteCauchemar()) {
+    if (this.isEntite()) {
       return 0;
     }
     return RdDCarac.calculSConst(Misc.templateData(this).carac.constitution.value);
@@ -1759,7 +1755,7 @@ export class RdDActor extends Actor {
     result.newValue = Math.max(minValue, Math.min(compteur.value + inc, compteur.max));
     //console.log("New value ", inc, minValue, result.newValue);
     let fatigue = 0;
-    if (name == "endurance" && !this.isEntiteCauchemar()) {
+    if (name == "endurance" && !this.isEntite()) {
       if (result.newValue == 0 && inc < 0 && !isCritique) { // perte endurance et endurance devient 0 (sauf critique) -> -1 vie
         sante.vie.value--;
         result.perteVie = true;
@@ -1796,7 +1792,7 @@ export class RdDActor extends Actor {
   }
 
   isDead() {
-    return !this.isEntiteCauchemar() && Misc.templateData(this).sante.vie.value < -this.getSConst()
+    return !this.isEntite() && Misc.templateData(this).sante.vie.value < -this.getSConst()
   }
 
   /* -------------------------------------------- */
@@ -3355,7 +3351,7 @@ export class RdDActor extends Actor {
     let encaissement = await this.jetEncaissement(rollData);
 
     this.ajouterBlessure(encaissement); // Will upate the result table
-    const perteVie = this.isEntiteCauchemar()
+    const perteVie = this.isEntite()
       ? { newValue: 0 }
       : await this.santeIncDec("vie", - encaissement.vie);
     const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, encaissement.critiques > 0);
@@ -3370,7 +3366,7 @@ export class RdDActor extends Actor {
       sonne: perteEndurance.sonne,
       jetEndurance: perteEndurance.jetEndurance,
       endurance: santeOrig.endurance.value - perteEndurance.newValue,
-      vie: this.isEntiteCauchemar() ? 0 : (santeOrig.vie.value - perteVie.newValue),
+      vie: this.isEntite() ? 0 : (santeOrig.vie.value - perteVie.newValue),
       show: defenderRoll?.show ?? {}
     });
 
@@ -3560,8 +3556,8 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async accorder(entite, when = 'avant-encaissement') {
     if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
-      || !entite.isEntiteCauchemar()
-      || entite.isEntiteCauchemarAccordee(this)) {
+      || !entite.isEntite([ENTITE_INCARNE])
+      || entite.isEntiteAccordee(this)) {
       return true;
     }
     const tplData = Misc.templateData(this);
@@ -3585,29 +3581,30 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  isEntiteCauchemar() {
-    return this.data.type == 'entite';
+  isEntite(typeentite = [] ) {
+    return this.data.type == 'entite' && (typeentite.length == 0 || typeentite.includes(this.data.data.typeentite));
   }
 
   /* -------------------------------------------- */
-  isEntiteCauchemarAccordee(attaquant) {
-    if (!this.isEntiteCauchemar()) { return true; }
+  isEntiteAccordee(attaquant) {
+    if (!this.isEntite([ENTITE_INCARNE]))
+    { return true; }
     let resonnance = Misc.templateData(this).sante.resonnance;
-    return (resonnance.actors.find(it => it == attaquant._id));
+    return (resonnance.actors.find(it => it == attaquant.id));
   }
 
   /* -------------------------------------------- */
   async setEntiteReveAccordee(attaquant) {
-    if (!this.isEntiteCauchemar()) {
+    if (!this.isEntite([ENTITE_INCARNE])) {
       ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entite de cauchemer/rêve");
       return;
     }
     let resonnance = duplicate(Misc.templateData(this).sante.resonnance);
-    if (resonnance.actors.find(it => it == attaquant._id)) {
+    if (resonnance.actors.find(it => it == attaquant.id)) {
       // déjà accordé
       return;
     }
-    resonnance.actors.push(attaquant._id);
+    resonnance.actors.push(attaquant.id);
     await this.update({ "data.sante.resonnance": resonnance });
     return;
   }
@@ -4161,7 +4158,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async setStatusEffect(label, status, updates = {}) {
-    if (this.isEntiteCauchemar() || this.data.type == 'vehicule') {
+    if (this.isEntite() || this.data.type == 'vehicule') {
       return;
     }
     console.log("setStatusEffect", label, status, updates)

module/constants.js

@@ -3,3 +3,7 @@ export const SYSTEM_SOCKET_ID = 'system.foundryvtt-reve-de-dragon';
 
 export const HIDE_DICE = 'hide';
 export const SHOW_DICE = 'show';
+
+export const ENTITE_INCARNE = 'incarne';
+export const ENTITE_NONINCARNE = 'nonincarne';
+export const ENTITE_BLURETTE = 'blurette';

module/dialog-item-achat.js

@@ -55,7 +55,7 @@ export class DialogItemAchat extends Dialog {
 
   static prepareVenteData(buttonAcheter, vendeurId, vendeur, acheteur) {
     const jsondata = buttonAcheter.attributes['data-jsondata']?.value;
-    const prixLot = buttonAcheter.attributes['data-prixLot']?.value ?? 0;
+    const prixLot = parseInt(buttonAcheter.attributes['data-prixLot']?.value ?? 0);
     let venteData = {
       item: JSON.parse(jsondata),
       vendeurId: vendeurId,

module/rdd-combat.js

@@ -1,5 +1,5 @@
 import { ChatUtility } from "./chat-utility.js";
-import { HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
 import { Grammar } from "./grammar.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetence } from "./item-competence.js";
@@ -320,7 +320,7 @@ export class RdDCombatManager extends Combat {
       initOffset = 10;
       caracForInit = combatant.actor.getReveActuel();
       initInfo = "Possession"
-    } else if (action.name == 'autre') {
+    } else if (action.action == 'autre') {
       initOffset = 2;
       initInfo = "Autre Action"
     } else if (action.action == 'haut-reve') {
@@ -457,7 +457,7 @@ export class RdDCombat {
     else {
       const defender = target?.actor;
       const defenderTokenId = target?.data._id;
-      if ( defender.type == 'entite' && defender.data.data.definition.typeentite == 'nonincarne') {
+      if ( defender.type == 'entite' && defender.data.data.definition.typeentite == ENTITE_NONINCARNE) {
         ui.notifications.warn("Vous ne pouvez pas cibler une entité non incarnée !!!!");
       } else {
         return this.create(attacker, defender, defenderTokenId, target)
@@ -799,7 +799,7 @@ export class RdDCombat {
   async _onAttaqueNormale(attackerRoll) {
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
-    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntiteCauchemar());
+    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
       cible: this.target ? this.defender.data.name : 'la cible',
@@ -1249,8 +1249,8 @@ export class RdDCombat {
   async accorderEntite(when = 'avant-encaissement') {
     if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
       || this.defender == undefined
-      || !this.defender.isEntiteCauchemar()
-      || this.defender.isEntiteCauchemarAccordee(this.attacker)) {
+      || !this.defender.isEntite([ENTITE_INCARNE])
+      || this.defender.isEntiteAccordee(this.attacker)) {
       return true;
     }
 

module/rdd-namegen.js

@@ -1,19 +1,29 @@
+import { RdDActor } from "./actor.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
 
-const words = [ 'pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i', 'onse', 'iane', 'ane', 'zach', 'arri', 'ba', 'bo', 'bi', 
-              'alta', 'par', 'pir', 'zor', 'zir', 'de', 'pol', 'tran', 'no', 'la', 'al' , 'pul', 'one', 'ner', 'nur', 'mac', 'mery',
-              'cat', 'do', 'di', 'der', 'er', 'el', 'far', 'fer', 'go', 'guer', 'hot', 'jor', 'jar', 'ji', 'kri', 'ket', 'lor', 'hur',
-              'lar', 'lir', 'lu', 'pot', 'pro', 'pra', 'pit', 'qua', 'qui', 're', 'ral', 'sal', 'sen', 'ted', 'to', 'ta', 'lars', 'ver',
-              'vin', 'ov', 'wal', 'ry', 'ly', '' ];
+const words = ['pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i', 'onse', 'iane', 'ane', 'zach', 'arri', 'ba', 'bo', 'bi',
+  'alta', 'par', 'pir', 'zor', 'zir', 'de', 'pol', 'tran', 'no', 'la', 'al', 'pul', 'one', 'ner', 'nur', 'mac', 'mery',
+  'cat', 'do', 'di', 'der', 'er', 'el', 'far', 'fer', 'go', 'guer', 'hot', 'jor', 'jar', 'ji', 'kri', 'ket', 'lor', 'hur',
+  'lar', 'lir', 'lu', 'pot', 'pro', 'pra', 'pit', 'qua', 'qui', 're', 'ral', 'sal', 'sen', 'ted', 'to', 'ta', 'lars', 'ver',
+  'vin', 'ov', 'wal', 'ry', 'ly', ''];
 
 /* -------------------------------------------- */
 export class RdDNameGen {
 
-  static async getName( msg, params ) {
-    let name = Misc.upperFirst( await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words) )
-    //console.log(name);
-    ChatMessage.create( { content: `Nom : ${name}`, whisper: ChatMessage.getWhisperRecipients("GM") } );
+  static async getName(msg, params) {
+    const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
+      nom: Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words))
+    });
+    ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
   }
 
+  static async onCreerActeur(event) {
+    const button = event.currentTarget;
+    await RdDActor.create({
+        name: button.attributes['data-nom'].value,
+        type: button.attributes['data-type'].value
+      },
+      {renderSheet: true});
+  }
 }

module/rdd-roll-encaisser.js

@@ -1,3 +1,5 @@
+import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE } from "./constants.js";
+
 /**
  * Extend the base Dialog entity by defining a custom window to perform roll.
  * @extends {Dialog}
@@ -7,15 +9,19 @@ 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") },
-      "sonne": { label: "Sonné", callback: html => this.actor.setSonne() },
-    };
-    const buttonsEntitesCauchemar = {
-      "cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
-    };
-    const buttons = actor.isEntiteCauchemar() ? buttonsEntitesCauchemar : buttonsCreatures;
+    let buttons = {};
+    if (!actor.isEntite()){
+      buttons = {
+        "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() },
+      };
+    }
+    else if (actor.isEntite([ENTITE_BLURETTE, ENTITE_INCARNE])){
+      buttons = {
+        "cauchemar": { label: "cauchemar", callback: html => this.performEncaisser("cauchemar") }
+      }
+    }
 
     let dialogConf = {
       title: "Jet d'Encaissement",
@@ -24,7 +30,6 @@ export class RdDEncaisser extends Dialog {
       default: "mortel"
     }
 
-
     let dialogOptions = {
       classes: ["rdddialog"],
       width: 320,

module/rdd-utility.js

@@ -11,6 +11,7 @@ import { RdDDice } from "./rdd-dice.js";
 import { RdDItem } from "./item.js";
 import { Monnaie } from "./item-monnaie.js";
 import { RdDPossession } from "./rdd-possession.js";
+import { RdDNameGen } from "./rdd-namegen.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -704,6 +705,7 @@ export class RdDUtility {
 
     // gestion bouton tchat Acheter
     html.on("click", '.button-acheter', event => DialogItemAchat.onButtonAcheter(event));
+    html.on("click", '.button-creer-acteur', event => RdDNameGen.onCreerActeur(event));
 
     // Gestion du bouton payer
     html.on("click", '.payer-button', event => {

system.json

@@ -29,7 +29,7 @@
   "url": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/",
   "license": "LICENSE.txt",
   "flags": {},
-  "version": "1.5.82",
+  "version": "1.5.85",
   "minimumCoreVersion": "0.8.0",
   "compatibleCoreVersion": "9",
   "scripts": [],
@@ -500,7 +500,7 @@
   "dependencies": [],
   "socket": true,
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v1.5/system.json",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-1.5.82.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-1.5.85.zip",
   "protected": false,
   "gridDistance": 1,
   "gridUnits": "m",

templates/actor-entite-sheet.html

@@ -65,6 +65,7 @@
                 {{#select data.definition.typeentite}}
                 <option value="incarne">Incarnée</option>
                 <option value="nonincarne">Non Incarnée</option>
+                <option value="blurette">Blurete</option>
                 {{/select}}
               </select>
             </li>

templates/chat-command-nom.html

@@ -0,0 +1,16 @@
+
+<h4>Proposition de nom: {{nom}}</h4>
+<span class="chat-card-button-area">
+  <a class="button-creer-acteur chat-card-button"
+    data-nom='{{nom}}'
+    data-type='personnage'
+    >
+  Créer un Personnage</a>
+</span>
+<span class="chat-card-button-area">
+  <a class="button-creer-acteur chat-card-button"
+    data-nom='{{nom}}'
+    data-type='creature'>
+  Créer une créature</a>
+</span>
+