78 lines
2.2 KiB
JavaScript
78 lines
2.2 KiB
JavaScript
import math from '/imports/math.js';
|
|
import bareSymbolSubtitutor from '/imports/api/creature/computation/utility/bareSymbolSubtitutor.js';
|
|
import substituteRollsWithFunctions from '/imports/api/creature/computation/afterComputation/substituteRollsWithFunctions.js'
|
|
|
|
export default function evaluateAndRollString(string, scope){
|
|
let errors = [];
|
|
if (!string){
|
|
errors.push('No string provided');
|
|
return {result: string, errors};
|
|
}
|
|
|
|
if (!scope) errors.push('No scope provided');
|
|
|
|
// Parse the string using mathjs
|
|
let calc;
|
|
try {
|
|
calc = math.parse(string);
|
|
} catch (e) {
|
|
errors.push(e);
|
|
return {result: string, errors};
|
|
}
|
|
|
|
// Replace all bare symbols with symbol.value
|
|
let transformedCalc = calc.transform(bareSymbolSubtitutor(scope));
|
|
// Replace all rolls with the function to call them
|
|
transformedCalc = calc.transform(substituteRollsWithFunctions);
|
|
|
|
// Evaluate the expression to a number or return with substitutions
|
|
try {
|
|
let result = transformedCalc.evaluate(scope);
|
|
return {result, errors};
|
|
} catch (e1){
|
|
errors.push(e1);
|
|
try {
|
|
let result = simplifyWithAccessors(transformedCalc, scope).toHTML();
|
|
return {result, errors};
|
|
} catch (e2){
|
|
errors.push(e2);
|
|
return {result: transformedCalc.toHTML(), errors};
|
|
}
|
|
}
|
|
}
|
|
|
|
function simplifyWithAccessors(calc, scope){
|
|
let noAccessorCalc = calc.transform(substituteAccessors(scope));
|
|
return math.simplify(noAccessorCalc);
|
|
}
|
|
|
|
// returns a function to replace all accessors with either their resolved value
|
|
// or a symbol to simplify with
|
|
function substituteAccessors(scope){
|
|
return function(node){
|
|
if (node.isAccessorNode){
|
|
try {
|
|
return evaluateAccessor(node, scope);
|
|
} catch (e) {
|
|
return replaceAccessorWithSymbol(node);
|
|
}
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Throws error if symbol is undefined in scope
|
|
function evaluateAccessor(node, scope){
|
|
let value = node.evaluate(scope);
|
|
if (value === undefined){
|
|
throw 'Undefined symbol'
|
|
}
|
|
return new math.ConstantNode(value);
|
|
}
|
|
|
|
function replaceAccessorWithSymbol(node){
|
|
let symbolNode = new math.SymbolNode(node.toString());
|
|
return symbolNode;
|
|
}
|