Fixed: buffs

app/imports/api/creature/Creatures.js

@@ -92,8 +92,32 @@ let CreatureSchema = new SimpleSchema({
     type: SimpleSchema.Integer,
     defaultValue: 0,
   },
-  // Sum of all weights of items and containers that are carried
+  // Inventory
-	'denormalizedStats.weightCarried': {
+	'denormalizedStats.weightTotal': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.weightEquipment': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.weightCarried': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.valueTotal': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.valueEquipment': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.valueCarried': {
+		type: Number,
+		defaultValue: 0,
+	},
+  'denormalizedStats.itemsAttuned': {
 		type: Number,
 		defaultValue: 0,
 	},

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

@@ -4,12 +4,19 @@ export default function applyAttack({
   prop,
   log,
   actionContext,
+  creature,
 }){
   let value = roll(1, 20)[0];
   actionContext.attackRoll = {value};
+  let criticalHitTarget = creature.variables.criticalHitTarget &&
+    creature.variables.criticalHitTarget.currentValue || 20;
+  let criticalHit = value >= criticalHitTarget;
+  if (criticalHit) actionContext.criticalHit = {value: true};
   let result = value + prop.rollBonusResult;
+  actionContext.toHit = {value: result};
+
   log.content.push({
-    name: 'To Hit',
+    name: criticalHit ? 'Critical Hit!' : 'To Hit',
     resultPrefix: `1d20 [${value}] + ${prop.rollBonusResult} = `,
     result,
   });

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

@@ -4,6 +4,7 @@ import {
 } from '/imports/api/parenting/parenting.js';
 import {setDocToLastOrder} from '/imports/api/parenting/order.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 
 export default function applyBuff({
   prop,
@@ -57,5 +58,10 @@ function copyNodeListToTarget(propList, target, oldParent){
     collection: CreatureProperties,
     doc: propList[0],
   });
-  CreatureProperties.batchInsert(propList);
+
+  CreatureProperties.batchInsert(propList, () => {
+    // This insert is racing the main recompute, recmpute again after it's
+    // certainly finished
+    recomputeCreatureByDoc(target);
+  });
 }

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

@@ -1,6 +1,7 @@
 import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
 import dealDamage from '/imports/api/creature/creatureProperties/methods/dealDamage.js';
 import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.js';
+import { CompilationContext } from '/imports/parser/parser.js';
 
 export default function applyDamage({
   prop,
@@ -14,8 +15,19 @@ export default function applyDamage({
     ...creature.variables,
     ...actionContext,
   };
+  if (targets.length === 1){
+    scope.target = targets[0].variables;
+  }
+  let criticalHit = !!(
+    actionContext.criticalHit &&
+    actionContext.criticalHit.value &&
+    prop.damageType !== 'healing' // Can't critically heal
+  );
+  let context = new CompilationContext({
+    doubleRolls: criticalHit,
+  });
   try {
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce');
+    var {result, errors} = evaluateString(prop.amount, scope, 'reduce', context);
     if (typeof result !== 'number') {
       log.content.push({
         error: errors.join(', '),
@@ -26,11 +38,13 @@ export default function applyDamage({
       error: e.toString(),
     });
   }
+  let suffix = (criticalHit ? ' critical ' : '') +
+    prop.damageType +
+    (prop.damageType !== 'healing' ? ' damage': '');
+
   if (damageTargets && damageTargets.length) {
     damageTargets.forEach(target => {
       let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-      let suffix = prop.damageType +
-        prop.damageType !== 'healing' ? ' damage': '';
       if (prop.target === 'each'){
         result = evaluateString(prop.amount, scope, 'reduce');
       }
@@ -69,7 +83,7 @@ export default function applyDamage({
     log.content.push({
       name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
       result,
-      details: `${prop.damageType}${prop.damageType !== 'healing'? ' damage': ''}`,
+      details: suffix,
     });
   }
 }

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

@@ -1,8 +1,11 @@
 import applyAction from '/imports/api/creature/actions/applyAction.js';
 import applyAdjustment from '/imports/api/creature/actions/applyAdjustment.js';
 import applyAttack from '/imports/api/creature/actions/applyAttack.js';
-import applyDamage from '/imports/api/creature/actions/applyDamage.js';
 import applyBuff from '/imports/api/creature/actions/applyBuff.js';
+import applyDamage from '/imports/api/creature/actions/applyDamage.js';
+import applyRoll from '/imports/api/creature/actions/applyRoll.js';
+import applyToggle from '/imports/api/creature/actions/applyToggle.js';
+import applySave from '/imports/api/creature/actions/applySave.js';
 
 function applyProperty(options){
   let prop = options.prop;
@@ -11,8 +14,13 @@ function applyProperty(options){
     if (prop.applied === true){
       return false;
     }
+  // Only ignore toggles if they wont be computed
+  } else if (prop.type === 'toggle') {
+    if (prop.disabled) return false;
+    if (prop.enabled) return true;
+    if (!prop.condition) return false;
   // Ignore inactive props of other types
-  } else if (prop.inactive === true){
+  } else if (prop.deactivatedBySelf === true){
     return false;
   }
   switch (prop.type){
@@ -33,40 +41,41 @@ function applyProperty(options){
     case 'buff':
       applyBuff(options);
       break;
+    case 'toggle':
+      return applyToggle(options);
     case 'roll':
-      // applyRoll(options);
+      applyRoll(options);
       break;
     case 'savingThrow':
-      // applySavingThrow(options);
+      return applySave(options);
-      break;
   }
   return true;
 }
 
-export default function applyProperties({
+function applyPropertyAndWalkChildren({prop, children, targets, ...options}){
-  forest,
+  let shouldKeepWalking = applyProperty({ prop, children, targets, ...options });
-  creature,
+  if (shouldKeepWalking){
-  targets,
+    applyProperties({ forest: children, targets, ...options,});
-  actionContext,
+  }
-  log,
+}
-}){
+
-  forest.forEach(child => {
+export default function applyProperties({ forest, targets, ...options}){
-    let walkChildren = applyProperty({
+  forest.forEach(node => {
-      prop: child.node,
+    let prop = node.node;
-      children: child.children,
+    let children = node.children;
-      creature,
+    if (shouldSplit(prop) && targets.length){
-      targets,
+      targets.forEach(target => {
-      actionContext,
+        let targets = [target]
-      log,
+        applyPropertyAndWalkChildren({ targets, prop, children, ...options});
-    });
-    if (walkChildren){
-      applyProperties({
-        forest: child.children,
-        creature,
-        targets,
-        actionContext,
-        log,
       });
+    } else {
+      applyPropertyAndWalkChildren({prop, children, targets, ...options});
     }
   });
 }
+
+function shouldSplit(prop){
+  if (prop.target === 'each'){
+    return true;
+  }
+}

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

@@ -0,0 +1,32 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+
+export default function applyRoll({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  try {
+    var {result, errors} = evaluateString(prop.roll, scope, 'reduce');
+    actionContext[prop.variableName] = result;
+    log.content.push({
+      name: prop.name,
+      resultPrefix: prop.variableName + ' = ' + prop.roll + ' = ',
+      result,
+    });
+    if (errors.length) {
+      log.content.push({
+        error: errors.join(', '),
+      });
+    }
+
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -0,0 +1,79 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+import CreaturesProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import roll from '/imports/parser/roll.js';
+
+export default function applySave({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  try {
+    // Calculate the DC
+    var {result, errors} = evaluateString(prop.dc, scope, 'reduce');
+    let dc = result;
+    log.content.push({
+      name: prop.name,
+      resultPrefix: ' DC ',
+      result,
+    });
+    if (errors.length) {
+      log.content.push({
+        error: errors.join(', '),
+      });
+      return false;
+    }
+    if (prop.target === 'self'){
+      let save = CreaturesProperties.findOne({
+        'ancestors.id': creature._id,
+        type: 'skill',
+        skillType: 'save',
+        variableName: prop.stat,
+        removed: {$ne: true},
+        inactive: {$ne: true},
+      });
+      if (!save){
+        log.content.push({
+          error: 'No saving throw found: ' + prop.stat,
+        });
+        return;
+      }
+      let value, values, resultPrefix;
+      if (save.advantage === 1){
+        values = roll(2, 20).sort().reverse();
+        value = values[0];
+        resultPrefix = `Advantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
+      } else if (save.advantage === -1){
+        values = roll(2, 20).sort();
+        value = values[0];
+        resultPrefix = `Disadvantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
+      } else {
+        values = roll(1, 20);
+        value = values[0];
+        resultPrefix = `1d20 [${value}] + ${save.value} = `
+      }
+      actionContext.savingThrowRoll = {value};
+      let result = value + save.value;
+      actionContext.savingThrow = {value: result};
+      let saveSuccess = result >= dc;
+      log.content.push({
+        name: 'Save',
+        resultPrefix,
+        result,
+        details: saveSuccess ? 'Passed' : 'Failed'
+      });
+      return !saveSuccess;
+    } else {
+      // TODO
+      return true;
+    }
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -0,0 +1,35 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+
+export default function applyToggle({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  if (Number.isFinite(+prop.condition)){
+    return !!+prop.condition;
+  }
+  try {
+    var {result, errors} = evaluateString(prop.condition, scope, 'reduce');
+    if (typeof result !== 'number' && typeof result !== 'boolean') {
+      log.content.push({
+        error: errors.join(', '),
+      });
+      return false;
+    }
+    log.content.push({
+      name: prop.name,
+      resultPrefix: prop.condition + ' = ',
+      result,
+    });
+    return !!result;
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -9,6 +9,7 @@ import { assertEditPermission } from '/imports/api/creature/creaturePermissions.
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import { nodesToTree } from '/imports/api/parenting/parenting.js';
 import applyProperties from '/imports/api/creature/actions/applyProperties.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const doAction = new ValidatedMethod({
   name: 'creatureProperties.doAction',
@@ -43,6 +44,8 @@ const doAction = new ValidatedMethod({
     });
 		doActionWork({action, creature, targets, method: this});
 
+    // The acting creature might have used ammo
+    recomputeInventory(creature._id);
     // recompute creatures
 		recomputeCreatureByDoc(creature);
     targets.forEach(target => {

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

@@ -4,8 +4,8 @@ export default function embedInlineCalculations(string, calculations){
   if (!string) return '';
   if (!calculations) return string;
   let index = 0;
-  return string.replace(INLINE_CALCULATION_REGEX, () => {
+  return string.replace(INLINE_CALCULATION_REGEX, substring => {
     let comp = calculations && calculations[index++];
-    return comp && comp.result ? comp.result : string;
+    return (comp && 'result' in comp) ? comp.result : substring;
   });
 }

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

@@ -1,7 +1,7 @@
 import { parse, CompilationContext } from '/imports/parser/parser.js';
 import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
 
-export default function evaluateString(string, scope, fn = 'compile'){
+export default function evaluateString(string, scope, fn = 'compile', context){
   let errors = [];
   if (!string){
     errors.push('No string provided');
@@ -18,7 +18,9 @@ export default function evaluateString(string, scope, fn = 'compile'){
     errors.push(e);
     return {result: string, errors};
   }
-  let context = new CompilationContext();
+  if (!context){
+    context = new CompilationContext({});
+  }
   let result = node[fn](scope, context);
   if (result instanceof ConstantNode){
     return {result: result.value, errors: context.errors}

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

@@ -14,7 +14,7 @@ export default class EffectAggregator{
         prop: stat,
         memo
       });
-      this.statBaseValue = result.value;
+      this.statBaseValue = +result.value;
       stat.dependencies = union(
         stat.dependencies,
         dependencies,

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

@@ -14,16 +14,22 @@ export default function computeEndStepProperty(prop, memo){
       break;
     case 'attack':
       computeAction(prop, memo);
-      computeAttack(prop, memo);
+      computePropertyField(prop, memo, 'rollBonus');
       break;
     case 'savingThrow':
-      computeSavingThrow(prop, memo);
+      computePropertyField(prop, memo, 'dc');
       break;
     case 'spellList':
-      computeSpellList(prop, memo);
+      computePropertyField(prop, memo, 'maxPrepared');
+      computePropertyField(prop, memo, 'attackRollBonus');
+      computePropertyField(prop, memo, 'dc');
       break;
     case 'propertySlot':
-      computeSlot(prop, memo);
+      computePropertyField(prop, memo, 'quantityExpected');
+      computePropertyField(prop, memo, 'slotCondition');
+      break;
+    case 'roll':
+      computePropertyField(prop, memo, 'roll', 'compile');
       break;
   }
 }
@@ -111,19 +117,3 @@ function computePropertyField(prop, memo, fieldName, fn){
     delete prop[`${fieldName}Errors`];
   }
 }
-
-function computeAttack(prop, memo){
-  computePropertyField(prop, memo, 'rollBonus');
-}
-
-function computeSavingThrow(prop, memo){
-  computePropertyField(prop, memo, 'dc');
-}
-
-function computeSpellList(prop, memo){
-  computePropertyField(prop, memo, 'maxPrepared');
-}
-
-function computeSlot(prop, memo){
-  computePropertyField(prop, memo, 'slotCondition');
-}

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

@@ -21,6 +21,9 @@ export default function evaluateCalculation({
     context,
     dependencies,
   };
+  if (typeof string !== 'string'){
+    string = string.toString();
+  }
   // Parse the string
   let calc;
   try {
@@ -119,10 +122,14 @@ function computeSymbols({calc, memo, prop, dependencies}){
         computeStat(stat, memo);
       }
       if (stat){
-        dependencies = union(dependencies, [
+        if (stat.dependencies){
-          stat._id || node.name,
+          dependencies = union(dependencies, [
-          ...stat.dependencies
+            stat._id || node.name,
-        ]);
+            ...stat.dependencies
+          ]);
+        } else {
+          dependencies = union(dependencies, [stat._id || node.name]);
+        }
       }
     }
   });

app/imports/api/creature/creatureProperties/CreatureProperties.js

@@ -43,6 +43,13 @@ let CreaturePropertySchema = new SimpleSchema({
     optional: true,
     index: 1,
   },
+  // Denormalised flag if this property was made inactive because of its own
+  // state
+  deactivatedBySelf: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+  },
   // Denormalised list of all properties or creatures this property depends on
   dependencies: {
     type: Array,

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

@@ -4,7 +4,8 @@ import SimpleSchema from 'simpl-schema';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 
 const adjustQuantity = new ValidatedMethod({
   name: 'creatureProperties.adjustQuantity',
@@ -30,8 +31,10 @@ const adjustQuantity = new ValidatedMethod({
     // Do work
     adjustQuantityWork({property, operation, value});
 
-    // Changing quantity does not change dependencies, recompute deps
+    // Changing quantity does not change dependencies, but recomputing the
-    recomputePropertyDependencies(property);
+    // inventory changes many deps at once, so recompute fully
+    recomputeCreatureByDoc(rootCreature);
+    recomputeInventory(rootCreature._id);
   },
 });
 

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

@@ -4,6 +4,8 @@ import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 import INVENTORY_TAGS from '/imports/constants/INVENTORY_TAGS.js';
 
 export function getParentRefByTag(creatureId, tag){
@@ -49,7 +51,7 @@ const equipItem = new ValidatedMethod({
 		});
     let tag = equipped ? INVENTORY_TAGS.equipment : INVENTORY_TAGS.carried;
     let parentRef = getParentRefByTag(creature._id, tag);
-    // organizeDoc handles recompuation
+
     organizeDoc.call({
       docRef: {
         id: _id,
@@ -57,7 +59,11 @@ const equipItem = new ValidatedMethod({
       },
       parentRef,
       order: Number.MAX_SAFE_INTEGER,
+      skipRecompute: true,
     });
+
+    recomputeInventory(creature._id);
+    recomputeCreatureByDoc(creature);
   },
 });
 

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

@@ -6,6 +6,7 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import { reorderDocs } from '/imports/api/parenting/order.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const insertProperty = new ValidatedMethod({
   name: 'creatureProperties.insert',
@@ -35,6 +36,11 @@ export function insertPropertyWork({property, creature}){
   });
   // Inserting the active status of the property needs to be denormalised
   recomputeInactiveProperties(creature._id);
+
+  // Recompute the inventory if it has changed
+  if (property.type === 'item' || property.type === 'container'){
+    recomputeInventory(creature._id);
+  }
   // Inserting a creature property invalidates dependencies: full recompute
   recomputeCreatureByDoc(creature);
   return _id;

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

@@ -15,6 +15,7 @@ import {
 } from '/imports/api/parenting/parenting.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
 import { setDocToLastOrder } from '/imports/api/parenting/order.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
 	name: 'creatureProperties.insertPropertyFromLibraryNode',
@@ -97,6 +98,8 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 
     // The library properties need to denormalise which of them are inactive
     recomputeInactiveProperties(rootId);
+    // Some of the library properties may be items or containers
+    recomputeInventory(rootCreature._id);
 		// Inserting a creature property invalidates dependencies: full recompute
     recomputeCreatureByDoc(rootCreature);
 		// Return the docId of the last property, the inserted root property

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

@@ -7,6 +7,7 @@ import { restore } from '/imports/api/parenting/softRemove.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const restoreProperty = new ValidatedMethod({
 	name: 'creatureProperties.restore',
@@ -27,6 +28,8 @@ const restoreProperty = new ValidatedMethod({
     // Do work
     restore({_id, collection: CreatureProperties});
 
+    // Items and containers might be restored
+    recomputeInventory(rootCreature._id);
     // Parents active status may have changed while it was deleted
     recomputeInactiveProperties(rootCreature._id);
     // Changes dependency tree by restoring children

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

@@ -6,6 +6,7 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import { softRemove } from '/imports/api/parenting/softRemove.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const softRemoveProperty = new ValidatedMethod({
 	name: 'creatureProperties.softRemove',
@@ -26,6 +27,8 @@ const softRemoveProperty = new ValidatedMethod({
     // Do work
 		softRemove({_id, collection: CreatureProperties});
 
+    // Potentially changes items and containers
+    recomputeInventory(rootCreature._id);
     // Changes dependency tree by removing children
     recomputeCreatureByDoc(rootCreature);
 	}

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

@@ -5,6 +5,7 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
 const updateCreatureProperty = new ValidatedMethod({
   name: 'creatureProperties.update',
@@ -52,6 +53,11 @@ const updateCreatureProperty = new ValidatedMethod({
     ].includes(path[0])){
       recomputeInactiveProperties(rootCreature._id);
     }
+
+    if (property.type === 'item' || property.type === 'container'){
+      // Potentially changes items and containers
+      recomputeInventory(rootCreature._id);
+    }
     // Updating a property is likely to change dependencies, do a full recompute
     recomputeCreatureByDoc(rootCreature);
   },

app/imports/api/creature/denormalise/recomputeInactiveProperties.js

@@ -20,9 +20,16 @@ export default function recomputeInactiveProperties(ancestorId){
   CreatureProperties.update({
     'ancestors.id': ancestorId,
     '_id': {$in: disabledIds},
-    $or: [{inactive: {$ne: true}}, {deactivatedByAncestor: true}],
+    $or: [
+      {inactive: {$ne: true}},
+      {deactivatedBySelf: {$ne: true}},
+      {deactivatedByAncestor: true},
+    ],
   }, {
-    $set: {inactive: true},
+    $set: {
+      inactive: true,
+      deactivatedBySelf: true,
+    },
     $unset: {deactivatedByAncestor: 1},
   }, {
     multi: true,
@@ -31,7 +38,10 @@ export default function recomputeInactiveProperties(ancestorId){
   // Decendants of inactive properties
   CreatureProperties.update({
     'ancestors.id': {$eq: ancestorId, $in: disabledIds},
-    $or: [{inactive: {$ne: true}}, {deactivatedByAncestor: {$ne: true}}],
+    $or: [
+      {inactive: {$ne: true}},
+      {deactivatedByAncestor: {$ne: true}},
+    ],
   }, {
     $set: {
       inactive: true,
@@ -46,7 +56,10 @@ export default function recomputeInactiveProperties(ancestorId){
   CreatureProperties.update({
     'ancestors.id': {$eq: ancestorId, $nin: disabledIds},
     '_id': {$nin: disabledIds},
-    $or: [{inactive: true}, {deactivatedByAncestor: true}],
+    $or: [
+      {inactive: true},
+      {deactivatedByAncestor: true},
+    ],
   }, {
     $unset: {
       inactive: 1,

app/imports/api/creature/denormalise/recomputeInventory.js

@@ -1,5 +1,6 @@
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import nodesToTree from '/imports/api/parenting/parenting.js';
+import Creatures from '/imports/api/creature/Creatures.js';
+import { nodesToTree } from '/imports/api/parenting/parenting.js';
 
 export default function recomputeInventory(creatureId){
   let inventoryForest = nodesToTree({
@@ -10,27 +11,27 @@ export default function recomputeInventory(creatureId){
     },
     deactivatedByAncestor: {$ne: true},
   });
-  return getChildrenInventoryData(inventoryForest);
+  let containersToWrite = [];
-}
+  let data =  getChildrenInventoryData(inventoryForest, containersToWrite);
-
+  containersToWrite.forEach(container => {
-function getChildrenInventoryData(forest){
+    CreatureProperties.update(container._id, {$set: {
-  let data = {
+      contentsWeight: container.contentsWeight,
-    weightTotal: 0,
+      contentsValue: container.contentsValue,
-    weightEquipment: 0,
+    }}, {selector: {type: 'container'}});
-    weightCarried: 0,
-    valueTotal: 0,
-    valueEquipment: 0,
-    valueCarried: 0,
-  }
-  forest.forEach(tree => {
-    let treeData = getInventoryData(tree);
-    for (let key in data){
-      data[key] += treeData[key];
-    }
   });
+  Creatures.update(creatureId, {$set: {
+    'denormalizedStats.weightTotal': data.weightTotal,
+    'denormalizedStats.weightEquipment': data.weightEquipment,
+    'denormalizedStats.weightCarried': data.weightCarried,
+    'denormalizedStats.valueTotal': data.valueTotal,
+    'denormalizedStats.valueEquipment': data.valueEquipment,
+    'denormalizedStats.valueCarried': data.valueCarried,
+    'denormalizedStats.itemsAttuned': data.itemsAttuned,
+  }});
+  return data;
 }
 
-function getInventoryData(tree){
+function getChildrenInventoryData(forest, containersToWrite){
   let data = {
     weightTotal: 0,
     weightEquipment: 0,
@@ -40,24 +41,41 @@ function getInventoryData(tree){
     valueCarried: 0,
     itemsAttuned: 0,
   }
-  let childData = getChildrenInventoryData(tree.children);
+  forest.forEach(tree => {
+    let treeData = getInventoryData(tree, containersToWrite);
+    for (let key in data){
+      data[key] += treeData[key] || 0;
+    }
+  });
+  return data;
+}
+
+function getInventoryData(tree, containersToWrite){
+  let data = {
+    weightTotal: 0,
+    weightEquipment: 0,
+    weightCarried: 0,
+    valueTotal: 0,
+    valueEquipment: 0,
+    valueCarried: 0,
+    itemsAttuned: 0,
+  }
+  let childData = getChildrenInventoryData(tree.children, containersToWrite);
   let node = tree.node;
   if (node.type === 'container'){
-    data.weightTotal += node.weight;
+    data.weightTotal += node.weight || 0;
-    data.valueTotal += node.value;
+    data.valueTotal += node.value || 0;
-    if (node.carried){
+    data.weightCarried += node.weight || 0;
-      data.weightCarried += node.weight;
+    data.valueCarried += node.value || 0;
-      data.valueCarried += node.valueCarried;
+    storeContentsData(node, childData, containersToWrite);
-    }
-    storeContentsData(node, childData);
   } else if (node.type === 'item'){
-    data.weightTotal += node.weight * node.quantity;
+    data.weightTotal += (node.weight * node.quantity) || 0;
-    data.valueTotal += node.value * node.quantity;
+    data.valueTotal += (node.value * node.quantity) || 0;
-    data.weightCarried += node.weight * node.quantity;
+    data.weightCarried += (node.weight * node.quantity) || 0;
-    data.valueCarried += node.valueCarried * node.quantity;
+    data.valueCarried += (node.value * node.quantity) || 0;
     if (node.equipped){
-      data.weightEquipment += node.weight * node.quantity;
+      data.weightEquipment += (node.weight * node.quantity) || 0;
-      data.valueEquipment += node.valueCarried * node.quantity;
+      data.valueEquipment += (node.value * node.quantity) || 0;
     }
     if (node.attuned){
       data.itemsAttuned += 1;
@@ -66,16 +84,18 @@ function getInventoryData(tree){
   for (let key in data){
     data[key] += childData[key];
   }
+  if (node.carried === false){
+    data.weightCarried = 0;
+    data.valueCarried = 0;
+  }
+  if (node.contentsWeightless){
+    data.weightCarried = node.weight;
+  }
   return data
 }
 
-function storeContentsData(node, childData){
+function storeContentsData(node, childData, containersToWrite){
-  let newContentsWeight;
+  let newContentsWeight = childData.weightCarried
-  if (node.contentsWeightless){
-    newContentsWeight = 0;
-  } else {
-    newContentsWeight = childData.weightCarried
-  }
   if (node.contentsWeight !== newContentsWeight){
     node.contentsWeight = newContentsWeight;
     node.contentsWeightChanged = true;
@@ -85,4 +105,7 @@ function storeContentsData(node, childData){
     node.contentsValue = newContentsValue;
     node.contentsValueChanged = true;
   }
+  if (node.contentsWeightChanged || node.contentsValueChanged){
+    containersToWrite.push(node);
+  }
 }

app/imports/api/creature/denormalise/recomputeSlotFullness.js

@@ -23,10 +23,14 @@ export default function recomputeSlotFullness(ancestorId){
       }
     });
     let spaceLeft;
-    if (slot.quantityExpected === 0){
+    let expected = slot.quantityExpectedResult;
+    if (typeof expected !== 'number'){
+      expected = 1;
+    }
+    if (expected === 0){
       spaceLeft = null;
     } else {
-      spaceLeft = slot.quantityExpected - totalFilled;
+      spaceLeft = expected - totalFilled;
     }
     if (slot.totalFilled !== totalFilled || slot.spaceLeft !== spaceLeft){
       CreatureProperties.update(slot._id, {

app/imports/api/parenting/organizeMethods.js

@@ -10,7 +10,7 @@ import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
 import getCollectionByName from '/imports/api/parenting/getCollectionByName.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 const organizeDoc = new ValidatedMethod({
   name: 'organize.organizeDoc',
   validate: new SimpleSchema({
@@ -20,13 +20,17 @@ const organizeDoc = new ValidatedMethod({
       type: Number,
       // Should end in 0.5 to place it reliably between two existing documents
     },
+    skipRecompute: {
+      type: Boolean,
+      optional: true,
+    },
   }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({docRef, parentRef, order}) {
+  run({docRef, parentRef, order, skipRecompute}) {
     let doc = fetchDocByRef(docRef);
     let collection = getCollectionByName(docRef.collection);
     // The user must be able to edit both the doc and its parent to move it
@@ -52,15 +56,20 @@ const organizeDoc = new ValidatedMethod({
     // Figure out which creatures need to be recalculated after this move
     let docCreatures = getCreatureAncestors(doc);
     let parentCreatures = getCreatureAncestors(parent);
-    let creaturesToRecompute = union(docCreatures, parentCreatures);
+    if (!skipRecompute){
-    // Recompute the creatures
+      let creaturesToRecompute = union(docCreatures, parentCreatures);
-    creaturesToRecompute.forEach(id => {
+      // Recompute the creatures
-      // The active status of some properties might change due to a change in
+      creaturesToRecompute.forEach(id => {
-      // ancestry
+        // The active status of some properties might change due to a change in
-      recomputeInactiveProperties(id);
+        // ancestry
-      // Some Dependencies depend on ancestry, so a full recompute is needed
+        recomputeInactiveProperties(id);
-      recomputeCreatureById(id);
+        if (doc.type === 'container' || doc.type === 'item'){
-    });
+          recomputeInventory(id);
+        }
+        // Some Dependencies depend on ancestry, so a full recompute is needed
+        recomputeCreatureById(id);
+      });
+    }
   },
 });
 

app/imports/api/properties/Rolls.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
 import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
+import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 
 /**
  * Rolls are children to actions or other rolls, they are triggered with 0 or
@@ -20,6 +21,17 @@ import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
  *  child rolls are applied
  */
 let RollSchema = new SimpleSchema({
+  name: {
+		type: String,
+    defaultValue: 'New Roll',
+	},
+  // The technical, lowercase, single-word name used in formulae
+  variableName: {
+    type: String,
+		regEx: VARIABLE_NAME_REGEX,
+    min: 2,
+    defaultValue: 'newRoll',
+  },
   // The roll, can be simplified, but only computed in context
   roll: {
     type: String,

app/imports/api/properties/SavingThrows.js

@@ -8,11 +8,22 @@ let SavingThrowSchema = new SimpleSchema ({
     type: String,
     optional: true,
   },
+  // The computed DC
   dc: {
     type: String,
     optional: true,
   },
-  // The variable name of ability the save to roll
+  // Who this saving throw applies to
+	target: {
+		type: String,
+    defaultValue: 'every',
+		allowedValues: [
+      'self',   // the character who took the action
+      'each',   // rolled once for `each` target
+      'every',  // rolled once and applied to `every` target
+    ],
+	},
+  // The variable name of save to roll
   stat: {
     type: String,
     optional: true,

app/imports/api/properties/Slots.js

@@ -22,9 +22,9 @@ let SlotSchema = new SimpleSchema({
 		type: String,
 	},
   quantityExpected: {
-    type: SimpleSchema.Integer,
+    type: String,
-    defaultValue: 1,
+    optional: true,
-    min: 0,
+    defaultValue: '1',
   },
   ignored: {
     type: Boolean,

app/imports/api/properties/SpellLists.js

@@ -23,6 +23,16 @@ let SpellListSchema = new SimpleSchema({
 		type: String,
 		optional: true,
 	},
+  // Calculation of The attack roll bonus used by spell attacks in this list
+  attackRollBonus: {
+		type: String,
+		optional: true,
+	},
+  // Calculation of the save dc used by spells in this list
+  dc: {
+		type: String,
+		optional: true,
+	},
 });
 
 const ComputedOnlySpellListSchema = new SimpleSchema({
@@ -33,6 +43,7 @@ const ComputedOnlySpellListSchema = new SimpleSchema({
   },
   'descriptionCalculations.$': InlineComputationSchema,
 
+  // maxPrepared
   maxPreparedResult: {
     type: Number,
     optional: true,
@@ -44,6 +55,32 @@ const ComputedOnlySpellListSchema = new SimpleSchema({
   'maxPreparedErrors.$':{
     type: ErrorSchema,
   },
+
+  // attackRollBonus
+  attackRollBonusResult: {
+    type: Number,
+    optional: true,
+  },
+  attackRollBonusErrors: {
+    type: Array,
+    optional: true,
+  },
+  'attackRollBonusErrors.$':{
+    type: ErrorSchema,
+  },
+
+  // dc
+  dcResult: {
+    type: Number,
+    optional: true,
+  },
+  dcErrors: {
+    type: Array,
+    optional: true,
+  },
+  'dcErrors.$':{
+    type: ErrorSchema,
+  },
 });
 
 const ComputedSpellListSchema = new SimpleSchema()

app/imports/constants/SVG_ICONS.js

@@ -91,6 +91,10 @@ const SVG_ICONS = Object.freeze({
     name: 'weight',
     shape: 'M256 46c-45.074 0-82 36.926-82 82 0 25.812 12.123 48.936 30.938 64H128L32 480h448l-96-288h-76.938C325.877 176.936 338 153.812 338 128c0-45.074-36.926-82-82-82zm0 36c25.618 0 46 20.382 46 46s-20.382 46-46 46-46-20.382-46-46 20.382-46 46-46z',
   },
+  'weightless': {
+    name: 'weightless',
+    shape: 'M470.72 20L368.186 49.813l41.563-28.094c-26.254 5.922-59.36 17.502-100.97 36.186l-67.874 70.78L264.97 79.25c-23.247 12.958-47.95 29.99-71.814 49.844l-15.78 64.312L174 145.844c-23.55 21.548-45.624 45.6-63.875 70.812-19.25 26.59-34.28 54.506-41.813 82.438L40.19 280.28c6.138 19.613 11.892 39.232 22.906 58.845.032 1.468.1 2.944.187 4.406L29.657 333.19c11.227 18.284 23.577 35.893 43 49.125.45 1.003.953 1.973 1.438 2.968-11.838 33.33-20.568 67.004-26.53 101.69l18.405 3.155c4.952-28.808 11.836-56.842 20.905-84.563.04.053.084.105.125.157 44.277-156.11 142.813-266.846 287.03-324l6.876 17.374c-129.048 51.143-219.303 145.15-265.78 279.062 18.106.102 35.796-2.088 52.218-6.22l4.875-60.967 13.093 55.5c10.84-3.922 20.88-8.762 29.812-14.376l-20.688-43.47 32.782 34.813c7.944-6.468 14.613-13.678 19.624-21.53 30.308-47.507 62.195-94.728 124.75-134.188l-45.72-16.25 70.157 2.124c2.044-1.085 4.087-2.18 6.19-3.25 9.087-4.63 17.916-10.182 26.31-16.375L378.814 150l74.718-17.625c5.788-5.81 11.174-11.836 16.033-17.97 17.384-21.94 29.034-44.784 26.28-65.56-1.376-10.39-7.556-20.154-17.624-25.626-2.333-1.27-4.832-2.337-7.5-3.22zM106.25 406c-.89 3.06-1.778 6.122-2.625 9.22l2.625-9.22z'
+  }
 });
 
 export default SVG_ICONS;

app/imports/parser/functions.js

@@ -1,3 +1,5 @@
+import ArrayNode from '/imports/parser/parseTree/ArrayNode.js';
+
 export default {
   'abs': {
     comment: 'Returns the absolute value of a number',
@@ -5,7 +7,7 @@ export default {
       {input: 'abs(9)', result: '9'},
       {input: 'abs(-3)', result: '3'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.abs,
   },
@@ -15,21 +17,21 @@ export default {
       {input: 'sqrt(16)', result: '4'},
       {input: 'sqrt(10)', result: '3.1622776601683795'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.sqrt,
   },
   'max': {
     comment: 'Returns the largest of the given numbers',
-    examples: [{input: 'min(12, 6, 3, 168)', result: '168'}],
+    examples: [{input: 'max(12, 6, 3, 168)', result: '168'}],
-    argumentType: 'number',
+    arguments: anyNumberOf('number'),
     resultType: 'number',
     fn: Math.max,
   },
   'min': {
     comment: 'Returns the smallest of the given numbers',
     examples: [{input: 'min(12, 6, 3, 168)', result: '3'}],
-    argumentType: 'number',
+    arguments: anyNumberOf('number'),
     resultType: 'number',
     fn: Math.min,
   },
@@ -40,7 +42,7 @@ export default {
       {input: 'round(5.5)', result: '6'},
       {input: 'round(5.05)', result: '5'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.round,
   },
@@ -52,7 +54,7 @@ export default {
       {input: 'floor(5)', result: '5'},
       {input: 'floor(-5.5)', result: '-6'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.floor,
   },
@@ -64,7 +66,7 @@ export default {
       {input: 'ceil(5)', result: '5'},
       {input: 'ceil(-5.5)', result: '-5'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.ceil,
   },
@@ -76,7 +78,7 @@ export default {
       {input: 'trunc(5)', result: '5'},
       {input: 'trunc(-5.5)', result: '-5'},
     ],
-    argumentType: 'number',
+    arguments:[ 'number'],
     resultType: 'number',
     fn: Math.trunc,
   },
@@ -87,8 +89,32 @@ export default {
       {input: 'sign(3)', result: '1'},
       {input: 'sign(0)', result: '0'},
     ],
-    argumentType: 'number',
+    arguments: ['number'],
     resultType: 'number',
     fn: Math.sign,
+  },
+  'tableLookup': {
+    comment: 'Returns the index of the last value in the array that is less than the specified amount',
+    examples: [
+      {input: 'tableLookup([100, 300, 900], 457)', result: '2'},
+      {input: 'tableLookup([100, 300, 900], 23)', result: '0'},
+      {input: 'tableLookup([100, 300, 900, 1200], 900)', result: '3'},
+      {input: 'tableLookup([100, 300], 594)', result: '2'},
+    ],
+    arguments: [ArrayNode, 'number'],
+    resultType: 'number',
+    fn: function tableLookup(arrayNode, number){
+      for(let i in arrayNode.values){
+        let node = arrayNode.values[i];
+        if (node.value > number) return i;
+      }
+      return arrayNode.values.length;
+    }
   }
 }
+
+function anyNumberOf(type){
+  let argumentArray = [type];
+  argumentArray.anyLength = true;
+  return argumentArray;
+}

app/imports/parser/parseTree/CallNode.js

@@ -11,40 +11,64 @@ export default class CallNode extends ParseNode {
   }
   resolve(fn, scope, context){
     let func = functions[this.functionName];
+    // Check that the function exists
     if (!func) return new ErrorNode({
       node: this,
-      error: `${this.functionName} is not a function`,
+      error: `${this.functionName} is not a supported function`,
       context,
     });
-    let args = castArgsToType({fn, scope, context, args: this.args, type: func.argumentType});
+
-    if (args.failed){
+    // Resolve the arguments
-      if (fn === 'reduce'){
+    let resolvedArgs = this.args.map(node => node[fn](scope, context));
+
+    // Check that the arguments match what is expected
+    let checkFailed = this.checkArugments({
+      fn,
+      context,
+      resolvedArgs,
+      argumentsExpected: func.arguments
+    });
+
+    if (checkFailed){
+      if (fn !== 'reduce'){
         return new ErrorNode({
           node: this,
-          error: 'Could not convert all arguments to the correct type',
+          error: `Invalid arguments to ${this.functionName} function`,
-          context,
         });
       } else {
         return new CallNode({
           functionName: this.functionName,
-          args: args,
+          args: resolvedArgs,
         });
       }
-    } else {
+    }
-      try {
+
-        let value = func.fn.apply(null, args);
+    // Map contant nodes to constants before attempting to run the function
-        return new ConstantNode({
+    let mappedArgs = resolvedArgs.map(node => {
-          value,
+      if (node instanceof ConstantNode){
-          type: 'number',
+        return node.value;
-          previousNodes: [this],
+      } else {
-        });
+        return node;
-      } catch (error) {
-        return new ErrorNode({
-          node: this,
-          error,
-          context,
-        });
       }
+    });
+
+    try {
+      // Run the function
+      let value = func.fn.apply(null, mappedArgs);
+
+      let type = typeof value;
+      if (type === 'number' || type === 'string' || type === 'boolean'){
+        // Convert constant results into constant nodes
+        return new ConstantNode({ value, type });
+      } else {
+        return value;
+      }
+    } catch (error) {
+      return new ErrorNode({
+        node: this,
+        error: error.message || error,
+        context,
+      });
     }
   }
   toString(){
@@ -57,20 +81,47 @@ export default class CallNode extends ParseNode {
   replaceChildren(fn){
     this.args = this.args.map(arg => arg.replaceNodes(fn));
   }
-}
+  checkArugments({fn, context, argumentsExpected, resolvedArgs}){
+    // Check that the number of arguments matches the number expected
+    if (
+      !argumentsExpected.anyLength &&
+      argumentsExpected.length !== resolvedArgs.length
+    ){
+      context.storeError({
+        type: 'error',
+        message: 'Incorrect number of arguments ' +
+          `to ${this.functionName} function, ` +
+          `expected ${argumentsExpected.length} got ${resolvedArgs.length}`
+        });
+      return true;
+    }
 
-function castArgsToType({fn, scope, context, args, type}){
+    let failed = false;
-  let resolvedArgs = args.map(node => node[fn](scope, context))
+    // Check that each argument is of the correct type
-  let result = [];
+    resolvedArgs.forEach((node, index) => {
-  if (type === 'number'){
+      let type;
-    resolvedArgs.forEach(node => {
+      if (argumentsExpected.anyLength){
-      if (node.isNumber){
+        type = argumentsExpected[0];
-        result.push(node.value);
       } else {
-        resolvedArgs.failed = true;
+        type = argumentsExpected[index];
       }
-    })
+      if (typeof type === 'string'){
+        // Type being a string means a constant node with matching type
+        if (node.type !== type) failed = true;
+      } else {
+        // Otherwise check that the node is an instance of the given type
+        if (!(node instanceof type)) failed = true;
+      }
+      if (failed && fn === 'reduce'){
+        let typeName = typeof type === 'string' ? type : type.constructor.name;
+        let nodeName = node.type || node.constructor.name
+        context.storeError({
+          type: 'error',
+          message: `Incorrect arguments to ${this.functionName} function` +
+          `expected ${typeName} got ${nodeName}`
+        });
+      }
+    });
+    return failed;
   }
-  if (resolvedArgs.failed) return resolvedArgs;
-  return result;
 }

app/imports/server/discord/sendWebhook.js

@@ -10,7 +10,6 @@ export default function sendWebhook({webhookURL, data = {}}){
 
   const hook = new Discord.WebhookClient(id, token);
   // Send a message using the webhook
-  console.log(JSON.stringify(data, null, 2));
   hook.send(data);
 }
 

app/imports/server/publications/singleCharacter.js

@@ -3,6 +3,7 @@ import Creatures from '/imports/api/creature/Creatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
 import { assertViewPermission } from '/imports/api/creature/creaturePermissions.js';
+import recomputeInvetory from '/imports/api/creature/denormalise/recomputeInventory.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import VERSION from '/imports/constants/VERSION.js';
 
@@ -25,7 +26,10 @@ Meteor.publish('singleCharacter', function(creatureId){
     try { assertViewPermission(creature, userId) }
     catch(e){ return [] }
     if (creature.computeVersion !== VERSION){
-      try { recomputeCreatureById(creatureId) }
+      try {
+        recomputeInvetory(creatureId);
+        recomputeCreatureById(creatureId)
+      }
       catch(e){ console.error(e) }
     }
     return [

app/imports/server/publications/slotFillers.js

@@ -50,7 +50,7 @@ Meteor.publish('slotFillers', function(slotId){
     }
     this.autorun(function(){
       // Get the limit of the documents the user can fetch
-      var limit = self.data('limit') || 16;
+      var limit = self.data('limit') || 20;
       check(limit, Number);
 
       // Get the search term

app/imports/ui/components/propertyToolbar.vue

@@ -19,6 +19,7 @@
       <v-layout
         v-if="editing && model"
         key="edit-buttons"
+        style="flex-shrink: 0;"
       >
         <v-spacer />
         <color-picker

app/imports/ui/creature/character/characterSheetTabs/CharacterTab.vue

@@ -41,7 +41,7 @@
           >
             Level {{ creature.variables.level.value }}
           </v-card-title>
-          <v-list>
+          <v-list two-line>
             <v-list-tile>
               <v-list-tile-content>
                 <v-list-tile-title
@@ -52,7 +52,14 @@
                 >
                   {{ creature.variables.milestoneLevels.value }} Milestone levels
                 </v-list-tile-title>
-                <v-list-tile-title v-else>
+                <v-list-tile-title
+                  v-if="
+                    !(creature.variables.milestoneLevels &&
+                      creature.variables.milestoneLevels.value) ||
+                      (creature.variables.xp &&
+                        creature.variables.xp.value)
+                  "
+                >
                   {{
                     creature.variables.xp &&
                       creature.variables.xp.value ||

app/imports/ui/creature/character/characterSheetTabs/InventoryTab.vue

@@ -1,6 +1,59 @@
 <template lang="html">
   <div class="inventory">
     <column-layout wide-columns>
+      <div>
+        <v-card>
+          <v-list>
+            <v-list-tile>
+              <v-list-tile-avatar>
+                <v-icon>$vuetify.icons.injustice</v-icon>
+              </v-list-tile-avatar>
+              <v-list-tile-content>
+                <v-list-tile-title>
+                  Weight Carried
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-action>
+                <v-list-tile-title>
+                  {{ creature.denormalizedStats.weightCarried || 0 }} lb
+                </v-list-tile-title>
+              </v-list-tile-action>
+            </v-list-tile>
+            <v-list-tile>
+              <v-list-tile-avatar>
+                <v-icon>$vuetify.icons.cash</v-icon>
+              </v-list-tile-avatar>
+              <v-list-tile-content>
+                <v-list-tile-title>
+                  Net worth
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-action>
+                <v-list-tile-title>
+                  <coin-value
+                    :value="creature.denormalizedStats.valueTotal || 0"
+                  />
+                </v-list-tile-title>
+              </v-list-tile-action>
+            </v-list-tile>
+            <v-list-tile v-if="creature.denormalizedStats.itemsAttuned">
+              <v-list-tile-avatar>
+                <v-icon>$vuetify.icons.spell</v-icon>
+              </v-list-tile-avatar>
+              <v-list-tile-content>
+                <v-list-tile-title>
+                  Items attuned
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-action>
+                <v-list-tile-title>
+                  {{ creature.denormalizedStats.itemsAttuned }}
+                </v-list-tile-title>
+              </v-list-tile-action>
+            </v-list-tile>
+          </v-list>
+        </v-card>
+      </div>
       <div>
         <toolbar-card
           :color="creature.color"
@@ -53,6 +106,7 @@ import ToolbarCard from '/imports/ui/components/ToolbarCard.vue';
 import ItemList from '/imports/ui/properties/components/inventory/ItemList.vue';
 import { getParentRefByTag } from '/imports/api/creature/creatureProperties/methods/equipItem.js';
 import INVENTORY_TAGS from '/imports/constants/INVENTORY_TAGS.js';
+import CoinValue from '/imports/ui/components/CoinValue.vue';
 
 export default {
 	components: {
@@ -60,6 +114,7 @@ export default {
 		ContainerCard,
     ToolbarCard,
     ItemList,
+    CoinValue,
 	},
 	props: {
 		creatureId: {
@@ -82,7 +137,10 @@ export default {
 			});
 		},
     creature(){
-      return Creatures.findOne(this.creatureId, {fields: {color: 1}});
+      return Creatures.findOne(this.creatureId, {fields: {
+        color: 1,
+        denormalizedStats: 1,
+      }});
     },
 		containersWithoutAncestorContainers(){
 			return CreatureProperties.find({

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

@@ -196,7 +196,7 @@ export default {
     },
     loadMore(){
       if (this.currentLimit >= this.countAll) return;
-      this._subs['slotFillers'].setData('limit', this.currentLimit + 16);
+      this._subs['slotFillers'].setData('limit', this.currentLimit + 20);
     },
     insert(){
       if (!this.selectedNode) return;

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

@@ -8,8 +8,8 @@
       <h3 class="layout row align-center">
         {{ slot.name }}
         <v-spacer />
-        <span v-if="slot.quantityExpected > 1">
+        <span v-if="slot.quantityExpectedResult > 1">
-          {{ slot.totalFilled }} / {{ slot.quantityExpected }}
+          {{ slot.totalFilled }} / {{ slot.quantityExpectedResult }}
         </span>
       </h3>
       <v-list v-if="slot.children.length">
@@ -38,7 +38,7 @@
         </v-list-tile>
       </v-list>
       <v-btn
-        v-if="!slot.quantityExpected || slot.spaceLeft"
+        v-if="!slot.quantityExpectedResult || slot.spaceLeft"
         icon
         :data-id="`slot-add-button-${slot._id}`"
         class="slot-add-button"

app/imports/ui/properties/components/inventory/ContainerCard.vue

@@ -9,6 +9,31 @@
         {{ model.name }}
       </v-toolbar-title>
       <v-spacer />
+      <v-toolbar-title>
+        <v-icon
+          small
+          style="width: 16px;"
+          class="mr-1"
+        >
+          $vuetify.icons.weight
+        </v-icon>
+        {{ (model.contentsWeight ? 0 : model.contentsWeight || 0) + (model.weight || 0) }}
+      </v-toolbar-title>
+      <v-toolbar-title
+        class="layout row align-center"
+        style="flex-grow: 0;"
+      >
+        <v-icon
+          small
+          style="width: 16px;"
+          class="mr-1"
+        >
+          $vuetify.icons.two_coins
+        </v-icon>
+        <coin-value
+          :value="(model.contentsValue || 0) + (model.value || 0)"
+        />
+      </v-toolbar-title>
     </template>
     <v-card-text class="px-0">
       <item-list
@@ -23,11 +48,13 @@
 import ToolbarCard from '/imports/ui/components/ToolbarCard.vue';
 import ItemList from '/imports/ui/properties/components/inventory/ItemList.vue';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import CoinValue from '/imports/ui/components/CoinValue.vue';
 
 export default {
 	components: {
 		ToolbarCard,
     ItemList,
+    CoinValue,
 	},
 	props: {
 		model: {

app/imports/ui/properties/components/inventory/ItemListTile.vue

@@ -15,7 +15,13 @@
         {{ title }}
       </v-list-tile-title>
     </v-list-tile-content>
-    <v-list-tile-action>
+    <v-list-tile-action
+      v-if="model.attuned"
+      style="min-width: 40px;"
+    >
+      <v-icon>$vuetify.icons.spell</v-icon>
+    </v-list-tile-action>
+    <v-list-tile-action style="min-width: 40px;">
       <increment-button
         v-if="context.creatureId && model.showIncrement"
         icon

app/imports/ui/properties/forms/RollForm.vue

@@ -1,5 +1,21 @@
 <template lang="html">
   <div class="roll-form">
+    <div class="layout row wrap">
+      <text-field
+        label="Name"
+        :value="model.name"
+        :error-messages="errors.name"
+        @change="change('name', ...arguments)"
+      />
+      <text-field
+        label="Variable name"
+        :value="model.variableName"
+        style="flex-basis: 300px;"
+        hint="Use this name in action formulae to refer to the result of this roll"
+        :error-messages="errors.variableName"
+        @change="change('variableName', ...arguments)"
+      />
+    </div>
     <text-field
       ref="focusFirst"
       label="Roll"

app/imports/ui/properties/forms/SavingThrowForm.vue

@@ -8,6 +8,7 @@
       @change="change('name', ...arguments)"
     />
     <text-field
+      ref="focusFirst"
       label="DC"
       :value="model.dc"
       :error-messages="errors.dc"
@@ -21,6 +22,15 @@
       :error-messages="errors.stat"
       @change="change('stat', ...arguments)"
     />
+    <smart-select
+      label="Target"
+      :hint="targetOptionHint"
+      :items="targetOptions"
+      :value="model.target"
+      :error-messages="errors.target"
+      :menu-props="{auto: true, lazy: true}"
+      @change="change('target', ...arguments)"
+    />
     <smart-combobox
       label="Tags"
       class="mr-2"
@@ -40,5 +50,34 @@ import propertyFormMixin from '/imports/ui/properties/forms/shared/propertyFormM
 
 export default {
   mixins: [saveListMixin, propertyFormMixin],
+  computed: {
+		targetOptions(){
+			return [
+				{
+					text: 'Self',
+					value: 'self',
+				}, {
+					text: 'Roll once for each target',
+					value: 'each',
+				}, {
+					text: 'Roll once and apply to every target',
+					value: 'every',
+				},
+			];
+		},
+		targetOptionHint(){
+			let hints = {
+				self: 'The damage will be applied to the character\'s own attribute when taking the action',
+				target: 'The damage will be applied to the target of the action',
+				each: 'The damage will be rolled separately for each of the targets of the action',
+				every: 'The damage will be rolled once and applied to each of the targets of the action',
+			};
+			if (this.parentTarget === 'singleTarget'){
+				hints.each = hints.target;
+				hints.every = hints.target;
+			}
+			return hints[this.model.target];
+		}
+	},
 };
 </script>

app/imports/ui/properties/forms/SlotForm.vue

@@ -28,8 +28,6 @@
     />
     <text-field
       label="Quantity"
-      type="number"
-      min="0"
       hint="How many matching properties must be used to fill this slot, 0 is unlimited"
       :value="model.quantityExpected"
       :error-messages="errors.quantityExpected"

app/imports/ui/properties/forms/SpellListForm.vue

@@ -35,6 +35,24 @@
     />
     <calculation-error-list :errors="model.maxPreparedErrors" />
 
+    <text-field
+      label="Spell save DC"
+      :value="model.dc"
+      hint="The spell save DC of spells in this list"
+      :error-messages="errors.dc"
+      @change="change('dc', ...arguments)"
+    />
+    <calculation-error-list :errors="model.dcErrors" />
+
+    <text-field
+      label="Attack roll bonus"
+      :value="model.attackRollBonus"
+      hint="The attack roll bonus of spell attacks made by spells in this list"
+      :error-messages="errors.attackRollBonus"
+      @change="change('attackRollBonus', ...arguments)"
+    />
+    <calculation-error-list :errors="model.attackRollBonusErrors" />
+
     <smart-combobox
       label="Tags"
       multiple

app/imports/ui/properties/forms/shared/propertyFormMixin.js

@@ -10,7 +10,7 @@ export default {
     },
   },
   mounted(){
-    if (this.$refs.focusFirst){
+    if (this.$refs.focusFirst && this.$refs.focusFirst.focus){
       setTimeout(() => this.$refs.focusFirst.focus(), 300);
     }
   },

app/imports/ui/properties/treeNodeViews/AdjustmentTreeNode.vue

@@ -10,7 +10,11 @@
     <div
       class="text-no-wrap text-truncate"
     >
-      {{ model.amountResult }} {{ model.stat }} damage
+      <span v-if="model.amountResult < 0">+</span>
+      {{ absoluteAmount }} {{ model.stat }}
+      <span v-if="typeof absoluteAmount === 'string' || absoluteAmount >= 0">
+        damage
+      </span>
     </div>
   </div>
 </template>
@@ -20,5 +24,14 @@ import treeNodeViewMixin from '/imports/ui/properties/treeNodeViews/treeNodeView
 
 export default {
   mixins: [treeNodeViewMixin],
+  computed: {
+    absoluteAmount(){
+      if (typeof this.model.amountResult === 'number'){
+        return Math.abs(this.model.amountResult);
+      } else {
+        return this.model.amountResult;
+      }
+    },
+  }
 }
 </script>

app/imports/ui/properties/viewers/AdjustmentViewer.vue

@@ -1,14 +1,81 @@
 <template lang="html">
-  <div class="adjustment-viewer layout row align-center">
+  <v-list-tile class="effect-viewer">
-    {{ model.amountResult }} {{ model.stat }} damage
+    <v-list-tile-avatar>
-  </div>
+      <v-tooltip bottom>
+        <template
+          v-if="effectIcon !== 'remove'"
+          #activator="{ on }"
+        >
+          <v-icon
+            class="mx-2"
+            style="cursor: default;"
+            v-on="on"
+          >
+            {{ effectIcon }}
+          </v-icon>
+        </template>
+        <span>{{ tooltip }}</span>
+      </v-tooltip>
+    </v-list-tile-avatar>
+    <v-list-tile-action class="headline">
+      {{ displayedValue }}
+    </v-list-tile-action>
+    <v-list-tile-content>
+      <v-list-tile-title>
+        <code>{{ model.stat }}</code>
+        <template v-if="effectIcon === 'remove'">
+          damage
+        </template>
+      </v-list-tile-title>
+    </v-list-tile-content>
+  </v-list-tile>
 </template>
 
 <script>
 	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js';
+  import getEffectIcon from '/imports/ui/utility/getEffectIcon.js';
 
 	export default {
 		mixins: [propertyViewerMixin],
+    computed: {
+      effectIcon(){
+        let effectOp = this.model.operation === 'increment' ? 'add' : 'base';
+				let value = this.value;
+        if (typeof value === 'string'){
+          value = 1;
+        }
+        return getEffectIcon(effectOp, -value);
+			},
+      value(){
+        return 'amountResult' in this.model ?
+          this.model.amountResult :
+          this.model.amount;
+      },
+      displayedValue(){
+        if (
+          typeof this.value === 'number' &&
+          this.model.operation !== 'set'
+        ){
+          return Math.abs(this.value);
+        } else {
+          return this.value;
+        }
+      },
+      tooltip(){
+        if (this.model.operation === 'increment'){
+          if (
+            typeof this.value === 'string' ||
+            this.value >= 0
+          ){
+            return 'Minus';
+          } else {
+            return 'Add'
+          }
+        } else {
+          return 'Set'
+        }
+      }
+    },
 	}
 </script>
 

app/imports/ui/properties/viewers/ConstantViewer.vue

@@ -0,0 +1,23 @@
+<template lang="html">
+  <div class="buff-viewer">
+    <property-name :value="model.name" />
+    <property-variable-name :value="model.variableName" />
+    <property-field
+      name="Calculation"
+      :value="model.calculation"
+    />
+    <calculation-error-list :errors="model.errors" />
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js'
+  import CalculationErrorList from '/imports/ui/properties/forms/shared/CalculationErrorList.vue';
+
+	export default {
+    components: {
+      CalculationErrorList,
+    },
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/ContainerViewer.vue

@@ -3,12 +3,13 @@
     <property-tags :tags="model.tags" />
     <div class="layout row wrap justify-space-around">
       <div
-        v-if="model.value !== undefined"
         class="mr-3 my-3"
       >
         <v-layout
+          v-if="model.value !== undefined"
           row
           align-center
+          class="mb-2"
         >
           <v-icon
             class="mr-2"
@@ -21,15 +22,34 @@
             :value="model.value"
           />
         </v-layout>
-      </div>
-      <div
-        v-if="model.weight !== undefined"
-        class="my-3"
-      >
         <v-layout
           row
           align-center
+        >
+          <v-icon
+            class="mr-2"
+            x-large
+          >
+            $vuetify.icons.cash
+          </v-icon>
+          <coin-value
+            class="title mr-2"
+            :value="model.contentsValue"
+          />
+          <span class="title">
+            contents
+          </span>
+        </v-layout>
+      </div>
+      <div
+        class="my-3"
+      >
+        <v-layout
+          v-if="model.weight !== undefined"
+          row
+          align-center
           justify-end
+          class="mb-2"
         >
           <span class="title mr-2">
             {{ model.weight }} lb
@@ -41,6 +61,45 @@
             $vuetify.icons.weight
           </v-icon>
         </v-layout>
+        <v-layout
+          row
+          align-center
+          justify-end
+          :class="{'mb-2': model.contentsWeightless}"
+        >
+          <span class="title mr-2">
+            {{ model.contentsWeight }} lb
+          </span>
+          <span
+            class="title"
+          >
+            contents
+          </span>
+          <v-icon
+            class="ml-2"
+            x-large
+          >
+            $vuetify.icons.injustice
+          </v-icon>
+        </v-layout>
+        <v-layout
+          v-if="model.contentsWeightless"
+          row
+          align-center
+          justify-end
+        >
+          <span
+            class="title"
+          >
+            Contents weightless
+          </span>
+          <v-icon
+            class="ml-2"
+            x-large
+          >
+            $vuetify.icons.weightless
+          </v-icon>
+        </v-layout>
       </div>
     </div>
     <property-description

app/imports/ui/properties/viewers/ItemViewer.vue

@@ -89,6 +89,7 @@
           row
           align-center
           justify-end
+          :class="{'mb-2': model.attuned}"
         >
           <span class="title mr-2">
             {{ model.weight }} lb
@@ -106,6 +107,22 @@
             $vuetify.icons.weight
           </v-icon>
         </v-layout>
+        <v-layout
+          v-if="model.attuned"
+          row
+          align-center
+          justify-end
+        >
+          <span class="title">
+            Attuned
+          </span>
+          <v-icon
+            class="ml-2"
+            x-large
+          >
+            $vuetify.icons.spell
+          </v-icon>
+        </v-layout>
       </div>
     </div>
     <property-description

app/imports/ui/properties/viewers/RollViewer.vue

@@ -0,0 +1,23 @@
+<template lang="html">
+  <div class="buff-viewer">
+    <property-name :value="model.name" />
+    <property-variable-name :value="model.variableName" />
+    <property-field
+      name="Roll"
+      :value="'rollResult' in model ? model.rollResult : model.roll"
+    />
+    <calculation-error-list :errors="model.rollErrors" />
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js'
+  import CalculationErrorList from '/imports/ui/properties/forms/shared/CalculationErrorList.vue';
+
+	export default {
+    components: {
+      CalculationErrorList,
+    },
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/SavingThrowViewer.vue

@@ -0,0 +1,21 @@
+<template lang="html">
+  <div class="buff-viewer">
+    <property-name :value="model.name" />
+    <property-field
+      name="Save"
+      :value="model.stat"
+    />
+    <property-field
+      name="DC"
+      :value="'dcResult' in model ? model.dcResult : model.dc"
+    />
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js'
+
+	export default {
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/SlotFillerViewer.vue

@@ -0,0 +1,37 @@
+<template lang="html">
+  <div class="slot-filler-viewer">
+    <property-name :value="model.name" />
+    <v-img
+      v-if="model.picture"
+      :src="model.picture"
+      :height="200"
+      contain
+      class="slot-card-image"
+    />
+    <property-field
+      name="Type"
+      :value="model.slotFillerType"
+    />
+    <property-field
+      name="Quantity"
+      :value="model.slotQuantityFilled"
+    />
+    <property-field
+      name="Condition"
+      :value="model.slotFillerCondition"
+    />
+    <property-description
+      :string="model.description"
+      :calculations="model.descriptionCalculations"
+      :inactive="model.inactive"
+    />
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js';
+
+	export default {
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/SlotViewer.vue

@@ -0,0 +1,41 @@
+<template lang="html">
+  <div class="buff-viewer">
+    <property-name :value="model.name" />
+    <property-field
+      name="Type"
+      :value="model.slotType"
+    />
+    <property-field
+      name="Quantity"
+      :value="'quantityExpectedResult' in model ? model.quantityExpectedResult : model.quantityExpected"
+    />
+    <property-field
+      name="Condition"
+      :value="model.slotCondition"
+    />
+    <property-field
+      v-if="'slotConditionResult' in model"
+      name="Condition result"
+      :value="model.slotConditionResult"
+    />
+    <template v-if="model.tags.length">
+      <div class="caption">
+        Tags
+      </div>
+      <property-tags :tags="model.tags" />
+    </template>
+    <property-description
+      :string="model.description"
+      :calculations="model.descriptionCalculations"
+      :inactive="model.inactive"
+    />
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js'
+
+	export default {
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/SpellListViewer.vue

@@ -4,7 +4,15 @@
     <property-variable-name :value="model.variableName" />
     <property-field
       name="Maximum prepared spells"
-      :value="model.maxPreparedResult"
+      :value="'maxPreparedResult' in model ? model.maxPreparedResult : model.maxPrepared"
+    />
+    <property-field
+      name="Spell Save DC"
+      :value="'dcResult' in model ? model.dcResult : model.dcResult"
+    />
+    <property-field
+      name="Attack roll bonus"
+      :value="'attackRollBonusResult' in model ? model.attackRollBonusResult : model.attackRollBonus"
     />
     <property-description
       :string="model.description"

app/imports/ui/properties/viewers/ToggleViewer.vue

@@ -0,0 +1,31 @@
+<template lang="html">
+  <div class="toggle-viewer">
+    <property-name :value="model.name" />
+    <property-field
+      v-if="model.disabled || model.enabled"
+      name="Status"
+      :value="model.enabled ? 'Enabled' : 'Disabled'"
+    />
+    <template
+      v-else-if="model.condition"
+    >
+      <property-field
+        name="Condition"
+        :value="model.condition"
+      />
+      <property-field
+        v-if="'toggleResult' in model"
+        name="Result"
+        :value="model.toggleResult"
+      />
+    </template>
+  </div>
+</template>
+
+<script>
+	import propertyViewerMixin from '/imports/ui/properties/viewers/shared/propertyViewerMixin.js'
+
+	export default {
+		mixins: [propertyViewerMixin],
+	}
+</script>

app/imports/ui/properties/viewers/shared/PropertyField.vue

@@ -1,11 +1,11 @@
 <template lang="html">
   <div v-if="value !== undefined || $slots.default">
-  	<div class="caption">
+    <div class="caption">
-  		{{name}}
+      {{ name }}
-  	</div>
+    </div>
     <p class="ml-2 subheading">
       <slot>
-        {{value}}
+        {{ value }}
       </slot>
     </p>
   </div>
@@ -15,7 +15,7 @@
 export default {
 	props: {
 		name: String,
-		value: [String, Number],
+		value: [String, Number, Boolean],
 	}
 }
 </script>

app/imports/ui/properties/viewers/shared/propertyViewerIndex.js

@@ -5,6 +5,7 @@ import AttributeViewer from '/imports/ui/properties/viewers/AttributeViewer.vue'
 import BuffViewer from '/imports/ui/properties/viewers/BuffViewer.vue';
 import ContainerViewer from '/imports/ui/properties/viewers/ContainerViewer.vue';
 import ClassLevelViewer from '/imports/ui/properties/viewers/ClassLevelViewer.vue';
+import ConstantViewer from '/imports/ui/properties/viewers/ConstantViewer.vue';
 import DamageViewer from '/imports/ui/properties/viewers/DamageViewer.vue';
 import DamageMultiplierViewer from '/imports/ui/properties/viewers/DamageMultiplierViewer.vue';
 import EffectViewer from '/imports/ui/properties/viewers/EffectViewer.vue';
@@ -13,10 +14,14 @@ import FolderViewer from '/imports/ui/properties/viewers/FolderViewer.vue';
 import ItemViewer from '/imports/ui/properties/viewers/ItemViewer.vue';
 import NoteViewer from '/imports/ui/properties/viewers/NoteViewer.vue';
 import ProficiencyViewer from '/imports/ui/properties/viewers/ProficiencyViewer.vue';
-//import RollViewer from '/imports/ui/properties/viewers/RollViewer.vue';
+import RollViewer from '/imports/ui/properties/viewers/RollViewer.vue';
 import SkillViewer from '/imports/ui/properties/viewers/SkillViewer.vue';
+import SavingThrowViewer from '/imports/ui/properties/viewers/SavingThrowViewer.vue';
+import SlotViewer from '/imports/ui/properties/viewers/SlotViewer.vue';
+import SlotFillerViewer from '/imports/ui/properties/viewers/SlotFillerViewer.vue';
 import SpellListViewer from '/imports/ui/properties/viewers/SpellListViewer.vue';
 import SpellViewer from '/imports/ui/properties/viewers/SpellViewer.vue';
+import ToggleViewer from '/imports/ui/properties/viewers/ToggleViewer.vue';
 
 export default {
   action: ActionViewer,
@@ -26,6 +31,7 @@ export default {
   buff: BuffViewer,
   container: ContainerViewer,
   classLevel: ClassLevelViewer,
+  constant: ConstantViewer,
   damage: DamageViewer,
   damageMultiplier: DamageMultiplierViewer,
   effect: EffectViewer,
@@ -34,8 +40,12 @@ export default {
   item: ItemViewer,
   note: NoteViewer,
   proficiency: ProficiencyViewer,
-//  roll: RollViewer,
+  propertySlot: SlotViewer,
+  roll: RollViewer,
+  savingThrow: SavingThrowViewer,
+  slotFiller: SlotFillerViewer,
   skill: SkillViewer,
   spellList: SpellListViewer,
   spell: SpellViewer,
+  toggle: ToggleViewer,
 };