fvtt-pegasus-rpg/modules/pegasus-create-char.js

import { PegasusUtility } from "./pegasus-utility.js";
import { PegasusActor } from "./pegasus-actor.js";
import { PegasusActorSheet } from "./pegasus-actor-sheet.js";
import { PegasusItemSheet } from "./pegasus-item-sheet.js";

export class PegasusActorCreate {

  /* -------------------------------------------- */
  async start() {
    this.actor = await Actor.create({
      name: "New Actor",
      type: "character"
    });
    this.actor.sheet.render(true)
    
    this.actor.computeValue = true // To force value computation
    
    const racesPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.race")
    this.races = racesPack.map(i => i.toObject())
    const rolesPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.role")
    this.roles = rolesPack.map(i => i.toObject())
    const perksPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.perk")
    this.perks = perksPack.map(i => i.toObject())
    const specPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.specialisations")
    this.specs = specPack.map(i => i.toObject())

    this.showRaces()
  }

  /* -------------------------------------------- */
  createFormData(step) {
    let formData = {
      name: this.actor.name,
      img: this.actor.img,
      step: step,
      races: this.races,
      roles: this.roles,
      nboptionnal: this.raceOptionnalAbilities?.nboptionnal?? 0,
      optionnalabilities: this.raceOptionnalAbilities?.optionnalabilities?? [], 
    }
    if ( this.raceSelectableStats ) {
      formData.numberstats = this.raceSelectableStats.numberstats;
      formData.statsonlyonce = this.raceSelectableStats.statsonlyonce;
      formData.stats = this.raceSelectableStats.stats;
    }
    return formData;
  }

  /* -------------------------------------------- */
  getSpecFromRoleStat( role)  {
    let specList = []
    for(let stat of role.system.statincreasechoice) {
      if (stat.flag) {
        specList = specList.concat( this.specs.filter( spec => spec.system.statistic.toLowerCase() == stat.name.toLowerCase() ))
      }
    }
    return specList
  }

  /* -------------------------------------------- */
  getPerksFromRole( role ) {
    let perks = this.perks.filter( perk => perk.system.category.toLowerCase() == role.system.perksrole.toLowerCase())
    return perks
  }

  /* -------------------------------------------- */
  processChatEvent( event ) {
    const step = $(event.currentTarget).data("step-name");
    const itemId = $(event.currentTarget).data("item-id");

    if ( step == "select-race") {
      let race = this.races.find( item => item._id == itemId);
      this.currentRace = race;
      this.actor.applyRace( race);
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      if ( race.system.nboptionnal > 0 && race.system.optionnalabilities.length > 0) {
        this.manageOptionnalAbilities(race);
      } else {
        if ( race.system.selectablestats ) {
          this.manageSelectableStats(race);
        } else if ( race.system.perksgained) {
          this.manageRacePerks(race);
        } else {
          this.showRoles()
        }
      }
    }

    if ( step == 'select-race-optionnal') {
      let ability = this.raceOptionnalAbilities.optionnalabilities.find( item => item._id == itemId);
      let update = []
      this.actor.applyAbility( ability, update );
      this.actor.update( update )
      this.actor.createEmbeddedDocuments( 'Item', [ability]);
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      this.raceOptionnalAbilities.optionnalabilities = this.raceOptionnalAbilities.optionnalabilities.filter( item => item._id != itemId);
      this.raceOptionnalAbilities.nboptionnal -= 1;
      this.processOptionnalAbilitiesStep();
    }

    if (step == 'select-race-stats') {
      let statKey = $(event.currentTarget).data("stat-key");
      this.actor.modStat( statKey, 1);
      this.raceSelectableStats.stats[statKey].used = true;
      this.raceSelectableStats.numberstats -=1;
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      this.processSelectableStats();
    }

    if (step == 'select-race-perks') {
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      let perk = this.racePerks.find( item => item._id == itemId);
      this.actor.createEmbeddedDocuments( 'Item', [perk]);
      this.racePerks = this.racePerks.filter( item => item._id != itemId);
      this.nbRacePerks -= 1;
      if ( this.nbRacePerks == 0 || this.racePerks.length == 0) {
        this.showRoles()
      } else  {
        this.manageRacePerks()
      }        
    }

    if ( step == 'select-role') {
      let role = this.roles.find( item => item._id == itemId);
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      this.actor.applyRole( role );
      this.currentRole = role;
      this.nbRoleStat = 2;
      this.roleStats = duplicate(role.system.statincreasechoice)
      this.showRoleStartSpec( );
    }

    if ( step == 'select-role-start-spec') {
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      let spec = this.roleSpecStart.find( item => item._id == itemId);
      this.actor.addIncSpec(spec, 1);
      this.nbRoleSpecStart--;
      this.roleSpecStart = this.roleSpecStart.filter( item => item._id != itemId);//Remove selected spec
      if( this.nbRoleSpecStart == 0) {
        this.showRoleStat( );
      } else {
        this.showRoleStartSpec( );
      }
    }

    if ( step == 'select-role-stat') {
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      let statKey = $(event.currentTarget).data("stat-key");
      this.actor.valueStat( statKey, 1);

      for (let stat of this.roleStats ) {
        if ( stat.name.toLowerCase() == statKey.toLowerCase()) {
          stat.flag = false
        }
      }
      this.nbRoleStat--;
      if ( this.nbRoleStat == 0 || this.roleStats.length == 0) {
        this.roleSpec = this.getSpecFromRoleStat( this.currentRole )
        this.nbDT2 = 1;
        this.nbDT1 = 2;
        this.showRoleSpecialisations()
      } else{
        this.showRoleStat( );
      }
    }

    if (step == 'select-role-spec') {
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      let spec = this.roleSpec.find( item => item._id == itemId);
      if (this.nbDT2 > 0) {
        this.actor.addIncSpec(spec, 2)
        this.nbDT2--;
      } else {
        this.actor.addIncSpec(spec, 1)
        this.nbDT1--;
      }
      this.roleSpec = this.roleSpec.filter( item => item._id != itemId);//Remove selected spec
      if ( this.nbDT1 == 0 || this.roleSpec.length == 0) {
        this.rolePerks =  this.getPerksFromRole( this.currentRole ) // duplicate(this.currentRole.data.perks)
        this.nbPerks = 2;
        this.showRolePerks()
      } else {
        this.showRoleSpecialisations()
      }
    }

    if (step == 'select-role-perk') {
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      let perk = this.rolePerks.find( item => item._id == itemId);
      this.actor.addItemWithoutDuplicate(perk)
      this.nbPerks--;
      this.rolePerks = this.rolePerks.filter( item => item._id != itemId);//Remove selected perk
      if (this.nbPerks == 0 || this.rolePerks.length == 0) {
        this.showCharacterEnd()
      } else {
        this.showRolePerks()
      }
    }
  }

  /* -------------------------------------------- */  
  async openItemView( event) {
    let step = $(event.currentTarget).data("step");
    let itemId = $(event.currentTarget).data("item-id");
    let itemData
    
    if ( step == 'select-race') {
      itemData = this.races.find( item => item._id == itemId );      
    }
    if ( step == 'select-race-optionnal') {
      itemData = this.raceOptionnalAbilities.optionnalabilities.find( item => item._id == itemId );
    }
    if ( step == 'select-race-perks') {
      itemData = this.perks.find( item => item._id == itemId );      
    }
    if ( step == 'select-race-perks'){
      itemData = this.racePerks.find( item => item._id == itemId );      
    }
    if ( step == 'select-role') {
      itemData = this.roles.find( item => item._id == itemId );      
    }
    if ( step == 'select-role-start-spec') {
      itemData = this.roleSpecStart.find( item => item._id == itemId );      
    }
    if (step == 'select-role-spec') {
      itemData = this.roleSpec.find( item => item._id == itemId );      
    }
    if (step == 'select-role-perk') {
      itemData = this.rolePerks.find( item => item._id == itemId );      
    }
    if (itemData) {
      let item = await Item.create(itemData, {temporary: true});   
      new PegasusItemSheet(item).render(true);
    }
  }
  
  /* -------------------------------------------- */
  manageSelectableStats( race ) {
    this.raceSelectableStats  = {
      "race": race,
      "statsonlyonce": race.data.statsonlyonce, 
      "numberstats": race.data.numberstats,
      "stats": duplicate(this.actor.data.data.statistics)
    }
    this.processSelectableStats()
  }

  /* -------------------------------------------- */
  async renderChatMessage( formData) {
    let chatData = {
      user: game.user.id,
      alias : this.actor.name,
      rollMode: game.settings.get("core", "rollMode"),
      whisper: [game.user.id].concat( ChatMessage.getWhisperRecipients('GM') ),
      content: await renderTemplate('systems/fvtt-pegasus-rpg/templates/chat-create-actor.html', formData)
    };  
    //console.log("Apply damage chat", chatData );
    await ChatMessage.create( chatData );  
  }

  /* ---------------  --------------------  --------- */
  manageRacePerks(race) {
    if ( !this.currentRace.data.perksgained ) {
      this.showRoles()
      return;
    }
    if ( !this.racePerks) { // First init
      if ( this.currentRace.data.perksall) {
        this.racePerks = duplicate(this.perks)
      } else {
        this.racePerks = duplicate(this.currentRace.data.perks)
      }      
      this.nbRacePerks = this.currentRace.data.perksnumber;      
    }
    let formData = this.createFormData("select-race-perks")
    formData.raceperks =  this.racePerks;
    formData.nbraceperks = this.nbRacePerks;  
    this.renderChatMessage(formData)
  }

  /* ---------------  --------------------  --------- */
  async processSelectableStats() {
    // End of race options choice
    if ( this.raceSelectableStats.numberstats == 0) {
      this.manageRacePerks();
      return;
    }
    let formData = this.createFormData("select-race-stats")
    let chatData = {
      user: game.user.id,
      alias : this.actor.name,
      rollMode: game.settings.get("core", "rollMode"),
      whisper: [game.user.id].concat( ChatMessage.getWhisperRecipients('GM') ),
      content: await renderTemplate('systems/fvtt-pegasus-rpg/templates/chat-create-actor.html', formData)
    };  
    //console.log("Apply damage chat", chatData );
    await ChatMessage.create( chatData );
  }

  /* ---------------  ----------------------------- */
  manageOptionnalAbilities( race) {
    this.raceOptionnalAbilities  = {
      "nboptionnal": race.data.nboptionnal, 
      "optionnalabilities": duplicate(race.data.optionnalabilities),
    }
    this.processOptionnalAbilitiesStep()
  }

  /* -------------------------------------------- */
  async processOptionnalAbilitiesStep() {
    // End of race options choice
    if ( this.raceOptionnalAbilities.nboptionnal == 0) {
      if ( this.raceSelectableStats ) {
        this.manageSelectableStats(this.currentrace);
      } else if ( this.currentRace.system.perksgained) {
        this.manageRacePerks(this.currentRace);
      } else {
        this.showRoles()
      }
    } else {
      let formData = this.createFormData("select-race-optionnal")
      this.renderChatMessage( formData)
    }
  }

  /* -------------------------------------------- */
  async showRaces() {
    let formData = this.createFormData("select-race")
    this.renderChatMessage( formData)
  }

  /* -------------------------------------------- */
  async showRoles() {
    let formData = this.createFormData("select-role")
    this.renderChatMessage( formData)
  }

  /* -------------------------------  ------------- */
  async showRoleStartSpec() {
    if ( !this.roleSpecStart) {
      this.roleSpecStart = this.specs.filter(spec => spec.system.statistic.toUpperCase() ==  this.currentRole.system.statincrease1.toUpperCase() || spec.system.statistic.toUpperCase() ==  this.currentRole.system.statincrease2.toUpperCase() )
      console.log("SPEC FOUND", this.roleSpecStart)
      //this.roleSpecStart = duplicate(this.currentRole.data.specialisationsplus1)
      this.nbRoleSpecStart = 2;
    }
    let formData = this.createFormData("select-role-start-spec")
    formData.rolestartspec = this.roleSpecStart 
    formData.nbrolespecstart = this.nbRoleSpecStart;
    this.renderChatMessage( formData)
  }

  /* -------------------------------  ------------- */
  async showRoleStat(  ) {
    let formData = this.createFormData("select-role-stat")
    formData.rolestats = []
    for(let stat of this.roleStats) {
      if (stat.flag) {
        formData.rolestats.push( duplicate(this.actor.system.statistics[stat.name.toLowerCase()]) )
      }
    } 
    //console.log("STAT", this.roleStats, formData)
    this.renderChatMessage( formData)
  }

  /* -------------------------------------------- */
  async showRoleSpecialisations() {
    let formData = this.createFormData("select-role-spec")
    formData.rolespec = duplicate(this.roleSpec)
    formData.dt = 1
    if (this.nbDT2 > 0 ) {
      formData.dt = 2
    } 
    this.renderChatMessage( formData)
  }

  /* -------------------------------------------- */
  async showRolePerks() {
    let formData = this.createFormData("select-role-perk")
    formData.roleperks = duplicate(this.rolePerks)
    formData.nbperks = this.nbPerks
    this.renderChatMessage( formData)
  }

  /* -------------------------------------------- */
  async showCharacterEnd() {
    await this.actor.computeNRGHealth()
    this.actor.computeValue = false // To force value computation
    let formData = this.createFormData("character-end")
    this.renderChatMessage( formData)
  }
  
}