Overhauled damage multipliers UX

Form and viewer revamp
custom damage types
Variables: `bludgeoning.resistance`

app/imports/api/engine/computation/buildComputation/linkTypeDependencies.js

@@ -218,7 +218,7 @@ function linkDamageMultiplier(dependencyGraph, prop){
   prop.damageTypes.forEach(damageType => {
     // Remove all non-letter characters from the damage name
     const damageName = damageType.replace(/[^a-z]/gi, '')
-    dependencyGraph.addLink(`${damageName}Multiplier`, prop._id, prop.type);
+    dependencyGraph.addLink(damageName, prop._id, prop.type);
   });
 }
 
@@ -242,7 +242,7 @@ function linkSkill(dependencyGraph, prop){
   }
   // Skills depend on the creature's proficiencyBonus
   dependencyGraph.addLink(prop._id, 'proficiencyBonus', 'skillProficiencyBonus');
-  
+
   // Depends on base value
   dependOnCalc({dependencyGraph, prop, key: 'baseValue'});
 }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable.js

@@ -54,6 +54,21 @@ function combineAggregations(computation, node){
 
 function computeVariableProp(computation, node, prop){
   if (!prop) return;
+
+  // Combine damage multipliers in all props so that they can't be overridden
+  if (node.data.immunity){
+    prop.immunity = node.data.immunity;
+    prop.immunities = node.data.immunities;
+  }
+  if (node.data.resistance){
+    prop.resistance = node.data.resistance;
+    prop.resistances = node.data.resistances;
+  }
+  if (node.data.vulnerability){
+    prop.vulnerability = node.data.vulnerability;
+    prop.vulnerabilities = node.data.vulnerabilities;
+  }
+
   if (prop.type === 'attribute'){
     computeVariableAsAttribute(computation, node, prop);
   } else if (prop.type === 'skill'){
@@ -73,21 +88,16 @@ function combineMultiplierAggregator(node){
   if (!aggregator) return;
 
   // Combine
-  let value;
-  if (aggregator.immunityCount){
-    value = 0;
-  } else if (
-    aggregator.resistanceCount &&
-    !aggregator.vulnerabilityCount
-  ){
-    value = 0.5;
-  }  else if (
-    !aggregator.resistanceCount &&
-    aggregator.vulnerabilityCount
-  ){
-    value = 2;
-  } else {
-    value = 1;
+  if (aggregator.immunities?.length){
+    node.data.immunity = true;
+    node.data.immunities = aggregator.immunities;
+  }
+  if (aggregator.resistances?.length){
+    node.data.resistance = true;
+    node.data.resistances = aggregator.resistances;
+  }
+  if (aggregator.vulnerabilities?.length){
+    node.data.vulnerability = true;
+    node.data.vulnerabilities = aggregator.vulnerabilities;
   }
-  node.data.damageMultiplyValue = value;
 }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateDamageMultiplier.js

@@ -1,22 +1,36 @@
+import { pick } from 'lodash';
+
 export default function aggregateDamageMultipliers({node, linkedNode, link}){
   if (link.data !== 'damageMultiplier') return;
   const multiplierValue = linkedNode.data.value;
   if (multiplierValue === undefined) return;
+
   // Store an aggregator, its presence indicates damage multipliers target this
   // variable
   if (!node.data.multiplierAggregator) node.data.multiplierAggregator = {
-    immunityCount: 0,
-    resistanceCount: 0,
-    vulnerabilityCount: 0,
+    immunities: [],
+    resistances: [],
+    vulnerabilities: [],
   }
   // Store a short reference to the aggregator
   const aggregator = node.data.multiplierAggregator;
-  // Sum the counts of each type of multiplier
+
+  // Make a stripped down copy of the multiplier to store in the aggregator
+  const keysToStore = ['_id', 'name'];
+  if (linkedNode.data.excludeTags?.length){
+    keysToStore.push('excludeTags');
+  }
+  if (linkedNode.data.includeTags?.length){
+    keysToStore.push('includeTags');
+  }
+  const storedMultiplier = pick(linkedNode.data, keysToStore);
+
+  // Store the multiplier in the appropriate field
   if (multiplierValue === 0){
-    aggregator.immunityCount += 1;
+    aggregator.immunities.push(storedMultiplier);
   } else if (multiplierValue === 0.5){
-    aggregator.resistanceCount += 1;
+    aggregator.resistances.push(storedMultiplier);
   } else if (multiplierValue === 2){
-    aggregator.vulnerabilityCount += 1;
+    aggregator.vulnerabilities.push(storedMultiplier);
   }
 }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeImplicitVariable.js

@@ -6,6 +6,21 @@ import getAggregatorResult from './getAggregatorResult.js';
  */
  export default function computeImplicitVariable(node){
    const prop = {};
+
+   // Combine damage multipliers
+   if (node.data.immunity){
+     prop.immunity = node.data.immunity;
+     prop.immunities = node.data.immunities;
+   }
+   if (node.data.resistance){
+     prop.resistance = node.data.resistance;
+     prop.resistances = node.data.resistances;
+   }
+   if (node.data.vulnerability){
+     prop.vulnerability = node.data.vulnerability;
+     prop.vulnerabilities = node.data.vulnerabilities;
+   }
+
    const result = getAggregatorResult(node);
    if (result !== undefined){
      prop.value = result;

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeVariableAsAttribute.js

@@ -1,7 +1,7 @@
 import getAggregatorResult from './getAggregatorResult.js';
 
 export default function computeVariableAsAttribute(computation, node, prop){
-  let result = getAggregatorResult(node, prop) || 0;
+  let result = getAggregatorResult(node) || 0;
 
   prop.total = result;
   prop.value = prop.total - (prop.damage || 0);

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/getAggregatorResult.js

@@ -1,15 +1,10 @@
 import stripFloatingPointOddities from '/imports/api/engine/computation/utility/stripFloatingPointOddities.js';
 
 export default function getAggregatorResult(node){
-  // Work out the base value as the greater of the deining stat value or
-  // the damage multiplier value
+  // Work out the base value as the greater of the deining stat value
   // This baseValue comes from aggregating definitions
   let statBase = node.data.baseValue;
 
-  const damageMultiplyValue = node.data.damageMultiplyValue;
-  if (statBase === undefined || damageMultiplyValue > statBase){
-    statBase = damageMultiplyValue;
-  }
   // get a reference to the  aggregator
   const aggregator = node.data.effectAggregator;