Effects targeting calculations by tag now work in the engine and actions

2022-02-15 15:59:41 +02:00
parent e0f621cc44
commit 378da71f5d
19 changed files with 454 additions and 98 deletions
--- a/app/imports/api/engine/computation/CreatureComputation.js
+++ b/app/imports/api/engine/computation/CreatureComputation.js
@@ -6,6 +6,7 @@ export default class CreatureComputation {
    // Set up fields
    this.originalPropsById =  {};
    this.propsById =  {};
+    this.propsWithTag = {};
    this.scope = {};
    this.props =  properties;
    this.dependencyGraph = createGraph();
@@ -18,6 +19,17 @@ export default class CreatureComputation {
      // Store by id
      this.propsById[prop._id] = prop;

+      // Store sets of ids in each tag
+      if (prop.tags){
+        prop.tags.forEach(tag => {
+          if (this.propsWithTag[tag]){
+            this.propsWithTag[tag].push(prop._id);
+          } else {
+            this.propsWithTag[tag] = [prop._id];
+          }
+        });
+      }
+
      // Store the prop in the dependency graph
      this.dependencyGraph.addNode(prop._id, prop);
    });
--- a/app/imports/api/engine/computation/buildComputation/linkTypeDependencies.js
+++ b/app/imports/api/engine/computation/buildComputation/linkTypeDependencies.js
@@ -1,4 +1,4 @@
-import { get } from 'lodash';
+import { get, intersection, difference } from 'lodash';

 const linkDependenciesByType = {
  action: linkAction,
@@ -127,11 +127,11 @@ function linkEffects(dependencyGraph, prop, computation){
  dependOnCalc({dependencyGraph, prop, key: 'amount'});
  // The stats depend on the effect
  if (prop.targetByTags){
-    // TODO: 
-    getEffectTagTargets(prop, computation).forEach(targetProp => {
+    getEffectTagTargets(prop, computation).forEach(targetId => {
+      const targetProp = computation.propsById[targetId];
      const key = prop.targetField || getDefaultCalculationField(targetProp);
      const calcObj = get(targetProp, key);
-      if (calcObj){
+      if (calcObj && calcObj.calculation){
        dependencyGraph.addLink(`${targetProp._id}.${key}`, prop._id , 'effect');
      }
    });
@@ -143,6 +143,67 @@ function linkEffects(dependencyGraph, prop, computation){
  }
 }

+// Returns an array of IDs of the properties the effect targets
+function getEffectTagTargets(effect, computation){
+  const targets = getTargetListFromTags(effect.targetTags, computation);
+  const notIds = [];
+  if (effect.extraTags){
+    effect.extraTags.forEach(ex => {
+      if (ex.operation === 'OR'){
+        targets.push(...getTargetListFromTags(ex.tags, computation));
+      } else if (ex.operation === 'NOT'){
+        ex.tags.forEach(tag => {
+          const idList = computation.propsWithTag[tag];
+          if (idList) notIds.push(...computation.propsWithTag[tag])
+        });
+      }
+    });
+  }
+  return difference(targets, notIds);
+}
+
+function getTargetListFromTags(tags, computation){
+  const targetTagIdLists = [];
+  if (!tags) return [];
+  tags.forEach(tag => {
+    const idList = computation.propsWithTag[tag];
+    if (idList) targetTagIdLists.push(idList);
+  });
+  const targets = intersection(...targetTagIdLists);
+  return targets;
+}
+
+function getDefaultCalculationField(prop){
+  switch (prop.type){
+    case 'action': return 'attackRoll';
+    case 'adjustment': return 'amount';
+    case 'attribute': return 'baseValue';
+    case 'branch': return 'condition';
+    case 'buff': return 'duration';
+    case 'class': return null;
+    case 'classLevel': return null;
+    case 'constant': return null;
+    case 'container': return null;
+    case 'damageMultiplier': return null;
+    case 'damage': return 'amount';
+    case 'effect': return 'amount';
+    case 'feature': return null;
+    case 'folder': return null;
+    case 'item': return null;
+    case 'note': return null;
+    case 'proficiency': return null;
+    case 'reference': return null;
+    case 'roll': return 'roll';
+    case 'savingThrow': return 'dc';
+    case 'skill': return 'baseValue';
+    case 'slotFiller': return null;
+    case 'slot': return 'quantityExpected';
+    case 'spellList': return 'attackRollBonus';
+    case 'spell': return null;
+    case 'toggle': return 'condition';
+  }
+}
+
 function linkRoll(dependencyGraph, prop){
  dependOnCalc({dependencyGraph, prop, key: 'roll'});
 }
--- a/app/imports/api/engine/computation/buildComputation/parseCalculationFields.js
+++ b/app/imports/api/engine/computation/buildComputation/parseCalculationFields.js
@@ -29,7 +29,7 @@ function discoverInlineCalculationFields(prop, schemas){

      // Set the value to the uncomputed string for use in calculations
      inlineCalcObj.value = string;
-      
+
      // Has the text, if it matches the existing hash, stop
      const inlineCalcHash = cyrb53(inlineCalcObj.text);
      if (inlineCalcHash === inlineCalcObj.hash){
@@ -57,6 +57,9 @@ function parseAllCalculationFields(prop, schemas){
    // Determine the level the calculation should compute down to
    let parseLevel = schemas[prop.type].getDefinition(calcKey).parseLevel || 'reduce';

+    // Special case of effects, when targeting by tags compile
+    if (prop.type === 'effect' && prop.targetByTags) parseLevel = 'compile';
+
    // For all fields matching they keys
    // supports `keys.$.with.$.arrays`
    applyFnToKey(prop, calcKey, (prop, key) => {
--- a/app/imports/api/engine/computation/computeComputation/computeByType/computeCalculation.js
+++ b/app/imports/api/engine/computation/computeComputation/computeByType/computeCalculation.js
@@ -3,4 +3,46 @@ import evaluateCalculation from '../../utility/evaluateCalculation.js';
 export default function computeCalculation(computation, node){
  const calcObj = node.data;
  evaluateCalculation(calcObj, computation.scope);
+  aggregateCalculationEffects(node, computation);
+}
+
+export function aggregateCalculationEffects(node, computation){
+  const calcObj = node.data;
+  delete calcObj.effects;
+  computation.dependencyGraph.forEachLinkedNode(
+    node.id,
+    (linkedNode, link) => {
+      // Only effect links
+      if (link.data !== 'effect') return;
+      // That have effect data
+      if (!linkedNode.data) return;
+      // Ignore inactive props
+      if (linkedNode.data.inactive) return;
+
+      // Collate effects
+      calcObj.effects = calcObj.effects || [];
+      calcObj.effects.push({
+        _id: linkedNode.data._id,
+        name: linkedNode.data.name,
+        operation: linkedNode.data.operation,
+        amount: linkedNode.data.amount && {
+          value: linkedNode.data.amount.value,
+          //parseNode: linkedNode.data.amount.parseNode,
+        },
+        // ancestors: linkedNode.data.ancestors,
+      });
+    },
+    true // enumerate only outbound links
+  );
+  if (calcObj.effects && typeof calcObj.value === 'number'){
+    calcObj.baseValue = calcObj.value;
+    calcObj.effects.forEach(effect => {
+      if (
+        effect.operation === 'add' &&
+        effect.amount && typeof effect.amount.value === 'number'
+      ){
+        calcObj.value += effect.amount.value
+      }
+    });
+  }
 }
--- a/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable.js
+++ b/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable.js
@@ -28,7 +28,7 @@ function aggregateLinks(computation, node){
      // Ignore inactive props
      if (linkedNode.data.inactive) return;
      // Apply all the aggregations
-      let arg = {node, linkedNode, link};
+      let arg = {node, linkedNode, link, computation};
      aggregate.classLevel(arg);
      aggregate.damageMultiplier(arg);
      aggregate.definition(arg);
--- a/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateEffect.js
+++ b/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateEffect.js
@@ -16,10 +16,23 @@ export default function aggregateEffect({node, linkedNode, link}){
    conditional: [],
    rollBonus: [],
  };
+
+  // Store a summary of the effect itself
+  node.data.effects = node.data.effects || [];
+  node.data.effects.push({
+    _id: linkedNode.data._id,
+    name: linkedNode.data.name,
+    operation: linkedNode.data.operation,
+    amount: linkedNode.data.amount && {value: linkedNode.data.amount.value},
+    // ancestors: linkedNode.data.ancestors,
+  });
+
  // get a shorter reference to the aggregator document
  const aggregator = node.data.effectAggregator;
  // Get the result of the effect
  const result = linkedNode.data.amount?.value;
+  // Skip aggregating if the result is not resolved completely
+  if (typeof result === 'string') return;
  // Aggregate the effect based on its operation
  switch(linkedNode.data.operation){
    case 'base':
--- a/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeVariableAsAttribute.js
+++ b/app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeVariableAsAttribute.js
@@ -23,4 +23,7 @@ export default function computeVariableAsAttribute(computation, node, prop){
  prop.hide = !node.data.effectAggregator &&
    prop.baseValue === undefined ||
    undefined
+
+  // Store effects
+  prop.effects = node.data.effects;
 }