Comptence de creatures

Reviewed-on: public/foundryvtt-reve-de-dragon#668

changelog.md

@@ -1,4 +1,15 @@
 # v11.0
+## v11.0.21
+- Macro pour attaquer avec les compétences de créatures
+
+## v11.0.20
+- Macro pour attaquer avec les armes des personnages
+
+## v11.0.17
+- Fix: les actions de commerce ne s'appliquait pas bien aux personnages des tokens non liés
+
+## v11.0.15 - L'apprentissage de Khrachtchoum
+- Fix: l'expérience ne s'appliquait plus sur certaines réussites particulières (régression depuis la 11.0.7)
 
 ## v11.0.14 - Les pincettes de Khrachtchoum le Problémeux
 - Correction du calcul de la place restante lors de l'ajout dans un conteneur

module/actor.js

@@ -265,7 +265,7 @@ export class RdDActor extends RdDBaseActor {
   }
   /* -------------------------------------------- */
   getDraconicList() {
-    return this.items.filter(it => it.isCompetencePersonnage() && it.system.categorie == 'draconic')
+    return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic')
   }
   /* -------------------------------------------- */
   getBestDraconic() {
@@ -275,13 +275,13 @@ export class RdDActor extends RdDBaseActor {
   }
 
   getDraconicOuPossession() {
-    const possession = this.items.filter(it => it.type == TYPES.competencecreature && it.system.categorie == 'possession')
+    const possession = this.itemTypes[TYPES.competencecreature].filter(it => it.system.categorie == 'possession')
       .sort(Misc.descending(it => it.system.niveau))
       .find(it => true);
     if (possession) {
-      return possession.clone();
+      return possession;
     }
-    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0).map(it => it.clone()),
+    const draconics = [...this.getDraconicList().filter(it => it.system.niveau >= 0),
       POSSESSION_SANS_DRACONIC]
       .sort(Misc.descending(it => it.system.niveau));
     return draconics[0];
@@ -1741,6 +1741,7 @@ export class RdDActor extends RdDBaseActor {
   async consommerNourritureboisson(itemId, choix = { doses: 1, seForcer: false, supprimerSiZero: false }, userId = undefined) {
     if (userId != undefined && userId != game.user.id) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'consommerNourritureboisson',
         args: [itemId, choix, userId]
@@ -3070,29 +3071,43 @@ export class RdDActor extends RdDBaseActor {
   }
 
   /* -------------------------------------------- */
-  rollArme(arme) {
+  getArmeCompetence(arme, competenceName) {
+    let comp = arme.system[competenceName]
+    if (!comp || comp.name == "") {
+      comp = arme.system[competenceName]
+    }
+    if ( !comp || comp.name == "") {
+      comp = arme.system[competenceName]
+    }
+    return comp
+  }
+
+  /* -------------------------------------------- */
+  rollArme(arme, competenceName = "competence") {
+    let compToUse = this.getArmeCompetence(arme, competenceName)
     if (!Targets.hasTargets()) {
       RdDConfirm.confirmer({
         settingConfirmer: "confirmer-combat-sans-cible",
-        content: `<p>Voulez vous faire un jet de compétence ${arme.system.competence} sans choisir de cible valide?
+        content: `<p>Voulez vous faire un jet de compétence ${competenceName} sans choisir de cible valide?
                   <br>Tous les jets de combats devront être gérés à la main
                   </p>`,
         title: 'Ne pas utiliser les automatisation de combat',
         buttonLabel: "Pas d'automatisation",
         onAction: async () => {
-          this.rollCompetence(arme.system.competence, { tryTarget: false })
+          this.rollCompetence(compToUse, { tryTarget: false })
         }
       });
       return;
     }
+
     Targets.selectOneToken(target => {
       if (Targets.isTargetEntite(target)) {
         ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
         return;
       }
 
-
-      const competence = this.getCompetence(arme.system.competence)
+      const competence = this.getCompetence(compToUse)
+      //console.log("RollArme", competence, arme)
       if (competence.isCompetencePossession()) {
         return RdDPossession.onAttaquePossession(target, this, competence);
       }
@@ -3121,7 +3136,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollTachePremiersSoins(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollTachePremiersSoins', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     console.log('TODO update blessure', this, blessureId, rollData, rollData.tache);
@@ -3151,7 +3166,7 @@ export class RdDActor extends RdDBaseActor {
 
   async onRollSoinsComplets(blessureId, rollData) {
     if (!this.isOwner) {
-      return RdDBaseActor.remoteActorCall({ actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
+      return RdDBaseActor.remoteActorCall({ tokenId: this.token?.id, actorId: this.id, method: 'onRollSoinsComplets', args: [blessureId, rollData] });
     }
     const blessure = this.getItem(blessureId, 'blessure')
     if (blessure && blessure.system.premierssoins.done && !blessure.system.soinscomplets.done) {
@@ -3245,6 +3260,7 @@ export class RdDActor extends RdDBaseActor {
     const attackerId = attacker?.id;
     if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'appliquerEncaissement',
         args: [rollData, show, attackerId]

module/actor/base-actor.js

@@ -50,7 +50,13 @@ export class RdDBaseActor extends Actor {
 
   static onRemoteActorCall(callData, userId) {
     if (userId == game.user.id) {
-      const actor = game.actors.get(callData?.actorId);
+      let actor = game.actors.get(callData?.actorId);
+      if ( callData.tokenId) {
+        let token = canvas.tokens.placeables.find(t => t.id == callData.tokenId)
+        if (token) {
+          actor = token.actor
+        }
+      }
       if (Misc.isOwnerPlayerOrUniqueConnectedGM(actor)) { // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
         const args = callData.args;
         console.info(`RdDBaseActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDBaseActor.${callData.method}(`, ...args, ')');
@@ -147,6 +153,7 @@ export class RdDBaseActor extends Actor {
   async creerObjetParMJ(object) {
     if (!Misc.isUniqueConnectedGM()) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'creerObjetParMJ',
         args: [object]
@@ -220,6 +227,7 @@ export class RdDBaseActor extends Actor {
     if (fromActorId && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
         userId: Misc.connectedGMOrUser(),
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'ajouterSols', args: [sols, fromActorId]
       });

module/dialog-chronologie.js

@@ -114,7 +114,7 @@ export class DialogChronologie extends Dialog {
         heure: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.heure']").val()),
         minute: this.html.find("form.rdddialogchrono :input[name='chronologie.minute']").val(),
       },
-      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val()
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
     }
   }
 

module/rdd-combat.js

@@ -789,7 +789,7 @@ export class RdDCombat {
     let rollData = {
       passeArme: randomID(16),
       mortalite: arme?.system.mortalite,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       targetToken: Targets.extractTokenData(this.target),
@@ -1044,7 +1044,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: this.defender.getCompetence(competenceParade).clone(),
+      competence: this.defender.getCompetence(competenceParade),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
       needParadeSignificative: ReglesOptionnelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
@@ -1125,7 +1125,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.defender.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       carac: this.defender.system.carac,

module/rdd-empoignade.js

@@ -181,7 +181,7 @@ export class RdDEmpoignade {
     let rollData = {
       mode, empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone(),
+      competence: attacker.getCompetence("Corps à corps"),
       selectedCarac: attacker.system.carac.melee,
       malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
     }
@@ -210,7 +210,7 @@ export class RdDEmpoignade {
       mode: "immobilise",
       empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone()
+      competence: attacker.getCompetence("Corps à corps")
     }
     const msg = await ChatMessage.create({
       whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
@@ -272,7 +272,7 @@ export class RdDEmpoignade {
       mode, attacker, defender, empoignade, attackerRoll,
       diffLibre: attackerRoll.diffLibre,
       attaqueParticuliere: attackerRoll.particuliere,
-      competence: defender.getCompetence(competenceName).clone(),
+      competence: defender.getCompetence(competenceName),
       surprise: defender.getSurprise(true),
       carac: defender.system.carac,
       selectedCarac: defender.system.carac[carac],

module/rdd-hotbar-drop.js

@@ -1,8 +1,9 @@
+import { TYPES } from "./item.js";
 
 export class RdDHotbar {
 
-  static async addToHotbar(item, slot) {
-    let command = `game.system.rdd.RdDHotbar.rollMacro("${item.name}", "${item.type}");`;
+  static async createItemMacro(item, slot, armeCompetence = undefined) {
+    let command = `game.system.rdd.RdDHotbar.rollMacro("${item.name}", "${item.type}"` + ((armeCompetence) ? `, "${armeCompetence}");` : `);`);
     let macro = game.macros.contents.find(m => (m.name === item.name) && (m.command === command));
     if (!macro) {
       macro = await Macro.create({
@@ -15,6 +16,33 @@ export class RdDHotbar {
     await game.user.assignHotbarMacro(macro, slot);
   }
 
+  static async addToHotbar(item, slot) {
+    switch (item?.type ?? "") {
+      case TYPES.arme:
+        {
+          // Les armes peuvent avoir plusieurs usages
+          if (item.system.competence != "") {
+            await this.createItemMacro(item, slot, "competence")
+            slot++
+          }
+          if (item.system.lancer != "") {
+            await this.createItemMacro(item, slot, "lancer")
+            slot++
+          }
+          if (item.system.tir != "") {
+            await this.createItemMacro(item, slot, "lancer")
+            slot++
+          }
+        }
+        return
+      case TYPES.competence:
+      case TYPES.competencecreature:
+      default:
+        await this.createItemMacro(item, slot)
+        return
+    }
+  }
+
   /**
    * Create a macro when dropping an entity on the hotbar
    * Item      - open roll dialog for item
@@ -27,16 +55,16 @@ export class RdDHotbar {
 
       // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
       if (documentData.type == "Item") {
-        let item = fromUuidSync(documentData.uuid)
-        if (item == undefined) {
-          item = this.actor.items.get(documentData.uuid)
-        }
+        const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
         console.log("DROP", documentData, item)
-        if (!item || (item.type != "arme" && item.type != "competence")) {
-          return true
+        switch (item?.type ?? "")
+        {
+          case TYPES.arme:
+          case TYPES.competence:
+          case TYPES.competencecreature:
+            this.addToHotbar(item, slot)
+            return false
         }
-        this.addToHotbar(item, slot)
-        return false
       }
 
       return true
@@ -44,12 +72,14 @@ export class RdDHotbar {
   }
 
   /** Roll macro */
-  static rollMacro(itemName, itemType, bypassData) {
+  static rollMacro(itemName, itemType, competenceName) {
     const speaker = ChatMessage.getSpeaker();
     let actor;
     if (speaker.token) actor = game.actors.tokens[speaker.token];
     if (!actor) actor = game.actors.get(speaker.actor);
-
+    if (!actor) {
+      return ui.notifications.warn(`Impossible de trouver le personnage concerné`);
+    }
     let item = actor?.items.find(it => it.name === itemName && it.type == itemType) ?? undefined;
     if (!item) {
       return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
@@ -57,9 +87,10 @@ export class RdDHotbar {
 
     // Trigger the item roll
     switch (item.type) {
-      case "arme":
-        return actor.rollArme(item);
-      case "competence":
+      case TYPES.arme:
+        return actor.rollArme(item, competenceName);
+      case TYPES.competence:
+      case TYPES.competencecreature:
         return actor.rollCompetence(itemName);
     }
   }

module/rdd-possession.js

@@ -39,7 +39,7 @@ export class RdDPossession {
     let rollData = {
       mode: "attaque",
       isECNIDefender: false,
-      competence: competence.clone(),
+      competence: competence,
       possession: possession,
       attacker: attacker,
       defender: defender,

module/time/rdd-calendrier.js

@@ -106,11 +106,6 @@ export class RdDCalendrier extends Application {
     return buttons
   }
 
-  /*async maximize() {
-    await super.maximize()
-    this.render(true)
-  }*/
-
   async close() { }
 
   async onUpdateSetting(setting, update, options, id) {

system.json

@@ -1,14 +1,13 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "11.0.14",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.0.14.zip",
+  "version": "11.0.22",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.0.22.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
     "minimum": "11",
-    "verified": "11",
-    "maximum": "11"
+    "verified": "11"
   },
   "description": "Rêve de Dragon RPG for FoundryVTT",
   "authors": [

templates/chat-info-appel-au-moral.html

@@ -1,6 +1,6 @@
 {{#if use.moral}}
 <span>
-  Vous avez fait appel {{#if (gt moral 0)}}au moral{{else}}à l'énergie du déspoir{{/if}}
+  Vous avez fait appel {{#if (gt moral 0)}}au moral{{else}}à l'énergie du désespoir{{/if}}
   {{#if (eq perteMoralEchec 'dissolution')}}et échoué, cous marquez un point de dissolution!.
   {{else if (eq perteMoralEchec 'perte')}}et échoué, votre moral baisse à {{moral}}.
   {{else}}et réussi, votre moral reste de {{moral}}.