fvtt-rolemaster-frp/module/documents/item.js

import { RFRPUtility } from "../rfrp-utility.js";

export class RMFRPItem extends Item {

  /** @override */
  prepareData() {
    // Prepare data for the item. Calling the super version of this executes
    // the following, in order: data reset (to clear active effects),
    // prepareBaseData(), prepareEmbeddedDocuments() (including active effects),
    // prepareDerivedData().
    console.log(`rmfrp | item.js | prepareData for:  ${this.name}`);
    super.prepareData();
  }

  // Set the icon images for newly created images.
  async _preCreate(data, options, userId) {
    await super._preCreate(data, options, userId);

    // Do not set on copied items if they have a custom Icon.
    if (!data.name.includes("(Copy)"))
    {
      if (this.type === "armor") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/armor.svg"});
      }
      else if (this.type === "weapon") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/weapon.svg"});
      }
      else if (this.type === "skill") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/skill.svg"});
      }
      else if (this.type === "skill_category") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/skill_category.svg"});
      }
      else if (this.type === "spell") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/spell.svg"});
      }
      else if (this.type === "herb_or_poison") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/herb_or_poison.svg"});
      }
      else if (this.type === "transport") {
        await this.updateSource({img: "systems/fvtt-rolemaster-frp/assets/default/transport.svg"});
      }
    }
  }

  prepareDerivedData() {
    const itemData = this;
    const systemData = itemData.system;

    if (this.parent?.getFlag("world", "importing")) {
      return; // Don't calculate skill bonuses if we are importing
    }
    // Make separate methods for each item type to keep things organized.
    if (itemData.type === "skill") {
      this._prepareSkillCategoryData(itemData);
    }

    if (itemData.type === "skill") {
      this._prepareSkillData(itemData);
    }
  }

  _prepareSkillCategoryData(itemData) {
    if (itemData.type !== "skill_category") return;
    console.log(`rmfrp | item.js | Preparing Skill Category Data for: ${itemData.name}`);
    // Calculate Skill Category Total Bonus
    this.calculateSkillCategoryTotalBonus(itemData);
  }

  _prepareSkillData(itemData) {
    if (itemData.type !== "skill") return;

    console.log(`rmfrp | item.js | Preparing Skill Data for: ${itemData.name}`);
    // Make modifications to data here. For example:
    // const systemData = itemData.system;
    // Calculate Skill Category Bonus
    this.calculateSelectedSkillCategoryBonus(itemData);
    // Calculate Skill Total Bonus
    this.calculateSkillTotalBonus(itemData);
  }

  calculateSkillCategoryTotalBonus(itemData) {
    if (this.type === "skill_category") {
      console.log(`rmfrp | item.js | Calculating Skill Category Total Bonus for:  ${itemData.name}`);
      const systemData = itemData.system;
      itemData.system.total_bonus = Number(systemData.rank_bonus)
                                  + Number(systemData.stat_bonus)
                                  + Number(systemData.prof_bonus)
                                  + Number(systemData.special_bonus_1)
                                  + Number(systemData.special_bonus_2);
    }
  }

  calculateSkillTotalBonus(itemData) {
    if (this.type === "skill") {
      const systemData = itemData.system;
      console.log(`rmfrp | item.js | Calculating Skill Total Bonus for: ${itemData.name}`);
      itemData.system.total_bonus = Number(systemData.rank_bonus)
                                  + Number(systemData.category_bonus)
                                  + Number(systemData.item_bonus)
                                  + Number(systemData.special_bonus_1)
                                  + Number(systemData.special_bonus_2);
    }
  }

  calculateSelectedSkillCategoryBonus(itemData) {
    // Find the relevant skill category 
    if (!this.parent) { return; } // Only if attached to an actor

    let skillC =  this.parent?.items || RFRPUtility.getSkillCategories();
    if (skillC) {
      let item = skillC.find(it => it.type == "skill_category" && it.name.toLowerCase() == itemData.system.category.toLowerCase());
      if (item) {
        this.system.category_bonus = item.system.total_bonus;
      } else {
        ui.notifications.warn(`Skill Category ${itemData.system.category} not found for Skill ${itemData.name}`);
      }
    } else {
      ui.notifications.info("No Skill Categories found. Please create a Skill Category.");
    }
  }
}