Merge branch 'develop' into feature-tabletop

app/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js

@@ -18,23 +18,31 @@ export default function getSlotFillFilter({ slot, libraryIds }) {
       }]
     });
   } else if (slot.type === 'class') {
-    filter.$and.push({
-      $or: [{
-        type: 'classLevel',
-      }, {
-        slotFillerType: 'classLevel',
-      }]
-    });
+    const classLevelFilter = {
+      type: 'classLevel',
+    };
+    const slotFillerFilter = {
+      slotFillerType: 'classLevel',
+    };
+
+    // Match variable name or tags
     if (slot.variableName) {
-      filter.variableName = slot.variableName;
+      classLevelFilter.variableName = slot.variableName;
+      slotFillerFilter.libraryTags = slot.variableName;
     }
 
     // Only search for levels the class needs
     if (slot.missingLevels && slot.missingLevels.length) {
-      filter.level = { $in: slot.missingLevels };
+      classLevelFilter.level = { $in: slot.missingLevels };
+      slotFillerFilter['cache.node.level'] = { $in: slot.missingLevels };
     } else {
-      filter.level = { $gt: slot.level || 0 };
+      classLevelFilter.level = { $gt: slot.level || 0 };
+      slotFillerFilter['cache.node.level'] = { $gt: slot.level || 0 };
     }
+
+    filter.$and.push({
+      $or: [classLevelFilter, slotFillerFilter]
+    });
   }
   let tagsOr = [];
   let tagsNin = [];

app/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js

@@ -105,6 +105,8 @@ function insertPropertyFromNode(nodeId, ancestors, order) {
 
   // Convert all references into actual nodes
   nodes = reifyNodeReferences(nodes);
+  // Refetch the root node, it might have been reified
+  node = nodes[0] || node;
 
   // set libraryNodeIds
   storeLibraryNodeReferences(nodes);

app/imports/api/creature/creatures/Creatures.js

@@ -179,11 +179,6 @@ let CreatureSchema = new SimpleSchema({
     blackbox: true,
     defaultValue: {}
   },
-  variables: {
-    type: Object,
-    blackbox: true,
-    defaultValue: {}
-  },
   computeErrors: {
     type: Array,
     optional: true,

app/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js

@@ -2,9 +2,8 @@ import operator from '/imports/parser/parseTree/operator.js';
 import { parse } from '/imports/parser/parser.js';
 import logErrors from './logErrors.js';
 
-export default function applyEffectsToCalculationParseNode(calcObj, actionContext){
-  if (!calcObj.effects) return;
-  calcObj.effects.forEach(effect => {
+export default function applyEffectsToCalculationParseNode(calcObj, actionContext) {
+  calcObj.effects?.forEach(effect => {
     if (effect.operation !== 'add') return;
     if (!effect.amount) return;
     if (effect.amount.value === null) return;
@@ -17,8 +16,31 @@ export default function applyEffectsToCalculationParseNode(calcObj, actionContex
         operator: '+',
         fn: 'add'
       });
-    } catch (e){
+    } catch (e) {
       logErrors([e], actionContext)
     }
   });
+  // Add the highest proficiency as well
+  let highestProficiency;
+  calcObj.proficiencies?.forEach(proficiency => {
+    if (
+      proficiency.value > highestProficiency
+      || (highestProficiency === undefined && Number.isFinite(proficiency.value))
+    ) {
+      highestProficiency = proficiency.value;
+    }
+  });
+  if (highestProficiency) {
+    try {
+      let profParseNode = parse(highestProficiency.toString());
+      calcObj.parseNode = operator.create({
+        left: calcObj.parseNode,
+        right: profParseNode,
+        operator: '+',
+        fn: 'add'
+      });
+    } catch (e) {
+      logErrors([e], actionContext)
+    }
+  }
 }

app/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js

@@ -2,7 +2,7 @@ import evaluateCalculation from '/imports/api/engine/computation/utility/evaluat
 import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
 import logErrors from './logErrors.js';
 
-export default function recalculateCalculation(calc, actionContext, context){
+export default function recalculateCalculation(calc, actionContext, context) {
   if (!calc?.parseNode) return;
   calc._parseLevel = 'reduce';
   applyEffectsToCalculationParseNode(calc, actionContext);

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

@@ -1,14 +1,14 @@
 import resolve, { toString } from '/imports/parser/resolve.js';
 
-export default function evaluateCalculation(calculation, scope, givenContext){
+export default function evaluateCalculation(calculation, scope, givenContext) {
   const parseNode = calculation.parseNode;
   const fn = calculation._parseLevel;
-  const calculationScope = {...calculation._localScope, ...scope};
-  const {result: resultNode, context} = resolve(fn, parseNode, calculationScope, givenContext);
+  const calculationScope = { ...calculation._localScope, ...scope };
+  const { result: resultNode, context } = resolve(fn, parseNode, calculationScope, givenContext);
   calculation.errors = context.errors;
-  if (resultNode?.parseType === 'constant'){
+  if (resultNode?.parseType === 'constant') {
     calculation.value = resultNode.value;
-  } else if (resultNode?.parseType === 'error'){
+  } else if (resultNode?.parseType === 'error') {
     calculation.value = null;
   } else {
     calculation.value = toString(resultNode);

app/imports/api/library/methods/duplicateLibraryNode.js

@@ -28,8 +28,8 @@ const duplicateLibraryNode = new ValidatedMethod({
   }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
-    numRequests: 1,
-    timeInterval: 5000,
+    numRequests: 4,
+    timeInterval: 6000,
   },
   run({ _id }) {
     let libraryNode = LibraryNodes.findOne(_id);