Merge branch 'Develop-VJ' into cyr-power-point-ui

lang/en.json

@@ -144,6 +144,10 @@
 "SW5E.BonusRWDamage": "Ranged Weapon Damage Bonus",
 "SW5E.BonusSaveForm": "Update Bonuses",
 "SW5E.BonusPowerDC": "Global Power DC Bonus",
+"SW5E.BonusForceLightPowerDC": "Global Force Light Power DC Bonus",
+"SW5E.BonusForceDarkPowerDC": "Global Force Dark Power DC Bonus",
+"SW5E.BonusForceUnivPowerDC": "Global Force Universal Power DC Bonus",
+"SW5E.BonusTechPowerDC": "Global Tech Power DC Bonus",
 "SW5E.BonusTitle": "Configure Actor Bonuses",
 "SW5E.Bonuses": "Global Bonuses",
 "SW5E.BonusesHint": "Define global bonuses as formulas which are added to certain rolls. For example: 1d4 + 2",

module/actor/entity.js

@@ -94,7 +94,7 @@ export default class Actor5e extends Actor {
     // Prepare power-casting data
     data.attributes.powerForceLightDC = 8 + data.abilities.wis.mod + data.attributes.prof ?? 10;
     data.attributes.powerForceDarkDC = 8 + data.abilities.cha.mod + data.attributes.prof ?? 10;
-    data.attributes.powerForceUnivDC = Math.ceil(data.attributes.powerForceLightDC,data.attributes.powerForceDarkDC) ?? 10;
+    data.attributes.powerForceUnivDC = Math.max(data.attributes.powerForceLightDC,data.attributes.powerForceDarkDC) ?? 10;
     data.attributes.powerTechDC = 8 + data.abilities.int.mod + data.attributes.prof ?? 10;
     this._computePowercastingProgression(this.data);
 
@@ -506,7 +506,6 @@ export default class Actor5e extends Actor {
     }
 
     // Look up the number of slots per level from the powerLimit table
-    // TODO: Add Tech progression afterwards
     let forcePowerLimit = SW5E.powerLimit['none'];
     for (let i = 0; i < (forceProgression.maxClassPowerLevel); i++) {
       forcePowerLimit[i] = SW5E.powerLimit[forceProgression.maxClass][i];
@@ -515,9 +514,22 @@ export default class Actor5e extends Actor {
     for ( let [n, lvl] of Object.entries(powers) ) {
       let i = parseInt(n.slice(-1));
       if ( Number.isNaN(i) ) continue;
-      if ( Number.isNumeric(lvl.override) ) lvl.max = Math.max(parseInt(lvl.override), 0);
+      if ( Number.isNumeric(lvl.foverride) ) lvl.fmax = Math.max(parseInt(lvl.foverride), 0);
-      else lvl.max = forcePowerLimit[i-1] || 0;
+      else lvl.fmax = forcePowerLimit[i-1] || 0;
-      lvl.value = parseInt(lvl.value);
+      lvl.fvalue = parseInt(lvl.fvalue);
+    }
+    
+    let techPowerLimit = SW5E.powerLimit['none'];
+    for (let i = 0; i < (techProgression.maxClassPowerLevel); i++) {
+      techPowerLimit[i] = SW5E.powerLimit[techProgression.maxClass][i];
+    }
+
+    for ( let [n, lvl] of Object.entries(powers) ) {
+      let i = parseInt(n.slice(-1));
+      if ( Number.isNaN(i) ) continue;
+      if ( Number.isNumeric(lvl.toverride) ) lvl.tmax = Math.max(parseInt(lvl.toverride), 0);
+      else lvl.tmax = techPowerLimit[i-1] || 0;
+      lvl.tvalue = parseInt(lvl.tvalue);
     }
 
     // Set Force and tech power
@@ -1119,8 +1131,6 @@ export default class Actor5e extends Actor {
       }
     }
 
-
-
     // Note the change in HP and HD and TP which occurred
     const dhd = this.data.data.attributes.hd - hd0;
     const dhp = this.data.data.attributes.hp.value - hp0;

module/apps/ability-use-dialog.js

@@ -100,32 +100,63 @@ export default class AbilityUseDialog extends Dialog {
 
     // Determine the levels which are feasible
     let lmax = 0;
-    const powerLevels = Array.fromRange(10).reduce((arr, i) => {
+    let points;
-      if ( i < lvl ) return arr;
+    let powerType;
-      const label = CONFIG.SW5E.powerLevels[i];
+    switch (itemData.school){
-      const l = actorData.powers["power"+i] || {max: 0, override: null};
+      case "lgt":
-      let max = parseInt(l.override || l.max || 0);
+      case "uni":
-      let slots = Math.clamped(parseInt(l.value || 0), 0, max);
+      case "drk": {
-      if ( max > 0 ) lmax = i;
+        powerType = "force"
-      arr.push({
+        points = actorData.attributes.force.points.value + actorData.attributes.force.points.temp;
-        level: i,
+        break;
-        label: i > 0 ? game.i18n.format('SW5E.PowerLevelSlot', {level: label, n: slots}) : label,
+      }
-        canCast: max > 0,
+      case "tec": {
-        hasSlots: slots > 0
+        powerType = "tech"
-      });
+        points = actorData.attributes.tech.points.value + actorData.attributes.tech.points.temp;
-      return arr;
+        break;
-    }, []).filter(sl => sl.level <= lmax);
+      }
-
-    // If this character has pact slots, present them as an option for casting the power.
-    const pact = actorData.powers.pact;
-    if (pact.level >= lvl) {
-      powerLevels.push({
-        level: 'pact',
-        label: `${game.i18n.format('SW5E.PowerLevelPact', {level: pact.level, n: pact.value})}`,
-        canCast: true,
-        hasSlots: pact.value > 0
-      });
     }
+    let powerLevels
+    if (powerType === "force"){
+      powerLevels = Array.fromRange(10).reduce((arr, i) => {
+        if ( i < lvl ) return arr;
+        const label = CONFIG.SW5E.powerLevels[i];
+        const l = actorData.powers["power"+i] || {fmax: 0, foverride: null};
+        let max = parseInt(l.foverride || l.fmax || 0);
+        let slots = Math.clamped(parseInt(l.fvalue || 0), 0, max);
+        if ( max > 0 ) lmax = i;
+        if ((max > 0) && (slots > 0) && (points > i)){
+          arr.push({
+            level: i,
+            label: i > 0 ? game.i18n.format('SW5E.PowerLevelSlot', {level: label, n: slots}) : label,
+            canCast: max > 0,
+            hasSlots: slots > 0
+          });
+        }
+        return arr;
+      }, []).filter(sl => sl.level <= lmax);
+    }else if (powerType === "tech"){
+      powerLevels = Array.fromRange(10).reduce((arr, i) => {
+        if ( i < lvl ) return arr;
+        const label = CONFIG.SW5E.powerLevels[i];
+        const l = actorData.powers["power"+i] || {tmax: 0, toverride: null};
+        let max = parseInt(l.override || l.tmax || 0);
+        let slots = Math.clamped(parseInt(l.tvalue || 0), 0, max);
+        if ( max > 0 ) lmax = i;
+        if ((max > 0) && (slots > 0) && (points > i)){
+          arr.push({
+            level: i,
+            label: i > 0 ? game.i18n.format('SW5E.PowerLevelSlot', {level: label, n: slots}) : label,
+            canCast: max > 0,
+            hasSlots: slots > 0
+          });
+        }
+        return arr;
+      }, []).filter(sl => sl.level <= lmax);
+    }
+  
+    
+
     const canCast = powerLevels.some(l => l.hasSlots);
     if ( !canCast ) data.errors.push(game.i18n.format("SW5E.PowerCastNoSlots", {
       level: CONFIG.SW5E.powerLevels[lvl],

module/apps/actor-flags.js

@@ -74,7 +74,11 @@ export default class ActorSheetFlags extends BaseEntitySheet {
       {name: "data.bonuses.abilities.check", label: "SW5E.BonusAbilityCheck"},
       {name: "data.bonuses.abilities.save", label: "SW5E.BonusAbilitySave"},
       {name: "data.bonuses.abilities.skill", label: "SW5E.BonusAbilitySkill"},
-      {name: "data.bonuses.power.dc", label: "SW5E.BonusPowerDC"}
+      {name: "data.bonuses.power.dc", label: "SW5E.BonusPowerDC"},
+      {name: "data.bonuses.power.forceLightDC", label: "SW5E.BonusForceLightPowerDC"},
+      {name: "data.bonuses.power.forceDarkDC", label: "SW5E.BonusForceDarkPowerDC"},
+      {name: "data.bonuses.power.forceUnivDC", label: "SW5E.BonusForceUnivPowerDC"},
+      {name: "data.bonuses.power.techDC", label: "SW5E.BonusTechPowerDC"}
     ];
     for ( let b of bonuses ) {
       b.value = getProperty(this.object._data, b.name) || "";

module/item/entity.js

@@ -25,8 +25,17 @@ export default class Item5e extends Item {
     else if (this.actor) {
       const actorData = this.actor.data.data;
 
-      // Powers - Use Actor powercasting modifier
+      // Powers - Use Actor powercasting modifier based on power school
-      if (this.data.type === "power") return actorData.attributes.powercasting || "int";
+      if (this.data.type === "power") {
+        switch (this.data.data.school) {
+          case "lgt": return "wis";
+          case "uni": return (actorData.abilities["wis"].mod >= actorData.abilities["cha"].mod) ? "wis" : "cha";
+          case "drk": return "cha";
+          case "tec": return "int";
+        }
+        return "none";
+      }
+        
 
       // Tools - default to Intelligence
       else if (this.data.type === "tool") return "int";
@@ -311,7 +320,24 @@ export default class Item5e extends Item {
 
     // Actor power-DC based scaling
     if ( save.scaling === "power" ) {
-      save.dc = this.isOwned ? getProperty(this.actor.data, "data.attributes.powerdc") : null;
+      switch (this.data.data.school) {
+        case "lgt": {
+          save.dc = this.isOwned ? getProperty(this.actor.data, "data.attributes.powerForceLightDC") : null;
+          break;
+        }
+        case "uni": {
+          save.dc = this.isOwned ? getProperty(this.actor.data, "data.attributes.powerForceUnivDC") : null;
+          break;
+        }
+        case "drk": {
+          save.dc = this.isOwned ? getProperty(this.actor.data, "data.attributes.powerForceDarkDC") : null;
+          break;
+        }
+        case "tec": {
+          save.dc = this.isOwned ? getProperty(this.actor.data, "data.attributes.powerTechDC") : null;
+          break;
+        }
+      }
     }
 
     // Ability-score based scaling
@@ -414,6 +440,7 @@ export default class Item5e extends Item {
     const recharge = id.recharge || {};       // Recharge mechanic
     const uses = id?.uses ?? {};              // Limited uses
     const isPower = this.type === "power";    // Does the item require a power slot?
+    // TODO: Possibly Mod this to not consume slots based on class?
     const requirePowerSlot = isPower && (id.level > 0) && CONFIG.SW5E.powerUpcastModes.includes(id.preparation.mode);
 
     // Define follow-up actions resulting from the item usage
@@ -424,11 +451,18 @@ export default class Item5e extends Item {
     let consumeUsage = !!uses.per;              // Consume limited uses
     let consumeQuantity = uses.autoDestroy;     // Consume quantity of the item in lieu of uses
 
+    /*//set rollback values in case you pick a spell level you can't cast anymore
+    let forcePointValueRollback = actor.data.data.attributes.force.points.value;
+    let forcePointTempRollback = actor.data.data.attributes.force.points.temp;
+    let techPointValueRollback = actor.data.data.attributes.tech.points.value;
+    let techPointTempRollback = actor.data.data.attributes.tech.points.temp;
+    */
     // Display a configuration dialog to customize the usage
     const needsConfiguration = createMeasuredTemplate || consumeRecharge || consumeResource || consumePowerSlot || consumeUsage;
     if (configureDialog && needsConfiguration) {
       const configuration = await AbilityUseDialog.create(this);
       if (!configuration) return;
+      
 
       // Determine consumption preferences
       createMeasuredTemplate = Boolean(configuration.placeTemplate);
@@ -440,18 +474,20 @@ export default class Item5e extends Item {
       // Handle power upcasting
       if ( requirePowerSlot ) {
         const slotLevel = configuration.level;
-        const powerLevel = slotLevel === "pact" ? actor.data.data.powers.pact.level : parseInt(slotLevel);
+        const powerLevel = parseInt(slotLevel);
+        
         if (powerLevel !== id.level) {
           const upcastData = mergeObject(this.data, {"data.level": powerLevel}, {inplace: false});
           item = this.constructor.createOwned(upcastData, actor);  // Replace the item with an upcast version
         }
-        if ( consumePowerSlot ) consumePowerSlot = slotLevel === "pact" ? "pact" : `power${powerLevel}`;
+        if ( consumePowerSlot ) consumePowerSlot = `power${powerLevel}`;
       }
     }
 
     // Determine whether the item can be used by testing for resource consumption
     const usage = item._getUsageUpdates({consumeRecharge, consumeResource, consumePowerSlot, consumeUsage, consumeQuantity});
     if ( !usage ) return;
+    
     const {actorUpdates, itemUpdates, resourceUpdates} = usage;
 
     // Commit pending data updates
@@ -513,14 +549,47 @@ export default class Item5e extends Item {
     // Consume Power Slots
     if ( consumePowerSlot ) {
       const level = this.actor?.data.data.powers[consumePowerSlot];
-      const powers = Number(level?.value ?? 0);
+      const fp = this.actor.data.data.attributes.force.points;
-      if ( powers === 0 ) {
+      const tp = this.actor.data.data.attributes.tech.points;
-        const label = game.i18n.localize(consumePowerSlot === "pact" ? "SW5E.PowerProgPact" : `SW5E.PowerLevel${id.level}`);
+      const powerCost = level + 1;
-        ui.notifications.warn(game.i18n.format("SW5E.PowerCastNoSlots", {name: this.name, level: label}));
+      switch (id.school){
-        return false;
+        case "lgt":
+        case "uni":
+        case "drk": {
+          const powers = Number(level?.fvalue ?? 0);
+          if ( powers === 0 ) {
+            const label = game.i18n.localize(`SW5E.PowerLevel${id.level}`);
+            ui.notifications.warn(game.i18n.format("SW5E.PowerCastNoSlots", {name: this.name, level: label}));
+            return false;
+          }
+          actorUpdates[`data.powers.${consumePowerSlot}.fvalue`] = Math.max(powers - 1, 0);
+          if (fp.temp >= powerCost) {
+            actorUpdates["data.attributes.force.points.temp"] = fp.temp - powerCost;
+          }else{
+            actorUpdates["data.attributes.force.points.value"] = fp.value + fp.temp - powerCost;
+            actorUpdates["data.attributes.force.points.temp"] = 0;
+          }
+          break;
+        }
+        case "tec": {
+          const powers = Number(level?.tvalue ?? 0);
+          if ( powers === 0 ) {
+            const label = game.i18n.localize(`SW5E.PowerLevel${id.level}`);
+            ui.notifications.warn(game.i18n.format("SW5E.PowerCastNoSlots", {name: this.name, level: label}));
+            return false;
+          }
+          actorUpdates[`data.powers.${consumePowerSlot}.tvalue`] = Math.max(powers - 1, 0);
+          if (tp.temp >= powerCost) {
+            actorUpdates["data.attributes.force.points.temp"] = tp.temp - powerCost;
+          }else{
+            actorUpdates["data.attributes.force.points.value"] = tp.value + tp.temp - powerCost;
+            actorUpdates["data.attributes.force.points.temp"] = 0;
+          }
+          break;
+        }
       }
-      actorUpdates[`data.powers.${consumePowerSlot}.value`] = Math.max(powers - 1, 0);
     }
+    
 
     // Consume Limited Usage
     if ( consumeUsage ) {
@@ -792,7 +861,7 @@ export default class Item5e extends Item {
   /* -------------------------------------------- */
 
   /**
-   * Prepare chat card data for tool type items
+   * Prepare chat card data for loot type items
    * @private
    */
   _lootChatData(data, labels, props) {

module/migration.js

@@ -286,13 +286,28 @@ function _migrateActorPowers(actorData, updateData) {
     updateData["data.attributes.tech.points.tempmax"] = 0;
     updateData["data.attributes.tech.level"] = 0;
   }
+
+  // If new Power F/T split data is not present, create it
+  const hasNewBonus = ad?.powers?.power1?.fvalue !== undefined;
+  if ( !hasNewBonus ) {
+    for (let i = 1; i <= 9; i++) { 
+      // add new
+      updateData["data.powers.power" + i + ".fvalue"] = 0;
+      updateData["data.powers.power" + i + ".foverride"] = null;
+      updateData["data.powers.power" + i + ".tvalue"] = 0;
+      updateData["data.powers.power" + i + ".toverride"] = null;
+      //remove old
+      updateData["data.powers.power" + i + ".-=value"] = null;
+      updateData["data.powers.power" + i + ".-=override"] = null;
+    }
+  }
   // If new Bonus Power DC data is not present, create it
   const hasNewBonus = ad?.bonuses?.power?.forceLightDC !== undefined;
   if ( !hasNewBonus ) {
     updateData["data.bonuses.power.forceLightDC"] = "";
     updateData["data.bonuses.power.forceDarkDC"] = "";
     updateData["data.bonuses.power.forceUnivDC"] = "";
-    updateData["data.bonuses.power.TechDC"] = "";
+    updateData["data.bonuses.power.techDC"] = "";
   }
 
   // Remove the Power DC Bonus

template.json

@@ -211,40 +211,58 @@
         },
         "powers": {
           "power1": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power2": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power3": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power4": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power5": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power6": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power7": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power8": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           },
           "power9": {
-            "value": 0,
+            "fvalue": 0,
-            "override": null
+            "foverride": null,
+            "tvalue": 0,
+            "toverride": null
           }
         },
         "bonuses": {