fvtt-vadentis/modules/vadentis-actor.js

/* -------------------------------------------- */
import { VadentisUtility } from "./vadentis-utility.js";

/* -------------------------------------------- */
const MIN_PV = -50;
const MIN_PE = -50;

/* -------------------------------------------- */
/**
 * Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
 * @extends {Actor}
 */
export class VadentisActor extends Actor {

  /* -------------------------------------------- */
  /**
   * Override the create() function to provide additional SoS functionality.
   *
   * This overrided create() function adds initial items 
   * Namely: Basic skills, money, 
   *
   * @param {Object} data        Barebones actor data which this function adds onto.
   * @param {Object} options     (Unused) Additional options which customize the creation workflow.
   *
   */

  static async create(data, options) {

    // Case of compendium global import
    if (data instanceof Array) {
      return super.create(data, options);
    }
    // If the created actor has items (only applicable to foundry.utils.duplicated actors) bypass the new actor creation logic
    if (data.items) {
      let actor = super.create(data, options);
      return actor;
    }

    return super.create(data, options);
  }

  /* -------------------------------------------- */
  async prepareData() {
    super.prepareData();
  }

  /* -------------------------------------------- */
  getCompetences() {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'competence') || [] );
  }

  /* -------------------------------------------- */
  getDonnees()   {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'donnee')|| [] );
  }
  /* -------------------------------------------- */
  getEglises()   {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'eglise')|| [] );
  }
  /* -------------------------------------------- */
  getSorts() {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'sort')|| [] );
  }
  /* -------------------------------------------- */
  getAttributs() {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'attribut')|| [] );
  }
  /* -------------------------------------------- */
  getTechniques() {
    return foundry.utils.duplicate( this.items.filter( item => item.type == 'technique') || [] );
  }
  /* -------------------------------------------- */
  getDevotions() {
    return foundry.utils.duplicate(this.items.filter( item => item.type == 'devotion')|| [] );
  }
  /* -------------------------------------------- */
  getEquipements() {
    return  foundry.utils.duplicate(this.items.filter( item => item.type == 'equipement'  ) || [] );
  }
  /* -------------------------------------------- */
  getArmes() {
    return foundry.utils.duplicate(this.items.filter( item => item.type == 'armecc' || item.type == 'tir' ) || [] );
  }
  /* -------------------------------------------- */
  getArmures() {
    return foundry.utils.duplicate(this.items.filter( item => item.type == 'armurebouclier' ) || [] );
  }
  /* -------------------------------------------- */
  getMonnaies() {
    return foundry.utils.duplicate(this.items.filter( item => item.type == 'monnaie' ) || [] );
  }
  
  /* -------------------------------------------- */
  async updateCompetence( name, field, value) {
    let competence = this.items.find( item => item.type == 'competence' && item.name == name);
    if (competence) {
      let dataPath = 'system.'+field;
      await this.updateEmbeddedDocuments( "Item", [{ _id: competence.id, [dataPath]:value }] );
    }
  }
  
  /* -------------------------------------------- */
  async equiperObject( equipementId ) {    
    let item = this.items.get(equipementId)
    if (item) {
      let update = { _id: item.id, "system.equipee": !item.system.equipee };
      await this.updateEmbeddedDocuments("Item", [ update ] );
    }
  }

  /* -------------------------------------------- */
  buildListeActionsCombat( ) {
    let armes = [];

  }
  
  /* -------------------------------------------- */
  calculerSommeStats( ) {
    for (const key in this.system.combat) {
      let combatData  = this.system.combat[key];
      combatData.total = combatData.base + combatData.malus + combatData.bonus;      
    }
    for (const key in this.system.magie) {
      let magieData  = this.system.magie[key];
      magieData.total = magieData.base + magieData.malus + magieData.bonus;      
    }
  }

  /* -------------------------------------------- */
  async processSortDevotion( name, devotionSort ) {
    if ( this.system.stats.pointsenergie.value == 0) { // Vérification du ~ de points d'énergie
      ChatMessage.create({ content: `${this.name} n'a pas assez de Points d'Energie pour lancer ${name} ${devotionSort.name}` } );        
      return;
    }
    
    let scores = this.system.magie[(name =="devotion") ? 'devotion': 'matriseelementaire'];
    let statValue = scores.base + scores.malus + scores.bonus;
    let formulaFull = this.buildTexteFormula( scores );
    let myRoll = await VadentisUtility.processRoll("1d20+"+statValue );
    let msgData = {
      alias: this.name, 
      title: `Sort ${devotionSort.name}`,
      isSort: true
    }

    if (myRoll.dice[0].results[0].result > 1 && myRoll.total >= devotionSort.system.difficulty) {
      msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_sort_réussi.webp';
      msgData.msg =  `${this.name} a réussi son ${name} et perd ${devotionSort.system.pe} Points d'Energie (lancer : ${formulaFull} => <strong>${myRoll.total} / ${devotionSort.system.difficulty}</strong>).`;  

      //DEPRECATED : let maintain = (devotionSort.system.ismaintain)?"Oui":"Non";
      //DEPRECATED : let complex  = (devotionSort.system.complexactions)?"Oui":"Non";
      //DEPRECATED : msgData.msg += `<br>Peut être maintenu: ${maintain}<br>Actions complexes : ${complex}`;
      if ( !devotionSort.system.notes)  devotionSort.system.notes  = "";
      msgData.msg += `<br><strong>Description : </strong>${devotionSort.system.notes.replace(/<\/?[^>]+(>|$)/g, "")}`;

      let newEnergie = this.system.stats.pointsenergie.value - devotionSort.system.pe;
      await this.update( {'system.stats.pointsenergie.value': newEnergie });
      if (myRoll.dice[0].results[0].result >= devotionSort.system.valuecritical ) { // Critique ?
        msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_réussite_critique.webp';
        msgData.msg += "<br>C'est une <strong>réussite critique</strong> !";
        msgData.msg += `<br><strong>Effet critique : </strong>${devotionSort.system.criticaleffect.replace(/<\/?[^>]+(>|$)/g, "")}`;
      } else {
        msgData.msg += `<br><strong>Effet : </strong>${devotionSort.system.effect.replace(/<\/?[^>]+(>|$)/g, "")}`;
      }

      if ( devotionSort.system.damage != "") {
        let formula = devotionSort.system.damage;
        if (myRoll.dice[0].results[0].result >= devotionSort.system.valuecritical ) { // Critique ?
          msgData.msg += `<br>Et provoque les dégats critiques suivants : [[/roll ${devotionSort.system.damagecritical}]]`;
          formula = devotionSort.system.damagecritical;
        } else {
          msgData.msg += `<br>Et provoque les dégats suivants : [[/roll ${devotionSort.system.damage}]]`;
        }
      }
      if ( newEnergie < 0) {
        msgData.msg += `<br><strong>Attention</strong> : Les Points d'Energie de ${this.name} sont négatifs ! Il convient d'éditer ses Points de Vie en conséquence.`;
      }
    } else {
      msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_sort_échoué.webp';
      if (myRoll.dice[0].results[0].result == 1 ) { // Critique ?
        msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_échec_critique.webp';
        msgData.msg = `${this.name} a fait un <strong>échec critique</strong> à son lancer de ${name}`;
      } else {
        msgData.msg = `${this.name} a échoué son lancer de ${name}`;
      }
    }
    console.log(devotionSort.system.description, msgData);
    ChatMessage.create({
      //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
    });
}

  /* -------------------------------------------- */
  async rollDamage( weapon, damageType ) {
    let formula = VadentisUtility.processDamageString( weapon.system[damageType], this );
    let degatsRoll = await VadentisUtility.processRoll( formula );
    let msgData = {
      alias: this.name, 
      img: "systems/foundryvtt-vadentis/images/icons/tchat_dégâts_infligés.webp",
      title: `Dégâts de ${weapon.name}`,
      msg: `${this.name} frappe avec ${weapon.name} et produit <strong>${degatsRoll.total} Points de Dégâts</strong> (${formula}).`
    }
    ChatMessage.create({
      //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
    });
  }

  /* -------------------------------------------- */
  async rollSortDevotionDamage( sort, damageType ) {
    let formula = VadentisUtility.processDamageString( sort.system[damageType], this );
    let degatsRoll = await VadentisUtility.processRoll( formula );
    let msgData = {
      alias: this.name, 
      img: "systems/foundryvtt-vadentis/images/icons/tchat_dégâts_infligés.webp",
      title: `Dégâts de ${sort.name}`,
      msg: `Le sort ${sort.name} produit <strong>${degatsRoll.total} Points de Dégâts</strong> (${formula}).`
    }
    ChatMessage.create({
      //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
    });
  }

  
  /* -------------------------------------------- */
  async applyDamage( damageValue ) {
    let pvData = this.system.stats.pointsvie;
    let newValue = Math.max( pvData.value - damageValue, MIN_PV);
    await this.update( {'system.stats.pointsvie.value': newValue });

    let msgData = {
      alias: this.name, 
      img: "systems/foundryvtt-vadentis/images/icons/tchat_dégâts_infligés.webp",
      title: `${this.name} encaisse des dégâts !`,
      msg: `${this.name} encaisse ${damageValue} dégâts !`      
    }

    ChatMessage.create({
      //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
    });
    
    if ( game.user.isGM) {
      msgData.msg = `<br>Ses Points de Vie actuels sont désormais de ${newValue}.`;
      ChatMessage.create({
        whisper: ChatMessage.getWhisperRecipients( 'GM'),
        content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
      });
    }
  }

  /* -------------------------------------------- */
  _getCombatValue(mydata) {
    if ( typeof mydata.base == 'number' ) {
      return mydata.base + mydata.malus + mydata.bonus;
    } else {
      return Number(mydata.base[0]) + Number(mydata.malus[0]) + Number(mydata.bonus[0]);
    }
  }

  /* -------------------------------------------- */
  getInitiativeScore(  ) {
    let initData = this.system.combat.initiative;
    return this._getCombatValue( initData);
  }
  /* -------------------------------------------- */
  getDefenseScore(  ) {
    let defenseData = this.system.combat.defense;
    return this._getCombatValue( defenseData);
  }
  /* -------------------------------------------- */
  getForceScore(  ) {
    let forceData = this.system.combat.force;
    return this._getCombatValue( forceData);
  }
  /* -------------------------------------------- */
  getAttaqueScore(  ) {
    let attaqueData = this.system.combat.attaque;
    return this._getCombatValue( attaqueData);
  }

  /* -------------------------------------------- */
  buildTexteFormula( stat) {
    let signMalus = (stat.malus < 0) ? "" : "+";
    return `1d20+ ${stat.base} ${signMalus} ${stat.malus} + ${stat.bonus}`;
  }

  /* -------------------------------------------- */
  async rollSort( sortId ) {
    let sort = this.items.get( sortId );
    if ( sort ) {
      sort = foundry.utils.duplicate(sort)
      this.processSortDevotion( "sort", sort);
    }
  }

  /* -------------------------------------------- */
  async rollDevotion( devotionId ) {
    let devotion = this.items.get( devotionId );
    if ( devotion ) {
      devotion = foundry.utils.duplicate(devotion)
      this.processSortDevotion( "devotion", devotion);
    }
  }

  /* -------------------------------------------- */
  rollSortOuDevotion( sortId ) {
    let sort = this.items.get( sortId );
    this.processSortDevotion( sort.type, sort);
  }


  /* -------------------------------------------- */
  async rollTechnique( techniqueId ) {
    let technique = this.items.get( techniqueId )
    if (technique) {
      technique = foundry.utils.duplicate(technique)
      let msgData = {
        alias: this.name, 
        img: technique.img,
        title: `Technique ${technique.name}` 
      }
      if ( this.system.stats.pointsadrenaline.value < technique.system.pacost) { // Vérification du ~ de points d'adrénaline
        msgData.msg = `${this.name} n'a pas assez de Points d'Adrénaline pour éxecuter sa technique ${technique.name}`;
      } else {
        let newAdrenaline = this.system.stats.pointsadrenaline.value - technique.system.pacost;
        await this.update( {'system.stats.pointsadrenaline.value': newAdrenaline });
        msgData.msg = `${this.name} execute sa technique ${technique.name}, pour un côut de ${technique.system.pacost} Points d'Adrénaline<br>
            Les effets sont : ${technique.system.effect}`;
      }
      ChatMessage.create({
        //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
        content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
      });
    } else {
      ui.notifications.warn("Technique non trouvée");
    }
  }

  /* -------------------------------------------- */
  async rollCompetence( competenceId ) {
    console.log(competenceId)
    let competence = this.items.get( competenceId);
    if ( competence) {
      competence = foundry.utils.duplicate(competence)
      let msgData = {
        alias: this.name, 
        img: competence.img,
        rollMode: game.settings.get("core", "rollMode"),
        title: `Compétence ${competence.name}` 
      }

      let statValue = competence.system.base + competence.system.malus + competence.system.bonus;
      let formulaFull = this.buildTexteFormula( competence.system );
      let myRoll = await VadentisUtility.processRoll("1d20+"+statValue, msgData.rollMode );
      msgData.msg = `${formulaFull} => <strong>${myRoll.total}</strong>`; 
      console.log(formulaFull, myRoll)

      if (myRoll.dice[0].results[0].result == 1 ) { // Critique ?
        msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_échec_critique.webp';
        msgData.msg += `<br>C'est un <strong>échec critique</strong> !`;
      }
      if (myRoll.dice[0].results[0].result == 20 ) { // Critique ?
        msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_réussite_critique.webp';
        msgData.msg += `<br>C'est une <strong>réussite critique</strong> !`;
      }

      if (["gmroll", "blindroll"].includes(msgData.rollMode)) msgData["whisper"] = ChatMessage.getWhisperRecipients("GM").map(u => u.id);
      if (msgData.rollMode === "blindroll") msgData["blind"] = true;
      else if (msgData.rollMode === "selfroll") msgData["whisper"] = [game.user];
  
      ChatMessage.create({
        whisper: msgData["whisper"],
        content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
      });
    } else {
      ui.notifications.warn("Compétence non trouvée");
    }
  }

  /* -------------------------------------------- */
  async genericRoll( stat, key ) {
    let statValue = this._getCombatValue( stat );
    let formulaFull = this.buildTexteFormula( stat );
  
    let myRoll = await VadentisUtility.processRoll("1d20+"+statValue );
    let msgData = {
      alias: this.name, 
      img: `systems/foundryvtt-vadentis/images/icons/feuille_perso_${key}.webp`,
      title: VadentisUtility.buildJetText( stat),
      msg: `${formulaFull} => <strong>${myRoll.total}</strong>` 
    }

    if (myRoll.dice[0].results[0].result == 1 ) { // Critique ?
      msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_échec_critique.webp';
      msgData.msg += `<br>C'est un <strong>échec critique</strong> !`;
    }
    if (myRoll.dice[0].results[0].result == 20 ) { // Critique ?
      msgData.img = 'systems/foundryvtt-vadentis/images/icons/tchat_réussite_critique.webp';
      msgData.msg += `<br>C'est une <strong>réussite critique</strong> !`;
    }

    ChatMessage.create({
      //whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-vadentis/templates/chat-generic-result.html`, msgData)
    });
  }

  /* -------------------------------------------- */
  async rollCombat( combatName ) {
    let stat = this.system.combat[combatName];
    this.genericRoll( stat, combatName );
}

  /* -------------------------------------------- */
  rollMagie( magieName ) {
    let stat = this.system.magie[magieName];
    this.genericRoll( stat, magieName );
  }

  /* -------------------------------------------- */
  async incrementeArgent( arme ) {
    let monnaie = this.items.find( item => item.type == 'monnaie' && item.name == arme.name);
    if (monnaie) {
      monnaie = foundry.utils.duplicate(monnaie)
      let newValeur = monnaie.system.nombre + 1;
      await this.updateEmbeddedDocuments( 'Item', [{ _id: monnaie._id, 'system.nombre': newValeur }] );
    }
  }
  /* -------------------------------------------- */
  async decrementeArgent( arme ) {
    let monnaie = this.items.find( item => item.type == 'monnaie' && item.name == arme.name);
    if (monnaie) {
      monnaie = foundry.utils.duplicate(monnaie)
      let newValeur = monnaie.system.nombre - 1;
      newValeur = (newValeur <= 0) ? 0 : newValeur;
      await this.updateEmbeddedDocuments( "Item", [{ _id: monnaie._id, 'system.nombre': newValeur }] );
    }
  }
  
  /* -------------------------------------------- */
  async incrementeMunition( arme ) {
    let armeTir = this.items.find( item => item.type == 'tir' && item.name == arme.name);
    if (armeTir) {
      armeTir = foundry.utils.duplicate(armeTir)
      let newMunition = armeTir.system.munition + 1;
      await this.updateEmbeddedDocuments( "Item", [{ _id: armeTir._id, 'system.munition': newMunition }] );
    }
  }
  /* -------------------------------------------- */
  async decrementeMunition( arme ) {
    let armeTir = this.items.find( item => item.type == 'tir' && item.name == arme.name);
    if (armeTir) {
      armeTir = foundry.utils.duplicate(armeTir)
      let newMunition = armeTir.system.munition - 1;
      newMunition = (newMunition <= 0) ? 0 : newMunition;
      await this.updateEmbeddedDocuments( "Item", [{ _id: armeTir._id, 'system.munition': newMunition } ]);
    }
  }

  /* -------------------------------------------- */
  async incrementeQuantite( objet ) {
    let objetQ = this.items.find( item => item._id == objet._id );
    if (objetQ) {
      objetQ = foundry.utils.duplicate(objetQ)
      let newQ = objetQ.system.quantite + 1;
      await this.updateEmbeddedDocuments( "Item", [{ _id: objetQ._id, 'system.quantite': newQ } ] );
    }
  }
  
  /* -------------------------------------------- */
  async decrementeQuantite( objet ) {
    let objetQ = this.items.find( item => item._id == objet._id );
    if (objetQ) {
      objetQ = foundry.utils.duplicate(objetQ)
      let newQ = objetQ.system.quantite - 1;
      newQ = (newQ <= 0) ? 0 : newQ;
      await this.updateEmbeddedDocuments( "Item", [{ _id: objetQ._id, 'system.quantite': newQ } ]);
    }
  }
  
  /* -------------------------------------------- */
  rollArme(armeId) {
    let target = VadentisUtility.getTarget();

    if ( target ) {
      let arme = this.items.find( item => (item.type == 'armecc' || item.type == 'tir') && item.id == armeId);
      if (arme) {
        arme = foundry.utils.duplicate(arme)
        if ( arme.type == 'tir' && arme.system.munition <= 0 ) {
          ui.notifications.warn("Vous n'avez plus de munitions avec cette arme.");
          return;
        }
        let combatData = { 
          attackerActorId: this.id,
          targetActorId: target.actor.id,
          arme: foundry.utils.duplicate(arme) 
        }
        if (game.user.isGM) {
          VadentisUtility.performAttack( combatData);
        } else {
          game.socket.emit("system.foundryvtt-vadentis", { name: "msg_attack", data: combatData } );
        }
      }
    } else {
      ui.notifications.warn("Vous devez désigner une cible pour attaquer avec une arme.")
    }
  }
  
}