Referencing a missing variable in an effect now returns zero, not an error

app/imports/api/creature/computation/evaluateCalculation.js

@@ -1,15 +1,20 @@
-import bareSymbolSubtitutor from '/imports/api/creature/computation/utility/bareSymbolSubtitutor.js';
 import computeStat from '/imports/api/creature/computation/computeStat.js';
 import math from '/imports/math.js';
 
+/* Convert a calculation into a constant output and errors*/
 export default function evaluateCalculation(string, memo){
   if (!string) return string;
+  let errors = [];
   // Parse the string using mathjs
   let calc;
   try {
     calc = math.parse(string);
   } catch (e) {
-    return string;
+    errors.push({
+      type: 'parsing',
+      message: e.message || e
+    });
+    return {errors, value: string};
   }
   // Ensure all symbol nodes are defined and coputed
   calc.traverse(node => {
@@ -20,12 +25,73 @@ export default function evaluateCalculation(string, memo){
       }
     }
   });
-  // Ensure any bare symbols are value accessors instead
-  let substitutedCalc = calc.transform(bareSymbolSubtitutor(memo.statsByVariableName));
+  // Replace all symbols with their subtitution
+  let substitutedCalc = calc.transform(
+    symbolSubtitutor(memo.statsByVariableName, errors)
+  );
   // Evaluate the expression to a number or return with substitutions
   try {
-    return substitutedCalc.evaluate(memo.statsByVariableName);
+    let value = substitutedCalc.evaluate(memo.statsByVariableName);
+    return {errors, value};
   } catch (e){
-    return substitutedCalc.toString();
+    errors.push({
+      type: 'evaluation',
+      message: e.message || e
+    });
+    let value = substitutedCalc.toString();
+    return {errors, value};
+  }
+}
+
+// returns a function to replace all symbols with either their resolved value
+// or zero, keeping the errors
+function symbolSubtitutor(scope, errors){
+  return function(node){
+    // mark symbol nodes that are children of function nodes to be skipped
+    if (node.isFunctionNode){
+      let fn = node.fn;
+      if (fn && fn.isSymbolNode){
+        fn.skipReplacement = true;
+      }
+      return node;
+    } else if (node.isSymbolNode && node.skipReplacement !== true){
+      //bare symbols of name "stat", should search for stat.value
+      let stat = scope[node.name];
+      if (stat){
+        if (stat.value === undefined){
+          errors.push({
+            type: 'subsitution',
+            message: `${node.name} does not have a value, set to 0`
+          });
+          return new math.ConstantNode(0);
+        } else {
+          return new math.ConstantNode(stat.value);
+        }
+      } else {
+        try {
+          return new math.ConstantNode(node.evaluate(scope));
+        } catch (e) {
+          errors.push({
+            type: 'subsitution',
+            message: `${node.name} not found, set to 0`
+          });
+          return new math.ConstantNode(0);
+        }
+      }
+    } else if (node.isAccessorNode){
+      try {
+        let value = node.evaluate(scope);
+        if (value === undefined) throw 'Not found';
+        return new math.ConstantNode(value);
+      } catch (e) {
+        errors.push({
+          type: 'subsitution',
+          message: `${node.toString()} not found, set to 0`
+        });
+        return new math.ConstantNode(0);
+      }
+    } else {
+      return node;
+    }
   }
 }