Méthode rollPossession pour attaque possession

- Ajout d'une méthode pour ouvrir le dialogue en mode possession
- gestion des information de possession
- fenêtre défense possession
- préparation des messages de tchat

module/roll/chat-roll-result.mjs

@@ -53,19 +53,19 @@ export default class ChatRollResult {
   prepareDisplay(roll) {
     roll.done = roll.done ?? {}
     roll.show = roll.show ?? {}
-    roll.show.chance = this.isAppelChancePossible(roll)
-    roll.show.encaissement = this.isShowEncaissement(roll)
-    roll.show.recul = this.getRecul(roll)
-    roll.show.maladresse = this.getMaladresse(roll)
+    roll.show.chance = this.$isAppelChancePossible(roll)
+    roll.show.encaissement = this.$isShowEncaissement(roll)
+    roll.show.recul = this.$getRecul(roll)
+    roll.show.maladresse = this.$getMaladresse(roll)
   }
 
-  isAppelChancePossible(roll) {
+  $isAppelChancePossible(roll) {
     return roll.active.actor.isPersonnage() &&
       roll.rolled.isEchec &&
       RdDCarac.isActionPhysique(roll.current.carac?.key)
   }
 
-  isShowEncaissement(roll) {
+  $isShowEncaissement(roll) {
     switch (roll.type.current) {
       case ROLL_TYPE_DEFENSE:
         return roll.rolled.isEchec
@@ -73,7 +73,7 @@ export default class ChatRollResult {
     return false
   }
 
-  getMaladresse(roll) {
+  $getMaladresse(roll) {
     switch (roll.type.current) {
       case ROLL_TYPE_DEFENSE:
         if (roll.rolled.isETotal) {
@@ -91,7 +91,7 @@ export default class ChatRollResult {
     return undefined
   }
 
-  getRecul(roll, defender = roll.active.actor, attacker = roll.opponent?.actor) {
+  $getRecul(roll, defender = roll.active.actor, attacker = roll.opponent?.actor) {
     switch (roll.type.current) {
       case ROLL_TYPE_DEFENSE:
         {
@@ -195,7 +195,6 @@ export default class ChatRollResult {
         this.getCombat(reRoll)?.doRollDefense(reRoll, callbacks)
         break
       case ROLL_TYPE_ATTAQUE:
-        // TODO
         this.getCombat(reRoll)?.doRollAttaque(reRoll, callbacks)
         break
       default: {

module/roll/roll-dialog.mjs

@@ -370,10 +370,11 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
 
 
   selectType() {
-    const selectedType = this.getSelectedType();
-    this.rollData.type.label = selectedType.title(this.rollData)
+    const selectedType = this.getSelectedType()
+    selectedType.prepare(this.rollData)
     selectedType.setRollDataType(this.rollData)
     selectedType.onSelect(this.rollData)
+    this.rollData.type.label = selectedType.title(this.rollData)
 
     ROLL_PARTS.find(it => it.code == PART_CARAC).filterCaracs(this.rollData)
     ROLL_PARTS.find(it => it.code == PART_COMP).filterComps(this.rollData)

module/roll/roll-part-possession.mjs

@@ -1,5 +1,6 @@
 import { CATEGORIES_COMPETENCES_CREATURES } from "../item/base-items.js"
 import { CARACS } from "../rdd-carac.js"
+import { RdDPossessionV2 } from "../rdd-possession-v2.mjs"
 import { ROLL_TYPE_POSSESSION } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
@@ -20,14 +21,11 @@ export class RollPartPossession extends RollPartSelect {
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
-    const selected = this.getSelected(rollData)
     refs.all = this.$getActorConjurations(rollData)
-    refs.isPersonnage = rollData.active.actor.isPersonnage()
-    refs.isENI = rollData.active.actor.isEntiteNonIncarnee()
-
     this.$selectPossession(rollData)
   }
 
+
   choices(refs) { return refs.all }
 
   $getActorConjurations(rollData) {
@@ -38,7 +36,7 @@ export class RollPartPossession extends RollPartSelect {
   static extractPossession(comp) {
     return {
       key: comp.id ?? comp.name,
-      label: `${comp.system.categorie == CATEGORIES_COMPETENCES_CREATURES.possession.key ? 'Possession': 'Conjuration'} (${comp.name})`,
+      label: `${comp.system.categorie == CATEGORIES_COMPETENCES_CREATURES.possession.key ? 'Possession' : 'Conjuration'} (${comp.name})`,
       value: comp.system.niveau,
       comp: comp
     }
@@ -47,18 +45,26 @@ export class RollPartPossession extends RollPartSelect {
   prepareContext(rollData) {
     this.$selectPossession(rollData)
   }
+
   getAjustements(rollData) {
     return []
   }
-  async _onRender(rollDialog, context, options) {
-    const select = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-possession"]`)
 
+  async _onRender(rollDialog, context, options) {
+    const rollData = rollDialog.rollData
+    const select = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-possession"]`)
+    const button = rollDialog.element.querySelector(`roll-section[name="${this.code}"] button[name="creer-possession"]`)
     select?.addEventListener("change", e => {
       const selectOptions = e.currentTarget.options
       const index = selectOptions.selectedIndex
-      this.$selectPossession(rollDialog.rollData, selectOptions[index]?.value)
+      this.$selectPossession(rollData, selectOptions[index]?.value)
       rollDialog.render()
     })
+    button?.addEventListener("click", async e => {
+        e.preventDefault()
+        await RdDPossessionV2.createPossession(rollData.active.actor, rollData.opponent.actor)
+        rollDialog.render()
+      })
   }
 
   $selectPossession(rollData, key) {
@@ -69,7 +75,7 @@ export class RollPartPossession extends RollPartSelect {
     if (this.visible(rollData)) {
       const current = this.getCurrent(rollData)
       switch (part.code) {
-        case PART_CARAC: return part.filterCaracs(rollData, [this.getRefs(rollData).isPersonnage ? CARACS.REVE_ACTUEL : CARACS.REVE])
+        case PART_CARAC: return part.filterCaracs(rollData, [rollData.type.possession.isPersonnage ? CARACS.REVE_ACTUEL : CARACS.REVE])
         case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
       }
     }

module/roll/roll-type-possession.mjs

@@ -1,33 +1,28 @@
+import { RdDPossessionV2 } from "../rdd-possession-v2.mjs"
 import { DIFF, ROLL_TYPE_POSSESSION } from "./roll-constants.mjs"
 import { RollType } from "./roll-type.mjs"
 
-
-export const TYPE_POSSESSION = {
-  POSSEDER: 'posseder',
-  CONJURER: 'conjurer',
-  DEFENSE: 'defense'
-}
 export class RollTypePossession extends RollType {
   get code() { return ROLL_TYPE_POSSESSION }
-  get name() { return `Posséder` }
+  get name() { return "Posséder" }
+
+  prepare(rollData) {
+    rollData.type.possession = RdDPossessionV2.getPossessionDetails(rollData, rollData.type.possession?.action)
+  }
 
   title(rollData) {
-    const isEntite = this.isEntite(rollData)
-    if (this.isDefense(rollData)) {
-      return `résiste à la ${isEntite ? 'conjuration' : 'possession'} de`
-    }
-    return `tente de ${isEntite ? 'posséder' : 'conjurer'}`
+    return RdDPossessionV2.actionTitle(rollData.type.possession.action)
   }
 
   onSelect(rollData) {
-    this.setDiffType(rollData, this.isDefense(rollData) ? DIFF.DEFENSE : DIFF.ATTAQUE)
+    this.setDiffType(rollData, this.isAttaque(rollData) ? DIFF.ATTAQUE : DIFF.DEFENSE)
   }
 
   isEntite(rollData) {
     return rollData.active.actor.isEntiteNonIncarnee()
   }
 
-  isDefense(rollData) {
-    return rollData.type.possession == TYPE_POSSESSION.DEFENSE
+  isAttaque(rollData) {
+    return RdDPossessionV2.isAttaque(rollData.type.possession.action)
   }
 }

module/roll/roll-type.mjs

@@ -16,6 +16,7 @@ export class RollType {
     return { code: this.code, name: this.name, icon: this.icon, section: 'type', template: this.template, selected: this.isSelected(rollData) }
   }
 
+  prepare(rollData){}
   isAllowed(rollData) { return rollData.type.allowed == undefined || rollData.type.allowed.includes(this.code) }
   visible(rollData) { return true }
   title(rollData) { return this.code }