Added constants to the UI and Computation Engine

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

@@ -6,6 +6,7 @@ import findAncestorByType from '/imports/api/creature/computation/engine/findAnc
 export default class ComputationMemo {
   constructor(props, creature){
     this.statsByVariableName = {};
+    this.constantsByVariableName = {};
     this.extraStatsByVariableName = {};
     this.statsById = {};
     this.originalPropsById = {};
@@ -51,13 +52,15 @@ export default class ComputationMemo {
         return true;
       }
     }).forEach((prop) => {
-      // Now add all effects and proficiencies
+      // Now add everything else
       if (prop.type === 'effect'){
         this.addEffect(prop);
       } else if (prop.type === 'proficiency') {
         this.addProficiency(prop);
       } else if (prop.type === 'classLevel'){
         this.addClassLevel(prop);
+      } else if (prop.type === 'constant'){
+        this.addConstant(prop);
       } else {
         this.addEndStepProp(prop);
       }
@@ -72,6 +75,14 @@ export default class ComputationMemo {
       }
     }
   }
+  addConstant(prop){
+    prop = this.registerProperty(prop);
+    if (
+      !this.constantsByVariableName[prop.variableName]
+    ){
+      this.constantsByVariableName[prop.variableName] = prop
+    }
+  }
   registerProperty(prop){
     this.originalPropsById[prop._id] = cloneDeep(prop);
     this.propsById[prop._id] = prop;

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

@@ -42,11 +42,75 @@ export default function evaluateCalculation({
       dependencies,
     };
   }
+
+  // Replace constants with their parsed constant
+  let failed = replaceConstants({calc, memo, prop, dependencies, errors})
+  if (failed){
+    return {
+      context: {errors},
+      result: new ConstantNode({value: string, type: 'string'}),
+      dependencies,
+    };
+  }
+
   // Ensure all symbol nodes are defined and computed
+  computeSymbols({calc, memo, prop, dependencies})
+
+  // Evaluate
+  let context = new CompilationContext();
+  let result = calc[fn](memo.statsByVariableName, context);
+  return {result, context, dependencies};
+}
+
+// Replace constants in the calc with the right ParseNodes
+function replaceConstants({calc, memo, prop, dependencies, errors}){
+  let constFailed = [];
+  calc.replaceNodes(node => {
+    if (!(node instanceof SymbolNode)) return;
+    let stat, constant;
+    if (node.name[0] !== '#'){
+      stat = memo.statsByVariableName[node.name]
+      constant = memo.constantsByVariableName[node.name];
+    } else if (node.name === '#constant'){
+      constant = findAncestorByType({type: 'constant', prop, memo});
+    }
+    // replace constants that aren't overridden by stats
+    if (constant && !stat){
+      dependencies = union(dependencies, [
+        constant._id,
+        ...constant.dependencies
+      ]);
+      // 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 => {
+    errors.push({
+      type: 'error',
+      message: `${name} is a constant property with parsing errors`
+    });
+  });
+  return !!constFailed.length;
+}
+
+  // Ensure all symbol nodes are defined and computed
+function computeSymbols({calc, memo, prop, dependencies}){
   calc.traverse(node => {
     if (node instanceof SymbolNode || node instanceof AccessorNode){
-      // References up the tree start with $
       let stat;
+      // References up the tree start with #
       if (node.name[0] === '#'){
         stat = findAncestorByType({type: node.name.slice(1), prop, memo});
         memo.statsByVariableName[node.name] = stat;
@@ -64,8 +128,4 @@ export default function evaluateCalculation({
       }
     }
   });
-  // Evaluate
-  let context = new CompilationContext();
-  let result = calc[fn](memo.statsByVariableName, context);
-  return {result, context, dependencies};
 }