Made constants work in calculations performed after recomputation

app/imports/api/creature/actions/applyAdjustment.js

@@ -13,42 +13,43 @@ export default function applyAdjustment({
     ...creature.variables,
     ...actionContext,
   };
-  try {
+  var {result, context} = evaluateString({
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce');
+    string: prop.amount,
-    if (typeof result !== 'number') {
+    scope,
-      log.content.push({
+    fn: 'reduce'
-        name: 'Attribute damage',
+  });
-        error: errors.join(', ') || 'Something went wrong',
+  context.errors.forEach(e => {
-      });
-    }
-  } catch (e){
     log.content.push({
-      name: 'Attribute damage',
+      name: 'Attribute damage error',
-      error: e.toString(),
+      error: e.message || e.toString(),
     });
-  }
+  });
   if (damageTargets) {
     damageTargets.forEach(target => {
       if (prop.target === 'each'){
-        result = evaluateString(prop.amount, scope, 'reduce');
+        ({result} = evaluateString({
+          string: prop.amount,
+          scope,
+          fn: 'reduce'
+        }));
       }
       damagePropertiesByName.call({
         creatureId: target._id,
         variableName: prop.stat,
         operation: prop.operation || 'increment',
-        value: result
+        value: result.value,
       });
       log.content.push({
         name: 'Attribute damage',
         resultPrefix: `${prop.stat} ${prop.operation === 'set' ? 'set to' : ''}`,
-        result: `${-result}`,
+        result: `${result.isNumber ? -result.value : result.toString()}`,
       });
     });
   } else {
     log.content.push({
       name: 'Attribute damage',
       resultPrefix: `${prop.stat} ${prop.operation === 'set' ? 'set to' : ''}`,
-      result: `${-result}`,
+      result: `${result.isNumber ? -result.value : result.toString()}`,
     });
   }
 }

app/imports/api/creature/actions/applyDamage.js

@@ -15,49 +15,79 @@ export default function applyDamage({
     ...creature.variables,
     ...actionContext,
   };
+  // Add the target's variables to the scope
   if (targets.length === 1){
     scope.target = targets[0].variables;
   }
+  // Determine if the hit is critical
   let criticalHit = !!(
     actionContext.criticalHit &&
     actionContext.criticalHit.value &&
     prop.damageType !== 'healing' // Can't critically heal
   );
+  // Double the damage rolls if the hit is critical
   let context = new CompilationContext({
     doubleRolls: criticalHit,
   });
-  try {
+
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce', context);
+  // Compute the roll the first time, logging any errors
-    if (typeof result !== 'number') {
+  var {result} = evaluateString({
-      log.content.push({
+    string: prop.amount,
-        error: errors.join(', '),
+    scope,
-      });
+    fn: 'reduce',
-    }
+    context
-  } catch (e){
+  });
+
+  // If the result is an error bail out now
+  if (result.constructor.name === 'ErrorNode'){
     log.content.push({
-      error: e.toString(),
+      name: 'Damage error',
+      error: result.toString(),
     });
+    return;
   }
+
+  // Memoise the damage suffix for the log
   let suffix = (criticalHit ? ' critical ' : '') +
     prop.damageType +
     (prop.damageType !== 'healing' ? ' damage': '');
 
   if (damageTargets && damageTargets.length) {
+    // Iterate through all the targets
     damageTargets.forEach(target => {
       let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
+
+      // Reroll the damage if needed
       if (prop.target === 'each'){
-        result = evaluateString(prop.amount, scope, 'reduce');
+        ({result, context} = evaluateString({
+          string: prop.amount,
+          scope,
+          fn: 'reduce'
+        }));
       }
+      // If the result is an error or not a number bail out now
+      if (result.constructor.name === 'ErrorNode' || !result.isNumber){
+        log.content.push({
+          name: 'Damage error',
+          error: result.toString(),
+        });
+        return;
+      }
+
+      // Deal the damage to the target
       let damageDealt = dealDamage.call({
         creatureId: target._id,
         damageType: prop.damageType,
-        amount: result,
+        amount: result.value,
       });
+
+      // Log the damage done
       if (target._id === creature._id){
+        // Target is same as self, log damage as such
         log.content.push({
           name,
           result: damageDealt,
-          details: suffix + 'to self',
+          details: suffix + ' to self',
         });
       } else {
         log.content.push({
@@ -66,6 +96,7 @@ export default function applyDamage({
           result: damageDealt,
           details: suffix + `${target.name && ' to '}${target.name}`,
         });
+        // Log the damage received on that creature's log as well
         insertCreatureLog.call({
           log: {
             content: [{
@@ -80,9 +111,10 @@ export default function applyDamage({
       }
     });
   } else {
+    // There are no targets, just log the result
     log.content.push({
       name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
-      result,
+      result: result.toString(),
       details: suffix,
     });
   }

app/imports/api/creature/actions/applyRoll.js

@@ -10,23 +10,17 @@ export default function applyRoll({
     ...creature.variables,
     ...actionContext,
   };
-  try {
+  var {result} = evaluateString({
-    var {result, errors} = evaluateString(prop.roll, scope, 'reduce');
+    string: prop.roll,
-    actionContext[prop.variableName] = result;
+    scope,
-    log.content.push({
+    fn: 'reduce'
-      name: prop.name,
+  });
-      resultPrefix: prop.variableName + ' = ' + prop.roll + ' = ',
+  if (result.isNumber){
-      result,
+    actionContext[prop.variableName] = result.value;
-    });
-    if (errors.length) {
-      log.content.push({
-        error: errors.join(', '),
-      });
-    }
-
-  } catch (e){
-    log.content.push({
-      error: e.toString(),
-    });
   }
+  log.content.push({
+    name: prop.name,
+    resultPrefix: prop.variableName + ' = ' + prop.roll + ' = ',
+    result: result.toString(),
+  });
 }

app/imports/api/creature/actions/applySave.js

@@ -14,19 +14,17 @@ export default function applySave({
   };
   try {
     // Calculate the DC
-    var {result, errors} = evaluateString(prop.dc, scope, 'reduce');
+    var {result} = evaluateString({
-    let dc = result;
+      string: prop.dc,
+      scope,
+      fn: 'reduce'
+    });
+    let dc = result.value;
     log.content.push({
       name: prop.name,
       resultPrefix: ' DC ',
-      result,
+      result: result.toString(),
     });
-    if (errors.length) {
-      log.content.push({
-        error: errors.join(', '),
-      });
-      return false;
-    }
     if (prop.target === 'self'){
       let save = CreaturesProperties.findOne({
         'ancestors.id': creature._id,

app/imports/api/creature/actions/applyToggle.js

@@ -13,23 +13,22 @@ export default function applyToggle({
   if (Number.isFinite(+prop.condition)){
     return !!+prop.condition;
   }
-  try {
+  var {result} = evaluateString({
-    var {result, errors} = evaluateString(prop.condition, scope, 'reduce');
+    string: prop.condition,
-    if (typeof result !== 'number' && typeof result !== 'boolean') {
+    scope,
-      log.content.push({
+    fn: 'reduce'
-        error: errors.join(', '),
+  });
-      });
+  if (result.constructor.name === 'ErrorNode') {
-      return false;
-    }
     log.content.push({
-      name: prop.name,
+      name: 'Toggle error',
-      resultPrefix: prop.condition + ' = ',
+      error: result.toString(),
-      result,
-    });
-    return !!result;
-  } catch (e){
-    log.content.push({
-      error: e.toString(),
     });
+    return false;
   }
+  log.content.push({
+    name: prop.name || 'Toggle',
+    resultPrefix: prop.condition + ' = ',
+    result: result.toString(),
+  });
+  return !!result.value;
 }

app/imports/api/creature/computation/afterComputation/evaluateString.js

@@ -1,32 +1,67 @@
 import { parse, CompilationContext } from '/imports/parser/parser.js';
 import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
+import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
+import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
 
 //TODO replace constants with their parsed node
 
-export default function evaluateString(string, scope, fn = 'compile', context){
+export default function evaluateString({string, scope, fn = 'compile', context}){
-  let errors = [];
+  if (!context){
+    context = new CompilationContext({});
+  }
   if (!string){
-    errors.push('No string provided');
+    context.storeError('No string provided');
-    return {result: string, errors};
+    return {result: {value: string}, context};
   }
 
-  if (!scope) errors.push('No scope provided');
+  if (!scope) context.storeError('No scope provided');
 
   // Parse the string using mathjs
   let node;
   try {
     node = parse(string);
   } catch (e) {
-    errors.push(e);
+    context.storeError(e);
-    return {result: string, errors};
+    return {result: {value: string}, context};
-  }
-  if (!context){
-    context = new CompilationContext({});
   }
+  node = replaceConstants({calc: node, context, scope});
   let result = node[fn](scope, context);
-  if (result instanceof ConstantNode){
+  return {result, context};
-    return {result: result.value, errors: context.errors}
+}
-  } else {
+
-    return {result: result.toString(), errors: context.errors};
+// Replace constants in the calc with the right ParseNodes
-  }
+function replaceConstants({calc, context, scope}){
+  let constFailed = [];
+  calc = calc.replaceNodes(node => {
+    if (!(node instanceof SymbolNode)) return;
+    let constant = scope[node.name];
+    // replace constants that aren't overridden by stats or disabled by a toggle
+    if (constant && constant.type === 'constant'){
+      // Fail if the constant has errors
+      if (constant.errors && constant.errors.length){
+        constFailed.push(node.name);
+        return;
+      }
+      let parsedConstantNode;
+      try {
+        parsedConstantNode = parse(constant.calculation);
+      } catch(e){
+        constFailed.push(node.name);
+        return;
+      }
+      if (!parsedConstantNode) constFailed.push(node.name);
+      return parsedConstantNode;
+    }
+  });
+  constFailed.forEach(name => {
+    context.storeError({
+      type: 'error',
+      message: `${name} is a constant property with parsing errors`
+    });
+  });
+  let failed = !!constFailed.length;
+  if (failed){
+    calc = new ErrorNode({error: 'Failed to replace constants'});
+  }
+  return calc;
 }

app/imports/api/creature/computation/engine/writeCreatureVariables.js

@@ -4,28 +4,30 @@ import VERSION from '/imports/constants/VERSION.js';
 
 export default function writeCreatureVariables(memo, creatureId, fullRecompute = true) {
   const fields = [
-    'name',
-    'attributeType',
-    'baseValue',
-    'spellSlotLevelValue',
-    'damage',
-    'decimal',
-    'reset',
-    'resetMultiplier',
-    'value',
-    'currentValue',
-    'modifier',
     'ability',
-    'skillType',
-    'baseProficiency',
     'abilityMod',
     'advantage',
-    'passiveBonus',
+    'attributeType',
-    'proficiency',
+    'baseProficiency',
+    'baseValue',
+    'calculation',
     'conditionalBenefits',
-    'rollBonuses',
+    'currentValue',
+    'damage',
+    'decimal',
     'fail',
     'level',
+    'modifier',
+    'name',
+    'passiveBonus',
+    'proficiency',
+    'reset',
+    'resetMultiplier',
+    'rollBonuses',
+    'skillType',
+    'spellSlotLevelValue',
+    'type',
+    'value',
   ];
 
   if (fullRecompute){
@@ -34,6 +36,12 @@ export default function writeCreatureVariables(memo, creatureId, fullRecompute =
       let condensedStat = pick(stat, fields);
       memo.creatureVariables[variableName] = condensedStat;
     });
+    forOwn(memo.constantsByVariableName, (stat, variableName) => {
+      let condensedStat = pick(stat, fields);
+      if (!memo.creatureVariables[variableName]){
+        memo.creatureVariables[variableName] = condensedStat;
+      }
+    });
     Creatures.update(creatureId, {$set: {
       variables: memo.creatureVariables,
       computeVersion: VERSION,

app/imports/ui/creature/slots/SlotFillDialog.vue

@@ -143,10 +143,10 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 import LibraryNodes from '/imports/api/library/LibraryNodes.js';
 import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
 import { getPropertyName } from '/imports/constants/PROPERTIES.js';
-import { parse, CompilationContext } from '/imports/parser/parser.js';
 import PROPERTIES from '/imports/constants/PROPERTIES.js';
 import TreeNodeView from '/imports/ui/properties/treeNodeViews/TreeNodeView.vue';
 import PropertyDescription from '/imports/ui/properties/viewers/shared/PropertyDescription.vue'
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
 
 export default {
   components: {
@@ -243,15 +243,12 @@ export default {
       // the quantity to fill
       nodes = nodes.filter(node => {
         if (node.slotFillerCondition){
-          let context = new CompilationContext();
+          let {result} = evaluateString({
-          let conditionResult;
+            string: node.slotFillerCondition,
-          try {
+            scope: this.creature.variables,
-            conditionResult = parse(node.slotFillerCondition)
+            fn: 'reduce',
-            .reduce(this.creature.variables, context);
+          });
-          } catch (e){
+          if (!result.value) return false;
-            console.warn(e);
-          }
-          if (conditionResult && !conditionResult.value) return false;
         }
         if (
           node.type === 'slotFiller' &&