Improved actions UI, Actions (including spells) can now have icons

app/.meteor/packages

@@ -50,3 +50,5 @@ akryum:vue-component
 accounts-patreon
 bozhao:link-accounts
 peerlibrary:reactive-publish
+simple:rest
+simple:rest-method-mixin

app/.meteor/versions

@@ -115,6 +115,9 @@ service-configuration@1.0.11
 session@1.2.0
 sha@1.0.9
 shell-server@0.5.0
+simple:json-routes@2.1.0
+simple:rest@1.1.1
+simple:rest-method-mixin@1.0.1
 socket-stream-client@0.3.0
 spacebars@1.0.15
 spacebars-compiler@1.1.3

app/imports/api/creature/CreatureProperties.js

@@ -1,5 +1,6 @@
 import { Meteor } from 'meteor/meteor';
 import { Mongo } from 'meteor/mongo';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import SimpleSchema from 'simpl-schema';
 import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
@@ -17,6 +18,9 @@ import {
 	renewDocIds
 } from '/imports/api/parenting/parenting.js';
 import {setDocToLastOrder} from '/imports/api/parenting/order.js';
+import { storedIconsSchema } from '/imports/api/icons/Icons.js';
+
+import '/imports/api/creature/actions/doAction.js';
 
 let CreatureProperties = new Mongo.Collection('creatureProperties');
 
@@ -36,6 +40,10 @@ let CreaturePropertySchema = new SimpleSchema({
 		type: Boolean,
 		optional: true,
 	},
+  icon: {
+    type: storedIconsSchema,
+    optional: true,
+  }
 });
 
 for (let key in propertySchemasIndex){
@@ -50,7 +58,7 @@ for (let key in propertySchemasIndex){
 	});
 }
 
-function getCreature(property){
+export function getCreature(property){
   if (!property) throw new Meteor.Error('No property provided');
   let creature = Creatures.findOne(property.ancestors[0].id);
   if (!creature) throw new Meteor.Error('Creature does not exist');
@@ -71,8 +79,13 @@ function recomputeCreatures(property){
 }
 
 const insertProperty = new ValidatedMethod({
-  name: 'CreatureProperties.methods.insert',
+  name: 'creatureProperties.insert',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({creatureProperty}) {
     delete creatureProperty._id;
     assertPropertyEditPermission(creatureProperty, this.userId);
@@ -83,13 +96,18 @@ const insertProperty = new ValidatedMethod({
 });
 
 const duplicateProperty = new ValidatedMethod({
-  name: 'CreatureProperties.methods.duplicate',
+  name: 'creatureProperties.duplicate',
   validate: new SimpleSchema({
     _id: {
       type: String,
       regEx: SimpleSchema.RegEx.Id,
     }
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id}) {
     let creatureProperty = CreatureProperties.findOne(_id);
     assertPropertyEditPermission(creatureProperty, this.userId);
@@ -100,7 +118,7 @@ const duplicateProperty = new ValidatedMethod({
 });
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'CreatureProperties.methods.insertPropertyFromLibraryNode',
+	name: 'creatureProperties.insertPropertyFromLibraryNode',
 	validate: new SimpleSchema({
 		nodeId: {
 			type: String,
@@ -110,6 +128,11 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 			type: RefSchema,
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({nodeId, parentRef}) {
 		// get the new ancestry for the properties
 		let {parentDoc, ancestors} = getAncestry({parentRef});
@@ -173,7 +196,7 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 })
 
 const updateProperty = new ValidatedMethod({
-  name: 'CreatureProperties.methods.update',
+  name: 'creatureProperties.update',
   validate({_id, path}){
 		if (!_id) return false;
 		// We cannot change these fields with a simple update
@@ -187,6 +210,11 @@ const updateProperty = new ValidatedMethod({
 				'This property can\'t be updated directly');
 		}
   },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id, path, value}) {
     let property = CreatureProperties.findOne(_id);
     assertPropertyEditPermission(property, this.userId);
@@ -205,8 +233,39 @@ const updateProperty = new ValidatedMethod({
   },
 });
 
+export function damagePropertyWork({property, operation, value}){
+  if (operation === 'set'){
+    let currentValue = property.value;
+    // Set represents what we want the value to be after damage
+    // So we need the actual damage to get to that value
+    let damage = currentValue - value;
+    // Damage can't exceed total value
+    if (damage > currentValue) damage = currentValue;
+    // Damage must be positive
+    if (damage < 0) damage = 0;
+    CreatureProperties.update(property._id, {
+      $set: {damage}
+    }, {
+      selector: property
+    });
+  } else if (operation === 'increment'){
+    let currentValue = property.value - (property.damage || 0);
+    let currentDamage = property.damage;
+    let increment = value;
+    // Can't increase damage above the remaining value
+    if (increment > currentValue) increment = currentValue;
+    // Can't decrease damage below zero
+    if (-increment > currentDamage) increment = -currentDamage;
+    CreatureProperties.update(property._id, {
+      $inc: {damage: increment}
+    }, {
+      selector: property
+    });
+  }
+}
+
 const damageProperty = new ValidatedMethod({
-  name: 'CreatureProperties.methods.adjust',
+  name: 'creatureProperties.damage',
   validate: new SimpleSchema({
     _id: SimpleSchema.RegEx.Id,
     operation: {
@@ -215,6 +274,11 @@ const damageProperty = new ValidatedMethod({
     },
     value: Number,
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 20,
+    timeInterval: 5000,
+  },
   run({_id, operation, value}) {
 		let currentProperty = CreatureProperties.findOne(_id);
 		// Check permissions
@@ -227,41 +291,108 @@ const damageProperty = new ValidatedMethod({
 				`Property of type "${currentProperty.type}" can't be damaged`
 			);
 		}
-		if (operation === 'set'){
-			let currentValue = currentProperty.value;
-			// Set represents what we want the value to be after damage
-			// So we need the actual damage to get to that value
-			let damage = currentValue - value;
-			// Damage can't exceed total value
-			if (damage > currentValue) damage = currentValue;
-			// Damage must be positive
-			if (damage < 0) damage = 0;
-			CreatureProperties.update(_id, {
-				$set: {damage}
-			}, {
-				selector: currentProperty
-			});
-		} else if (operation === 'increment'){
-			let currentValue = currentProperty.value - (currentProperty.damage || 0);
-			let currentDamage = currentProperty.damage;
-			let increment = value;
-			// Can't increase damage above the remaining value
-			if (increment > currentValue) increment = currentValue;
-			// Can't decrease damage below zero
-			if (-increment > currentDamage) increment = -currentDamage;
-			CreatureProperties.update(_id, {
-				$inc: {damage: increment}
-			}, {
-				selector: currentProperty
-			});
-		}
+		damagePropertyWork({property: currentProperty, operation, value})
 		recomputeCreatures(currentProperty);
   },
 });
 
+export function adjustQuantityWork({property, operation, value}){
+  // Check if property has quantity
+  let schema = CreatureProperties.simpleSchema(property);
+  if (!schema.allowsKey('quantity')){
+    throw new Meteor.Error(
+      'Adjust quantity failed',
+      `Property of type "${property.type}" doesn't have a quantity`
+    );
+  }
+  if (operation === 'set'){
+    CreatureProperties.update(property._id, {
+      $set: {quantity: value}
+    }, {
+      selector: property
+    });
+  } else if (operation === 'increment'){
+    // value here is 'damage'
+    value = -value;
+    let currentQuantity = property.quantity;
+    if (currentQuantity + value < 0) value = -currentQuantity;
+    CreatureProperties.update(property._id, {
+      $inc: {quantity: value}
+    }, {
+      selector: property
+    });
+  }
+}
+
+const adjustQuantity = new ValidatedMethod({
+  name: 'creatureProperties.adjustQuantity',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id,
+    operation: {
+      type: String,
+      allowedValues: ['set', 'increment']
+    },
+    value: Number,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id, operation, value}) {
+		let currentProperty = CreatureProperties.findOne(_id);
+		// Check permissions
+		assertPropertyEditPermission(currentProperty, this.userId);
+    adjustQuantityWork({property: currentProperty, operation, value});
+    recomputeCreatures(currentProperty);
+  },
+});
+
+const selectAmmoItem = new ValidatedMethod({
+  name: 'creatureProperties.selectAmmoItem',
+  validate: new SimpleSchema({
+    actionId: SimpleSchema.RegEx.Id,
+    itemId: SimpleSchema.RegEx.Id,
+    itemConsumedIndex: Number,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({actionId, itemId, itemConsumedIndex}) {
+		let action = CreatureProperties.findOne(actionId);
+		// Check permissions
+		assertPropertyEditPermission(action, this.userId);
+    // Check that this index has a document to edit
+    let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
+    if (!itemConsumed){
+      throw new Meteor.Error('Resouce not found',
+        'Could not set ammo, because the ammo document was not found');
+    }
+    let itemToLink = CreatureProperties.findOne(itemId);
+    if (!itemToLink){
+      throw new Meteor.Error('Item not found',
+        'Could not set ammo: the item was not found');
+    }
+    let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
+    CreatureProperties.update(actionId, {
+      $set: {[path]: itemId}
+    }, {
+      selector: action,
+    });
+    recomputeCreatures(action);
+  },
+});
+
 const pushToProperty = new ValidatedMethod({
-	name: 'CreatureProperties.methods.push',
+	name: 'creatureProperties.push',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id, path, value}){
 		let property = CreatureProperties.findOne(_id);
     assertPropertyEditPermission(property, this.userId);
@@ -275,8 +406,13 @@ const pushToProperty = new ValidatedMethod({
 });
 
 const pullFromProperty = new ValidatedMethod({
-	name: 'CreatureProperties.methods.pull',
+	name: 'creatureProperties.pull',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id, path, itemId}){
 		let property = CreatureProperties.findOne(_id);
     assertPropertyEditPermission(property, this.userId);
@@ -291,10 +427,15 @@ const pullFromProperty = new ValidatedMethod({
 });
 
 const softRemoveProperty = new ValidatedMethod({
-	name: 'CreatureProperties.methods.softRemove',
+	name: 'creatureProperties.softRemove',
 	validate: new SimpleSchema({
 		_id: SimpleSchema.RegEx.Id
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id}){
 		let property = CreatureProperties.findOne(_id);
     assertPropertyEditPermission(property, this.userId);
@@ -312,6 +453,8 @@ export {
 	insertPropertyFromLibraryNode,
 	updateProperty,
 	damageProperty,
+  adjustQuantity,
+  selectAmmoItem,
 	pushToProperty,
 	pullFromProperty,
 	softRemoveProperty,

app/imports/api/creature/Creatures.js

@@ -1,4 +1,5 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import deathSaveSchema from '/imports/api/properties/subSchemas/DeathSavesSchema.js'
 import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
@@ -7,6 +8,7 @@ import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
 import { getUserTier } from '/imports/api/users/patreon/tiers.js';
 
 import '/imports/api/creature/removeCreature.js';
+import '/imports/api/creature/restCreature.js';
 
 //set up the collection for creatures
 let Creatures = new Mongo.Collection('creatures');
@@ -27,6 +29,18 @@ let CreatureSettingsSchema = new SimpleSchema({
 		type: Boolean,
 		optional: true,
 	},
+  // Hide all the unused stats
+  hideUnusedStats: {
+    type: Boolean,
+    optional: true,
+  },
+  // How much each hitDice resets on a long rest
+  hitDiceResetMultiplier: {
+    type: Number,
+    optional: true,
+    min: 0,
+    max: 1,
+  }
 });
 
 let CreatureSchema = new SimpleSchema({
@@ -52,24 +66,31 @@ let CreatureSchema = new SimpleSchema({
     type: String,
     optional: true,
   },
-
 	// Mechanics
 	deathSave: {
 		type: deathSaveSchema,
 		defaultValue: {},
 	},
-	xp: {
+  // Stats that are computed and denormalised outside of recomputation
+  denormalizedStats: {
+    type: Object,
+    defaultValue: {},
+  },
+  // Sum of all XP gained by this character
+	'denormalizedStats.xp': {
 		type: SimpleSchema.Integer,
 		defaultValue: 0,
 	},
-	weightCarried: {
+  // Sum of all levels granted by milestone XP
+  'denormalizedStats.milestoneLevels': {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
+  // Sum of all weights of items and containers that are carried
+	'denormalizedStats.weightCarried': {
 		type: Number,
 		defaultValue: 0,
 	},
-	level: {
-		type: SimpleSchema.Integer,
-		defaultValue: 0,
-	},
 	type: {
 		type: String,
 		defaultValue: 'pc',
@@ -100,10 +121,16 @@ Creatures.attachSchema(CreatureSchema);
 
 const insertCreature = new ValidatedMethod({
 
-  name: 'Creatures.methods.insertCreature',
+  name: 'creatures.insertCreature',
 
   validate: null,
 
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
   run() {
     if (!this.userId) {
       throw new Meteor.Error('Creatures.methods.insert.denied',
@@ -126,22 +153,41 @@ const insertCreature = new ValidatedMethod({
 });
 
 const updateCreature = new ValidatedMethod({
-  name: 'Creatures.methods.update',
+  name: 'creatures.update',
   validate({_id, path}){
 		if (!_id) return false;
 		// Allowed fields
-		let allowedFields = ['name', 'alignment', 'gender', 'picture', 'avatarPicture', 'settings'];
+		let allowedFields = [
+      'name',
+      'alignment',
+      'gender',
+      'picture',
+      'avatarPicture',
+      'color',
+      'settings',
+    ];
 		if (!allowedFields.includes(path[0])){
 			throw new Meteor.Error('Creatures.methods.update.denied',
       'This field can\'t be updated using this method');
 		}
   },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id, path, value}) {
 		let creature = Creatures.findOne(_id);
     assertEditPermission(creature, this.userId);
-		Creatures.update(_id, {
-			$set: {[path.join('.')]: value},
-		});
+    if (value === undefined || value === null){
+      Creatures.update(_id, {
+        $unset: {[path.join('.')]: 1},
+      });
+    } else {
+      Creatures.update(_id, {
+        $set: {[path.join('.')]: value},
+      });
+    }
   },
 });
 

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

@@ -0,0 +1,89 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import CreatureProperties, { getCreature, damagePropertyWork, adjustQuantityWork } from '/imports/api/creature/CreatureProperties.js';
+import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/recomputeCreature.js';
+
+const doAction = new ValidatedMethod({
+  name: 'creatureProperties.doAction',
+  validate: new SimpleSchema({
+    actionId: SimpleSchema.RegEx.Id,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  run({actionId}) {
+    let action = CreatureProperties.findOne(actionId);
+		// Check permissions
+    let creature = getCreature(action);
+    assertEditPermission(creature, this.userId);
+		doActionWork(action);
+    // Note this only recomputes the top-level creature, not the nearest one
+		recomputeCreatureByDoc(creature);
+  },
+});
+
+function doActionWork(action){
+  spendResources(action);
+}
+
+function spendResources(action){
+  // Check Uses
+  if (action.usesUsed >= action.usesResult){
+    throw new Meteor.Error('Insufficient Uses',
+      'This action has no uses left');
+  }
+  // Resources
+  if (action.insufficientResources){
+    throw new Meteor.Error('Insufficient Resources',
+      'This creature doesn\'t have sufficient resources to perform this action');
+  }
+  // Items
+  let itemQuantityAdjustments = [];
+  action.resources.itemsConsumed.forEach(itemConsumed => {
+    if (!itemConsumed.itemId){
+      throw new Meteor.Error('Ammo not selected',
+        'No ammo was selected for this action');
+    }
+    let item = CreatureProperties.findOne(itemConsumed.itemId);
+    if (!item || item.ancestors[0].id !== action.ancestors[0].id){
+      throw new Meteor.Error('Ammo not found',
+        'The action\'s ammo was not found on the creature');
+    }
+    if (!item.equipped){
+      throw new Meteor.Error('Ammo not equipped',
+        'The selected ammo is not equipped');
+    }
+    if (!itemConsumed.quantity) return;
+    itemQuantityAdjustments.push({
+      property: item,
+      operation: 'increment',
+      value: itemConsumed.quantity,
+    });
+  });
+  // No more errors should be thrown after this line
+  // Now that we have confirmed that there are no errors, do actual work
+  //Items
+  itemQuantityAdjustments.forEach(adjustQuantityWork);
+  // Use uses
+  CreatureProperties.update(action._id, {
+    $inc: {usesUsed: 1}
+  }, {
+    selector: action
+  });
+  // Damage stats
+  action.resources.attributesConsumed.forEach(attConsumed => {
+    if (!attConsumed.quantity) return;
+    let stat = CreatureProperties.findOne(attConsumed.statId);
+    damagePropertyWork({
+      property: stat,
+      operation: 'increment',
+      value: attConsumed.quantity,
+    });
+  });
+}
+
+export default doAction;

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

@@ -3,7 +3,7 @@ import { includes, cloneDeep } from 'lodash';
 // The computation memo is an in-memory data structure used only during the
 // computation process
 export default class ComputationMemo {
-  constructor(props){
+  constructor(props, creature){
     this.statsByVariableName = {};
     this.extraStatsByVariableName = {};
     this.statsById = {};
@@ -15,6 +15,10 @@ export default class ComputationMemo {
     this.classes = {};
     this.togglesById = {};
     this.toggleIds = new Set();
+    // Equipped items that might be used as ammo
+    this.equipmentById = {};
+    // Properties that have calculations, but don't impact other properties
+    this.endStepPropsById = {};
     // First note all the ids of all the toggles
     props.forEach((prop) => {
       if (
@@ -38,6 +42,10 @@ export default class ComputationMemo {
       ) {
         // Add all the stats
         this.addStat(prop);
+      } else if (
+        prop.type === 'item'
+      ) {
+        this.addEquipment(prop);
       } else {
         return true;
       }
@@ -49,8 +57,19 @@ export default class ComputationMemo {
         this.addProficiency(prop);
       } else if (prop.type === 'classLevel'){
         this.addClassLevel(prop);
+      } else {
+        this.addEndStepProp(prop);
       }
     });
+    for (let name in creature.denormalizedStats){
+      if (!this.statsByVariableName[name]){
+        this.statsByVariableName[name] = {
+          variableName: name,
+          value: creature.denormalizedStats[name],
+          computationDetails: propDetailsByType.denormalizedStat(),
+        }
+      }
+    }
   }
   registerProperty(prop){
     this.originalPropsById[prop._id] = cloneDeep(prop);
@@ -63,46 +82,6 @@ export default class ComputationMemo {
     });
     return prop;
   }
-  /*
-  storeHighestClassLevel(name, prop, isBaseClass){
-    // Only store the highest level classLevel
-    let stat = this.statsByVariableName[name]
-    if (!stat){
-      this.statsByVariableName[name] = prop;
-      if (isBaseClass){
-        this.classes[name] = prop;
-      }
-    } else if (!has(stat, 'level')){
-      // Stat is overriden by an attribute
-      return;
-    } else if (stat.level < prop.level) {
-      this.statsByVariableName[name] = prop;
-      if (isBaseClass){
-        this.classes[name] = prop;
-      }
-    }
-    this.updateLevel();
-  }
-  updateLevel(){
-    let currentLevel = this.statsByVariableName['level'];
-    if (!currentLevel){
-      currentLevel = {
-        value: 0,
-        computationDetails: {
-          builtIn: true,
-          computed: true,
-        }
-      };
-      this.statsByVariableName['level'] = currentLevel;
-    }
-    // bail out if overriden by an attribute
-    if (!currentLevel.computationDetails.builtIn) return;
-    let level = 0;
-    for (let name in this.classes){
-      level += this.classes[name].level || 0;
-    }
-    this.statsByVariableName['level'].value = level;
-  }*/
   addToggle(prop){
     prop = this.registerProperty(prop);
     this.togglesById[prop._id] = prop;
@@ -212,6 +191,14 @@ export default class ComputationMemo {
     });
     return targets;
   }
+  addEquipment(prop){
+    prop = this.registerProperty(prop);
+    this.equipmentById[prop._id] = prop;
+  }
+  addEndStepProp(prop){
+    prop = this.registerProperty(prop);
+    this.endStepPropsById[prop._id] = prop;
+  }
 }
 
 function isAbility(prop){
@@ -237,7 +224,7 @@ function isSkillOperation(prop){
 }
 
 function propDetails(prop){
-  return propDetailsByType[prop.type]() || {};
+  return propDetailsByType[prop.type] && propDetailsByType[prop.type]() || {};
 }
 
 const propDetailsByType = {
@@ -291,4 +278,10 @@ const propDetailsByType = {
       disabledByToggle: false,
     };
   },
+  denormalizedStat(){
+    return {
+      toggleAncestors: [],
+      disabledByToggle: false,
+    };
+  }
 }

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

@@ -2,9 +2,14 @@ import evaluateCalculation from '/imports/api/creature/computation/evaluateCalcu
 
 export default class EffectAggregator{
   constructor(stat, memo){
+    delete this.baseValueErrors;
     if (stat.baseValueCalculation){
-      this.statBaseValue = evaluateCalculation(stat.baseValueCalculation, memo);
-      this.base = +this.statBaseValue;
+      let {value, errors} = evaluateCalculation(stat.baseValueCalculation, memo);
+      this.statBaseValue = value;
+      if (errors.length){
+        this.baseValueErrors = errors;
+      }
+      this.base = this.statBaseValue;
     } else {
       this.base = 0;
     }
@@ -16,17 +21,22 @@ export default class EffectAggregator{
     this.disadvantage = 0;
     this.passiveAdd = 0;
     this.fail = 0;
+    this.set = undefined;
     this.conditional = [];
     this.rollBonus = [];
+    this.hasNoEffects = true;
   }
   addEffect(effect){
     let result = effect.result;
+    if (this.hasNoEffects) this.hasNoEffects = false;
     switch(effect.operation){
       case 'base':
         // Take the largest base value
         this.base = result > this.base ? result : this.base;
         if (effect.statBase){
-          this.statBaseValue = result > this.statBaseValue ? result : this.statBaseValue;
+          if (this.statBaseValue === undefined || result > this.statBaseValue){
+            this.statBaseValue = result;
+          }
         }
         break;
       case 'add':
@@ -45,6 +55,10 @@ export default class EffectAggregator{
         // Take the smallest max value
         this.max = result < this.max ? result : this.max;
         break;
+      case 'set':
+        // Take the highest set value
+        this.set = this.set === undefined || result > this.set ? result : this.set;
+        break;
       case 'advantage':
         // Sum number of advantages
         this.advantage++;

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

@@ -11,17 +11,34 @@ export default function combineStat(stat, aggregator, memo){
   }
 }
 
-function combineAttribute(stat, aggregator){
+function getAggregatorResult(stat, aggregator){
   let result = (aggregator.base + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) result = aggregator.min;
-  if (result > aggregator.max) result = aggregator.max;
-  if (!stat.decimal) result = Math.floor(result);
-  stat.value = result;
+  if (result < aggregator.min) {
+    result = aggregator.min;
+  }
+  if (result > aggregator.max) {
+    result = aggregator.max;
+  }
+  if (aggregator.set !== undefined) {
+    result = aggregator.set;
+  }
+  if (!stat.decimal && Number.isFinite(result)){
+    result = Math.floor(result);
+  }
+  return result;
+}
+
+function combineAttribute(stat, aggregator){
+  stat.value = getAggregatorResult(stat, aggregator);
   stat.baseValue = aggregator.statBaseValue;
+  stat.baseValueErrors = aggregator.baseValueErrors;
   if (stat.attributeType === 'ability') {
-    stat.modifier = Math.floor((result - 10) / 2);
+    stat.modifier = Math.floor((stat.value - 10) / 2);
   }
   stat.currentValue = stat.value - (stat.damage || 0);
+  stat.hide = aggregator.hasNoEffects &&
+    stat.baseValue === undefined ||
+    undefined
 }
 
 function combineSkill(stat, aggregator, memo){
@@ -55,11 +72,19 @@ function combineSkill(stat, aggregator, memo){
   }
   // Multiply the proficiency bonus by the actual proficiency
   profBonus *= stat.proficiency;
+  // Base value
+  stat.baseValue = aggregator.statBaseValue;
+  stat.baseValueErrors = aggregator.baseValueErrors;
   // Combine everything to get the final result
-  let result = (stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
+  let result = (aggregator.base + stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
   if (result < aggregator.min) result = aggregator.min;
   if (result > aggregator.max) result = aggregator.max;
-  result = Math.floor(result);
+  if (aggregator.set !== undefined) {
+    result = aggregator.set;
+  }
+  if (Number.isFinite(result)){
+    result = Math.floor(result);
+  }
   stat.value = result;
   // Advantage/disadvantage
   if (aggregator.advantage && !aggregator.disadvantage){
@@ -79,6 +104,11 @@ function combineSkill(stat, aggregator, memo){
   stat.fail = aggregator.fail;
   // Rollbonus
   stat.rollBonuses = aggregator.rollBonus;
+  // Hide
+  stat.hide = aggregator.hasNoEffects &&
+    stat.baseValue === undefined &&
+    stat.proficiency == 0 ||
+    undefined;
 }
 
 function combineDamageMultiplier(stat){

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

@@ -20,9 +20,12 @@ export default function computeEffect(effect, memo){
   applyToggles(effect, memo);
 
   // Determine result of effect calculation
+  delete effect.errors;
   if (!effect.calculation){
     if(effect.operation === 'add' || effect.operation === 'base'){
       effect.result = 0;
+    } else {
+      delete effect.result
     }
   } else if (Number.isFinite(+effect.calculation)){
     effect.result = +effect.calculation;
@@ -31,7 +34,11 @@ export default function computeEffect(effect, memo){
   } else if(_.contains(['advantage', 'disadvantage', 'fail'], effect.operation)){
     effect.result = 1;
   } else {
-    effect.result = evaluateCalculation(effect.calculation, memo);
+    let {value, errors} = evaluateCalculation(effect.calculation, memo);
+    effect.result = value;
+    if (errors.length){
+      effect.errors = errors;
+    }
   }
   effect.computationDetails.computed = true;
   effect.computationDetails.busyComputing = false;

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

@@ -0,0 +1,96 @@
+import evaluateCalculation from '/imports/api/creature/computation/evaluateCalculation.js';
+
+export default function computeEndStepProperty(prop, memo){
+  switch (prop.type){
+    case 'action':
+    case 'spell':
+      computeAction(prop, memo);
+      break;
+    case 'attack':
+      computeAction(prop, memo);
+      computeAttack(prop, memo);
+      break;
+    case 'savingThrow':
+      computeSavingThrow(prop, memo);
+      break;
+    case 'spellList':
+      computeSpellList(prop, memo);
+      break;
+  }
+}
+
+function computeAction(prop, memo){
+  // Uses
+  let {value, errors} = evaluateCalculation(prop.uses, memo);
+  prop.usesResult = value;
+  if (errors.length){
+    prop.usesErrors = errors;
+  } else {
+    delete prop.usesErrors;
+  }
+  prop.insufficientResources = undefined;
+  if (prop.usesUsed >= prop.usesResult){
+    prop.insufficientResources = true;
+  }
+  // Attributes consumed
+  prop.resources.attributesConsumed.forEach((attConsumed, i) => {
+    if (attConsumed.variableName){
+      let stat = memo.statsByVariableName[attConsumed.variableName];
+      prop.resources.attributesConsumed[i].statId = stat && stat._id;
+      prop.resources.attributesConsumed[i].statName = stat && stat.name;
+      let available = stat && stat.currentValue || 0;
+      prop.resources.attributesConsumed[i].available = available;
+      if (available < attConsumed.quantity){
+        prop.insufficientResources = true;
+      }
+    }
+  });
+  // Items consumed
+  prop.resources.itemsConsumed.forEach((itemConsumed, i) => {
+    let item = itemConsumed.itemId && memo.equipmentById[itemConsumed.itemId];
+    prop.resources.itemsConsumed[i].itemId = item && item._id;
+    let available = item && item.quantity || 0;
+    prop.resources.itemsConsumed[i].available = available;
+    let name = item && item.name;
+    if (item && item.quantity !== 1 && item.plural){
+      name = item.plural;
+    }
+    prop.resources.itemsConsumed[i].itemName = name;
+    prop.resources.itemsConsumed[i].itemIcon = item && item.icon;
+    prop.resources.itemsConsumed[i].itemColor = item && item.color;
+    if (!item || available < itemConsumed.quantity){
+      prop.insufficientResources = true;
+    }
+  });
+}
+
+function computeAttack(prop, memo){
+  // Roll bonus
+  let {value, errors} = evaluateCalculation(prop.rollBonus, memo);
+  prop.rollBonusResult = value;
+  if (errors.length){
+    prop.rollBonusErrors = errors;
+  } else {
+    delete prop.rollBonusErrors;
+  }
+}
+
+function computeSavingThrow(prop, memo){
+  let {value, errors} = evaluateCalculation(prop.dc, memo);
+  prop.dcResult = value;
+  if (errors.length){
+    prop.dcErrors = errors;
+  } else {
+    delete prop.dcErrors;
+  }
+}
+
+function computeSpellList(prop, memo){
+  let {value, errors} = evaluateCalculation(prop.maxPrepared, memo);
+  prop.maxPreparedResult = value;
+  if (errors.length){
+    prop.maxPreparedErrors = errors;
+  } else {
+    delete prop.maxPreparedErrors;
+  }
+}

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

@@ -3,6 +3,7 @@ import computeLevels from '/imports/api/creature/computation/computeLevels.js';
 import computeStat from '/imports/api/creature/computation/computeStat.js';
 import computeEffect from '/imports/api/creature/computation/computeEffect.js';
 import computeToggle from '/imports/api/creature/computation/computeToggle.js';
+import computeEndStepProperty from '/imports/api/creature/computation/computeEndStepProperty.js';
 
 export default function computeMemo(memo){
   // Compute level
@@ -15,8 +16,12 @@ export default function computeMemo(memo){
   each(memo.unassignedEffects, effect => {
     computeEffect(effect, memo);
   });
+  // Compute toggles which didn't already get computed by dependencies
   forOwn(memo.togglesById, toggle => {
     computeToggle(toggle, memo);
   });
-  // Compute class levels
+  // Compute end step properties
+  forOwn(memo.endStepPropsById, prop => {
+    computeEndStepProperty(prop, memo);
+  });
 }

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

@@ -16,6 +16,7 @@ export default function computeToggle(toggle, memo){
   toggle.computationDetails.busyComputing = true;
 
   // Do work
+  delete toggle.errors;
   if (toggle.enabled){
     toggle.toggleResult = true;
   } else if (toggle.disabled){
@@ -25,7 +26,11 @@ export default function computeToggle(toggle, memo){
   } else if (Number.isFinite(+toggle.condition)){
     toggle.toggleResult = !!+toggle.condition;
   } else {
-    toggle.toggleResult = evaluateCalculation(toggle.condition, memo);
+    let {value, errors} = evaluateCalculation(toggle.condition, memo);
+    toggle.toggleResult = value;
+    if (errors.length){
+      toggle.errors = errors;
+    }
   }
   toggle.computationDetails.computed = true;
   toggle.computationDetails.busyComputing = false;

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;
+  if (!string) return {errors: [], value: 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,74 @@ 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);
+    if (typeof value === 'object') value = value.toString();
+    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;
+    }
   }
 }

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

@@ -1,4 +1,5 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
 import ComputationMemo from '/imports/api/creature/computation/ComputationMemo.js';
@@ -6,19 +7,27 @@ import computeMemo from '/imports/api/creature/computation/computeMemo.js';
 import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 import writeAlteredProperties from '/imports/api/creature/computation/writeAlteredProperties.js';
 import writeCreatureVariables from '/imports/api/creature/computation/writeCreatureVariables.js';
-import { recomputeDamageMultipliersById } from '/imports/api/creature/damageMultiplierDenormalise/recomputeDamageMultipliers.js'
+import { recomputeDamageMultipliersById } from '/imports/api/creature/damageMultiplierDenormalise/recomputeDamageMultipliers.js';
+import Creatures from '/imports/api/creature/Creatures.js';
 
 export const recomputeCreature = new ValidatedMethod({
 
-  name: 'Creatures.methods.recomputeCreature',
+  name: 'creatures.recomputeCreature',
 
   validate: new SimpleSchema({
     charId: { type: String }
   }).validator(),
 
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
   run({charId}) {
+    let creature = Creatures.findOne(charId);
     // Permission
-    assertEditPermission(charId, this.userId);
+    assertEditPermission(creature, this.userId);
     // Work, call this direcly if you are already in a method that has checked
     // for permission to edit a given character
     recomputeCreatureById(charId);
@@ -33,8 +42,20 @@ const calculationPropertyTypes = [
   'proficiency',
   'classLevel',
   'toggle',
+  'item',
+  // End step types
+  'action',
+  'attack',
+  'savingThrow',
+  'spellList',
+  'spell',
 ];
 
+export function recomputeCreatureById(creatureId){
+  let creature = Creatures.findOne(creatureId);
+  recomputeCreatureByDoc(creature);
+}
+
 /**
  * This function is the heart of DiceCloud. It recomputes a creature's stats,
  * distilling down effects and proficiencies into the final stats that make up
@@ -71,17 +92,18 @@ const calculationPropertyTypes = [
  *   - Mark the stat as computed
  * - Write the computed results back to the database
  */
-export function recomputeCreatureById(creatureId){
+export function recomputeCreatureByDoc(creature){
+  const creatureId = creature._id;
   let props = getActiveProperties({
     ancestorId: creatureId,
     filter: {type: {$in: calculationPropertyTypes}},
     includeUntoggled: true,
+    // TODO filter out expensive fields, particularly icon field
   });
-  let computationMemo = new ComputationMemo(props);
+  let computationMemo = new ComputationMemo(props, creature);
   computeMemo(computationMemo);
   writeAlteredProperties(computationMemo);
   writeCreatureVariables(computationMemo, creatureId);
-  // if(Meteor.isClient) console.log(computationMemo);
   recomputeDamageMultipliersById(creatureId);
   return computationMemo;
 }

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

@@ -1,16 +1,29 @@
 import { Meteor } from 'meteor/meteor'
 import { isEqual, forOwn } from 'lodash';
+import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
+// Schemas
+// Calculated props
 import { ComputedOnlySkillSchema } from '/imports/api/properties/Skills.js';
 import { ComputedOnlyAttributeSchema } from '/imports/api/properties/Attributes.js';
 import { ComputedOnlyEffectSchema } from '/imports/api/properties/Effects.js';
 import { ComputedOnlyToggleSchema } from '/imports/api/properties/Toggles.js';
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
+// End step props
+import { ComputedOnlyActionSchema } from '/imports/api/properties/Actions.js';
+import { ComputedOnlyAttackSchema } from '/imports/api/properties/Attacks.js';
+import { ComputedOnlySavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
+import { ComputedOnlySpellListSchema } from '/imports/api/properties/SpellLists.js';
+import { ComputedOnlySpellSchema } from '/imports/api/properties/Spells.js';
 
 const schemasByType = {
   'skill': ComputedOnlySkillSchema,
   'attribute': ComputedOnlyAttributeSchema,
   'effect': ComputedOnlyEffectSchema,
   'toggle': ComputedOnlyToggleSchema,
+  'action': ComputedOnlyActionSchema,
+  'attack': ComputedOnlyAttackSchema,
+  'savingThrow': ComputedOnlySavingThrowSchema,
+  'spellList': ComputedOnlySpellListSchema,
+  'spell': ComputedOnlySpellSchema,
 };
 
 export default function writeAlteredProperties(memo){

app/imports/api/creature/damageMultiplierDenormalise/recomputeDamageMultipliers.js

@@ -1,4 +1,5 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
 import Creatures from '/imports/api/creature/Creatures.js';
@@ -6,12 +7,18 @@ import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
 export const recomputeDamageMultipliers = new ValidatedMethod({
 
-  name: 'Creatures.methods.recomputeDamageMultipliers',
+  name: 'creatures.recomputeDamageMultipliers',
 
   validate: new SimpleSchema({
     creatureId: { type: String }
   }).validator(),
 
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
   run({creatureId}) {
     // Permission
     assertEditPermission(creatureId, this.userId);

app/imports/api/creature/experience/Experiences.js

@@ -0,0 +1,197 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import Creatures from '/imports/api/creature/Creatures.js';
+import { recomputeCreatureById } from '/imports/api/creature/computation/recomputeCreature.js';
+
+let Experiences = new Mongo.Collection('experiences');
+
+let ExperienceSchema = new SimpleSchema({
+	name: {
+		type: String,
+		optional: true,
+	},
+	// The amount of XP this experience gives
+	xp: {
+		type: SimpleSchema.Integer,
+		optional: true,
+    min: 0,
+	},
+  // Setting levels instead of value grants whole levels
+  levels: {
+    type: SimpleSchema.Integer,
+    optional: true,
+    min: 0,
+    index: 1,
+  },
+	// The real-world date that it occured, usually sorted by date
+	date: {
+		type: Date,
+		autoValue: function() {
+			// If the date isn't set, set it to now
+			if (!this.isSet) {
+				return new Date();
+			}
+		},
+    index: 1,
+	},
+  creatureId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    index: 1,
+  },
+});
+
+Experiences.attachSchema(ExperienceSchema);
+
+const insertExperienceForCreature = function({experience, creatureId, userId}){
+  assertEditPermission(creatureId, userId);
+  if (experience.xp){
+    Creatures.update(creatureId, {$inc: {
+      'denormalizedStats.xp': experience.xp
+    }});
+  }
+  if (experience.levels) {
+    Creatures.update(creatureId, {$inc: {
+      'denormalizedStats.milestoneLevels': experience.levels
+    }});
+  }
+  experience.creatureId = creatureId;
+  let id = Experiences.insert(experience);
+  recomputeCreatureById(creatureId);
+  return id;
+};
+
+const insertExperience = new ValidatedMethod({
+  name: 'experiences.insert',
+  validate: new SimpleSchema({
+    experience: {
+      type: ExperienceSchema.omit('creatureId'),
+    },
+    creatureIds: {
+      type: Array,
+      max: 12,
+    },
+    'creatureIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({experience, creatureIds}) {
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('Experiences.methods.insert.denied',
+      'You need to be logged in to insert an experience');
+    }
+    let tier = getUserTier(this.userId);
+    if (!tier.paidBenefits){
+      throw new Meteor.Error('Experiences.methods.insert.denied',
+      `The ${tier.name} tier does not allow you to grant experience`);
+    }
+    let insertedIds = [];
+    creatureIds.forEach(creatureId => {
+      let id = insertExperienceForCreature({experience, creatureId, userId});
+      insertedIds.push(id);
+    });
+    return insertedIds;
+  },
+});
+
+const removeExperience = new ValidatedMethod({
+  name: 'experiences.remove',
+  validate: new SimpleSchema({
+    experienceId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({experienceId}) {
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('Experiences.methods.remove.denied',
+      'You need to be logged in to remove an experience');
+    }
+    let tier = getUserTier(this.userId);
+    if (!tier.paidBenefits){
+      throw new Meteor.Error('Experiences.methods.remove.denied',
+      `The ${tier.name} tier does not allow you to remove  an experience`);
+    }
+    let experience = Experiences.findOne(experienceId);
+    if (!experience) return;
+    let creatureId = experience.creatureId
+    assertEditPermission(creatureId, userId);
+    if (experience.xp){
+      Creatures.update(creatureId, {$inc: {
+        'denormalizedStats.xp': -experience.xp
+      }});
+    }
+    if (experience.levels) {
+      Creatures.update(creatureId, {$inc: {
+        'denormalizedStats.milestoneLevels': -experience.levels
+      }});
+    }
+    experience.creatureId = creatureId;
+    let numRemoved = Experiences.remove(experienceId);
+    recomputeCreatureById(creatureId);
+    return numRemoved;
+  },
+});
+
+const recomputeExperiences = new ValidatedMethod({
+  name: 'experiences.recompute',
+  validate: new SimpleSchema({
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({creatureId}) {
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('Experiences.methods.recompute.denied',
+      'You need to be logged in to recompute a creature\'s experiences');
+    }
+    let tier = getUserTier(this.userId);
+    if (!tier.paidBenefits){
+      throw new Meteor.Error('Experiences.methods.recompute.denied',
+      `The ${tier.name} tier does not allow you to recompute a creature's experiences`);
+    }
+    assertEditPermission(creatureId, userId);
+
+    let xp = 0;
+    let milestoneLevels = 0;
+    Experiences.find({
+      creatureId
+    }, {
+      fields: {xp: 1, levels: 1}
+    }).forEach(experience => {
+      xp += experience.xp || 0;
+      milestoneLevels += experience.levels || 0;
+    });
+    Creatures.update(creatureId, {$set: {
+      'denormalizedStats.xp': xp,
+      'denormalizedStats.milestoneLevels': milestoneLevels
+    }});
+    recomputeCreatureById(creatureId);
+  },
+});
+
+export default Experiences;
+export { ExperienceSchema, insertExperience, removeExperience, recomputeExperiences };

app/imports/api/creature/getActiveProperties.js

@@ -6,6 +6,15 @@ export default function getActiveProperties({
   filter = {},
   options,
   includeUntoggled = false
+}){
+  filter = getActivePropertyFilter({ancestorId, filter, includeUntoggled});
+  return CreatureProperties.find(filter, options).fetch();
+}
+
+export function getActivePropertyFilter({
+  ancestorId,
+  filter = {},
+  includeUntoggled = false
 }){
   if (!ancestorId){
     throw 'Ancestor Id is required to get active properties'
@@ -14,9 +23,9 @@ export default function getActiveProperties({
   let disabledAncestorsFilter = {
     'ancestors.id': ancestorId,
     $or: [
-      {disabled: true},
-      {equipped: false},
-      {applied: false},
+      {disabled: true}, // Everything can be disabled
+      {equipped: false}, // Items can be equipped
+      {applied: false}, // Buffs can be applied
     ],
   };
   if (!includeUntoggled){
@@ -48,5 +57,5 @@ export default function getActiveProperties({
   filter._id = {
     $nin: disabledAncestorIds,
   }
-  return CreatureProperties.find(filter, options).fetch();
+  return filter;
 }

app/imports/api/creature/journal/JournalEntry.js

@@ -1,7 +1,7 @@
 import SimpleSchema from 'simpl-schema';
 
 let ExperienceSchema = new SimpleSchema({
-	name: {
+	title: {
 		type: String,
 		optional: true,
 	},
@@ -10,11 +10,6 @@ let ExperienceSchema = new SimpleSchema({
 		type: String,
 		optional: true,
 	},
-	// The amount of XP this experience gives
-	value: {
-		type: SimpleSchema.Integer,
-		optional: true,
-	},
 	// The real-world date that it occured
 	date: {
 		type: Date,
@@ -30,6 +25,20 @@ let ExperienceSchema = new SimpleSchema({
 		type: String,
 		optional: true,
 	},
+  // Tags to better find this entry later
+  tags: {
+    type: Array,
+    defaultValue: [],
+  },
+  'tags.$': {
+    type: String,
+  },
+  // ID of the journal this entry belongs to
+  journalId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    index: 1,
+  }
 });
 
 export { ExperienceSchema };

app/imports/api/creature/removeCreature.js

@@ -1,20 +1,29 @@
 import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import Creatures from '/imports/api/creature/Creatures.js';
 import CreatureProperties from '/imports/api/creature/CreatureProperties.js'
 import { assertOwnership } from '/imports/api/creature/creaturePermissions.js';
+import Experiences from '/imports/api/creature/experience/Experiences.js';
 
-function removeRelatedDocuments(charId){
-  CreatureProperties.remove({'ancestors.id': charId});
-};
+function removeRelatedDocuments(creatureId){
+  CreatureProperties.remove({'ancestors.id': creatureId});
+  Experiences.remove({creatureId});
+}
 
 const removeCreature = new ValidatedMethod({
-  name: "Creatures.methods.removeCreature", // DDP method name
+  name: 'Creatures.methods.removeCreature', // DDP method name
   validate: new SimpleSchema({
     charId: {
       type: String,
       regEx: SimpleSchema.RegEx.Id,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({charId}) {
     assertOwnership(charId, this.userId)
     Creatures.remove(charId);

app/imports/api/creature/restCreature.js

@@ -0,0 +1,112 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import Creatures from '/imports/api/creature/Creatures.js';
+import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
+import getActiveProperties, { getActivePropertyFilter } from '/imports/api/creature/getActiveProperties.js';
+import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { recomputeCreatureById } from '/imports/api/creature/computation/recomputeCreature.js';
+
+const restCreature = new ValidatedMethod({
+  name: 'creature.methods.longRest',
+  validate: new SimpleSchema({
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    restType: {
+      type: String,
+      allowedValues: ['shortRest', 'longRest'],
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({creatureId, restType}) {
+    let creature = Creatures.findOne(creatureId, {
+      fields: {
+        owner: 1,
+        writers: 1,
+        settings: 1,
+      }
+    }) ;
+    // Need edit permissions
+    assertEditPermission(creature, this.userId);
+
+    // Long rests reset short rest properties as well
+    let resetFilter;
+    if (restType === 'shortRest'){
+      resetFilter = 'shortRest'
+    } else {
+      resetFilter = {$in: ['shortRest', 'longRest']}
+    }
+    // Only apply to active properties
+    let filter = getActivePropertyFilter({
+      filter: {reset: resetFilter},
+      ancestorId: creatureId,
+      includeUntoggled: true,
+    });
+    // update all attribute's damage
+    filter.type = 'attribute';
+    CreatureProperties.update(filter, {
+      $set: {damage: 0}
+    }, {
+      selector: {type: 'attribute'},
+      multi: true,
+    });
+    // Update all action-like properties' usesUsed
+    filter.type = {$in: [
+      'action',
+      'attack',
+      'spell'
+    ]};
+    CreatureProperties.update(filter, {
+      $set: {usesUsed: 0}
+    }, {
+      selector: {type: 'action'},
+      multi: true,
+    });
+    // Reset half hit dice on a long rest, starting with the highest dice
+    if (restType === 'longRest'){
+      let hitDice = getActiveProperties({
+        ancestorId: creatureId,
+        filter: {type: 'attribute', attributeType: 'hitDice'},
+        options: {fields: {
+          hitDiceSize: 1,
+          damage: 1,
+          value: 1,
+        }},
+      });
+      // Use a collator to do sorting in natural order
+      let collator = new Intl.Collator('en', {
+        numeric: true, sensitivity: 'base'
+      });
+      // Get the hit dice in decending order of hitDiceSize
+      let compare = (a, b) => collator.compare(b.hitDiceSize, a.hitDiceSize)
+      hitDice.sort(compare);
+      // Get the total number of hit dice that can be recovered this rest
+      let totalHd = hitDice.reduce((sum, hd) => sum + (hd.value || 0), 0);
+      let resetMultiplier = creature.settings.hitDiceResetMultiplier || 0.5;
+      let recoverableHd = Math.max(Math.floor(totalHd*resetMultiplier), 1);
+      // recover each hit dice in turn until the recoverable amount is used up
+      let amountToRecover, resultingDamage;
+      hitDice.forEach(hd => {
+        if (!recoverableHd) return;
+        amountToRecover = Math.min(recoverableHd, hd.damage || 0);
+        if (!amountToRecover) return;
+        recoverableHd -= amountToRecover;
+        resultingDamage = hd.damage - amountToRecover;
+        CreatureProperties.update(hd._id, {
+          $set: {damage: resultingDamage}
+        }, {
+          selector: {type: 'attribute'},
+        });
+      });
+    }
+    recomputeCreatureById(creatureId);
+  },
+});
+
+export default restCreature;

app/imports/api/icons/Icons.js

@@ -1,8 +1,11 @@
 import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertAdmin } from '/imports/api/sharing/sharingPermissions.js';
 
 let Icons = new Mongo.Collection('icons');
 
-iconsSchema = new SimpleSchema({
+let iconsSchema = new SimpleSchema({
 	name: {
 		type: String,
     unique: true,
@@ -33,21 +36,62 @@ if (Meteor.isServer) {
   });
 }
 
+const storedIconsSchema = new SimpleSchema({
+  name: {
+    type: String,
+  },
+  shape: {
+    type: String,
+  },
+});
+
 Icons.attachSchema(iconsSchema);
 
-/*
-console.warn("Write Icons is not secure, disable before deployment")
+// This method does not validate icons against the schema, use wisely;
 const writeIcons = new ValidatedMethod({
-	name: 'writeIcons',
+	name: 'icons.write',
 	validate: null,
 	run(icons){
+    assertAdmin(this.userId);
     if (Meteor.isServer){
       this.unblock();
       Icons.rawCollection().insert(icons, {ordered: false});
     }
 	}
 });
-*/
 
-export { writeIcons };
+const findIcons = new ValidatedMethod({
+  name: 'icons.find',
+  validate: new SimpleSchema({
+    search: {
+      type: String,
+      max: 30,
+      optional: true,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({search}){
+    if (!search) return [];
+    if (!Meteor.isServer) return;
+    return Icons.find(
+      { $text: {$search: search} },
+      {
+        // relevant documents have a higher score.
+        fields: {
+          score: { $meta: 'textScore' }
+        },
+        // `score` property specified in the projection fields above.
+        sort: {
+          score: { $meta: 'textScore' }
+        }
+      }
+    ).fetch();
+  }
+})
+
+export { writeIcons, findIcons, storedIconsSchema };
 export default Icons;

app/imports/api/library/Libraries.js

@@ -1,4 +1,5 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import SharingSchema from '/imports/api/sharing/SharingSchema.js';
 import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
@@ -34,7 +35,7 @@ Libraries.attachSchema(LibrarySchema);
 export default Libraries;
 
 const insertLibrary = new ValidatedMethod({
-  name: 'Libraries.methods.insert',
+  name: 'libraries.insert',
 	mixins: [
 		simpleSchemaMixin,
   ],
@@ -55,7 +56,7 @@ const insertLibrary = new ValidatedMethod({
 });
 
 const updateLibraryName = new ValidatedMethod({
-	name: 'Libraries.methods.updateName',
+	name: 'libraries.updateName',
 	validate: new SimpleSchema({
 		_id: {
 			type: String,
@@ -65,6 +66,11 @@ const updateLibraryName = new ValidatedMethod({
 			type: String,
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id, name}){
 		let library = Libraries.findOne(_id);
 		assertEditPermission(library, this.userId);
@@ -73,7 +79,7 @@ const updateLibraryName = new ValidatedMethod({
 });
 
 const setLibraryDefault = new ValidatedMethod({
-  name: 'Libraries.methods.makeLibraryDefault',
+  name: 'libraries.makeLibraryDefault',
 	validate: new SimpleSchema({
 		_id: {
 			type: String,
@@ -83,6 +89,11 @@ const setLibraryDefault = new ValidatedMethod({
 			type: Boolean,
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id, isDefault}) {
 		if (!Meteor.users.isAdmin()){
 			throw new Meteor.Error('Permission denied', 'User must be admin to set libraries as default');
@@ -92,13 +103,18 @@ const setLibraryDefault = new ValidatedMethod({
 });
 
 const removeLibrary = new ValidatedMethod({
-	name: 'Libraries.methods.remove',
+	name: 'libraries.remove',
 	validate: new SimpleSchema({
 		_id: {
 			type: String,
 			regEx: SimpleSchema.RegEx.id
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id}){
 		let library = Libraries.findOne(_id);
 		assertOwnership(library, this.userId);

app/imports/api/library/LibraryNodes.js

@@ -1,6 +1,7 @@
 import { Meteor } from 'meteor/meteor';
 import { Mongo } from 'meteor/mongo';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
 import ChildSchema from '/imports/api/parenting/ChildSchema.js';
@@ -9,6 +10,7 @@ import Libraries from '/imports/api/library/Libraries.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { softRemove } from '/imports/api/parenting/softRemove.js';
 import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
+import { storedIconsSchema } from '/imports/api/icons/Icons.js';
 
 let LibraryNodes = new Mongo.Collection('libraryNodes');
 
@@ -24,6 +26,10 @@ let LibraryNodeSchema = new SimpleSchema({
 	'tags.$': {
 		type: String,
 	},
+  icon: {
+    type: storedIconsSchema,
+    optional: true,
+  }
 });
 
 for (let key in propertySchemasIndex){
@@ -51,8 +57,13 @@ function assertNodeEditPermission(node, userId){
 }
 
 const insertNode = new ValidatedMethod({
-  name: 'LibraryNodes.methods.insert',
+  name: 'libraryNodes.insert',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run(libraryNode) {
     delete libraryNode._id;
     assertNodeEditPermission(libraryNode, this.userId);
@@ -61,13 +72,18 @@ const insertNode = new ValidatedMethod({
 });
 
 const duplicateNode = new ValidatedMethod({
-  name: 'LibraryNodes.methods.duplicate',
+  name: 'libraryNodes.duplicate',
 	validate: new SimpleSchema({
     _id: {
       type: String,
       regEx: SimpleSchema.RegEx.Id,
     }
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id}) {
     let libraryNode = LibraryNodes.findOne(_id);
     assertNodeEditPermission(libraryNode, this.userId);
@@ -77,7 +93,7 @@ const duplicateNode = new ValidatedMethod({
 })
 
 const updateLibraryNode = new ValidatedMethod({
-  name: 'LibraryNodes.methods.update',
+  name: 'libraryNodes.update',
   validate({_id, path}){
 		if (!_id) return false;
 		// We cannot change these fields with a simple update
@@ -89,6 +105,11 @@ const updateLibraryNode = new ValidatedMethod({
 				return false;
 		}
   },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({_id, path, value}) {
     let node = LibraryNodes.findOne(_id);
     assertNodeEditPermission(node, this.userId);
@@ -107,8 +128,13 @@ const updateLibraryNode = new ValidatedMethod({
 });
 
 const pushToLibraryNode = new ValidatedMethod({
-	name: 'LibraryNodes.methods.push',
+	name: 'libraryNodes.push',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id, path, value}){
 		let node = LibraryNodes.findOne(_id);
     assertNodeEditPermission(node, this.userId);
@@ -121,8 +147,13 @@ const pushToLibraryNode = new ValidatedMethod({
 });
 
 const pullFromLibraryNode = new ValidatedMethod({
-	name: 'LibraryNodes.methods.pull',
+	name: 'libraryNodes.pull',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id, path, itemId}){
 		let node = LibraryNodes.findOne(_id);
     assertNodeEditPermission(node, this.userId);
@@ -136,10 +167,15 @@ const pullFromLibraryNode = new ValidatedMethod({
 });
 
 const softRemoveLibraryNode = new ValidatedMethod({
-	name: 'LibraryNodes.methods.softRemove',
+	name: 'libraryNodes.softRemove',
 	validate: new SimpleSchema({
 		_id: SimpleSchema.RegEx.Id
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({_id}){
 		let node = LibraryNodes.findOne(_id);
     assertNodeEditPermission(node, this.userId);

app/imports/api/parenting/organizeMethods.js

@@ -1,6 +1,7 @@
 import SimpleSchema from 'simpl-schema';
 import { union } from 'lodash';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { updateParent } from '/imports/api/parenting/parenting.js';
 import { reorderDocs, safeUpdateDocOrder } from '/imports/api/parenting/order.js';
 import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
@@ -10,7 +11,7 @@ import getCollectionByName from '/imports/api/parenting/getCollectionByName.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/recomputeCreature.js';
 
 const organizeDoc = new ValidatedMethod({
-  name: 'organize.methods.organizeDoc',
+  name: 'organize.organizeDoc',
   validate: new SimpleSchema({
     docRef: RefSchema,
     parentRef: RefSchema,
@@ -19,6 +20,11 @@ const organizeDoc = new ValidatedMethod({
       // Should end in 0.5 to place it reliably between two existing documents
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({docRef, parentRef, order}) {
     let doc = fetchDocByRef(docRef);
     let collection = getCollectionByName(docRef.collection);
@@ -54,7 +60,7 @@ const organizeDoc = new ValidatedMethod({
 });
 
 const reorderDoc = new ValidatedMethod({
-  name: 'organize.methods.reorderDoc',
+  name: 'organize.reorderDoc',
   validate: new SimpleSchema({
     docRef: RefSchema,
     order: {
@@ -62,6 +68,11 @@ const reorderDoc = new ValidatedMethod({
       // Should end in 0.5 to place it reliably between two existing documents
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({docRef, order}) {
     let doc = fetchDocByRef(docRef);
     assertDocEditPermission(doc, this.userId);

app/imports/api/properties/Actions.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
-import ResourcesSchema from '/imports/api/properties/subSchemas/ResourcesSchema.js'
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
+import { storedIconsSchema } from '/imports/api/icons/Icons.js'
 
 /*
  * Actions are things a character can do
@@ -12,6 +13,10 @@ let ActionSchema = new SimpleSchema({
 		type: String,
 		optional: true,
 	},
+	summary: {
+		type: String,
+		optional: true,
+	},
 	description: {
 		type: String,
 		optional: true,
@@ -40,13 +45,60 @@ let ActionSchema = new SimpleSchema({
   'tags.$': {
     type: String,
   },
+  // Duplicate the ResourceSchema here so we can extend it elegantly.
   resources: {
-    type: ResourcesSchema,
+    type: Object,
     defaultValue: {},
+  },
+  'resources.itemsConsumed': {
+    type: Array,
+    defaultValue: [],
+  },
+  'resources.itemsConsumed.$': {
+    type: Object,
+  },
+  'resources.itemsConsumed.$._id': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    autoValue(){
+      if (!this.isSet) return Random.id();
+    }
+  },
+  'resources.itemsConsumed.$.tag': {
+    type: String,
+    optional: true,
+  },
+  'resources.itemsConsumed.$.quantity': {
+    type: Number,
+    defaultValue: 1,
+  },
+  'resources.itemsConsumed.$.itemId': {
+    type: String,
+    optional: true,
+  },
+  'resources.attributesConsumed': {
+    type: Array,
+    defaultValue: [],
+  },
+  'resources.attributesConsumed.$': {
+    type: Object,
+  },
+  'resources.attributesConsumed.$._id': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    autoValue(){
+      if (!this.isSet) return Random.id();
+    }
+  },
+  'resources.attributesConsumed.$.variableName': {
+    type: String,
+    optional: true,
+  },
+  'resources.attributesConsumed.$.quantity': {
+    type: Number,
+    defaultValue: 1,
   },
 	// Calculation of how many times this action can be used
-	// Only set if this action tracks its own uses, rather than adjusting
-	// resources
 	uses: {
 		type: String,
 		optional: true,
@@ -64,4 +116,69 @@ let ActionSchema = new SimpleSchema({
 	},
 });
 
-export { ActionSchema };
+const ComputedOnlyActionSchema = new SimpleSchema({
+  usesResult: {
+    type: SimpleSchema.Integer,
+    optional: true,
+  },
+  usesErrors: {
+    type: Array,
+    optional: true,
+  },
+  'usesErrors.$':{
+    type: ErrorSchema,
+  },
+  resources: Object,
+  'resources.itemsConsumed': Array,
+  'resources.itemsConsumed.$': Object,
+  'resources.itemsConsumed.$.available': {
+    type: Number,
+    optional: true,
+  },
+  // This appears both in the computed and uncomputed schema because it can be
+  // set by both a computation or a form
+  'resources.itemsConsumed.$.itemId': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    optional: true,
+  },
+  'resources.itemsConsumed.$.itemName': {
+    type: String,
+    optional: true,
+  },
+  'resources.itemsConsumed.$.itemIcon': {
+    type: storedIconsSchema,
+    optional: true,
+  },
+  'resources.itemsConsumed.$.itemColor': {
+    type: String,
+    optional: true,
+  },
+  'resources.attributesConsumed': Array,
+  'resources.attributesConsumed.$': Object,
+  'resources.attributesConsumed.$.available': {
+    type: Number,
+    optional: true,
+  },
+  'resources.attributesConsumed.$.statId': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    optional: true,
+  },
+  'resources.attributesConsumed.$.statName': {
+    type: String,
+    optional: true,
+  },
+  // True if the uses left is zero, or any item or attribute consumed is
+  // insufficient
+  insufficientResources: {
+    type: Boolean,
+    optional: true,
+  },
+});
+
+const ComputedActionSchema = new SimpleSchema()
+  .extend(ActionSchema)
+  .extend(ComputedOnlyActionSchema);
+
+export { ActionSchema, ComputedOnlyActionSchema, ComputedActionSchema};

app/imports/api/properties/Adjustments.js

@@ -2,6 +2,7 @@ import SimpleSchema from 'simpl-schema';
 
 const AdjustmentSchema = new SimpleSchema({
 	// The roll that determines how much to change the attribute
+  // This can be simplified, but should only compute when activated
   amount: {
     type: String,
     optional: true,

app/imports/api/properties/Attacks.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
-import { ActionSchema } from '/imports/api/properties/Actions.js';
+import { ActionSchema, ComputedOnlyActionSchema } from '/imports/api/properties/Actions.js';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 // Attacks are special instances of actions
 let AttackSchema = new SimpleSchema()
@@ -25,4 +26,24 @@ let AttackSchema = new SimpleSchema()
     },
   });
 
-export { AttackSchema };
+const ComputedOnlyAttackSchema = new SimpleSchema()
+  .extend(ComputedOnlyActionSchema)
+  .extend({
+    rollBonusResult: {
+      type: Number,
+      optional: true,
+    },
+    rollBonusErrors: {
+      type: Array,
+      optional: true,
+    },
+    'rollBonusErrors.$':{
+      type: ErrorSchema,
+    },
+  });
+
+const ComputedAttackSchema = new SimpleSchema()
+  .extend(AttackSchema)
+  .extend(ComputedOnlyAttackSchema);
+
+export { AttackSchema, ComputedOnlyAttackSchema, ComputedAttackSchema };

app/imports/api/properties/Attributes.js

@@ -1,4 +1,5 @@
 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';
 
 /*
@@ -13,7 +14,7 @@ let AttributeSchema = new SimpleSchema({
   variableName: {
     type: String,
 		regEx: VARIABLE_NAME_REGEX,
-    min: 3,
+    min: 2,
     defaultValue: 'newAttribute',
   },
 	// How it is displayed and computed is determined by type
@@ -73,18 +74,36 @@ let ComputedOnlyAttributeSchema = new SimpleSchema({
   baseValue: {
     type: SimpleSchema.oneOf(Number, String, Boolean),
     optional: true,
+  },
+  baseValueErrors: {
+    type: Array,
+    optional: true,
+  },
+  'baseValueErrors.$': {
+    type: ErrorSchema,
   },
 	// The computed value of the attribute
   value: {
     type: SimpleSchema.oneOf(Number, String, Boolean),
 		defaultValue: 0,
     optional: true,
+  },
+  // The computed value of the attribute minus the damage
+  currentValue: {
+    type: SimpleSchema.oneOf(Number, String, Boolean),
+		defaultValue: 0,
+    optional: true,
   },
 	// The computed modifier, provided the attribute type is `ability`
 	modifier: {
 		type: SimpleSchema.Integer,
 		optional: true,
 	},
+  // Should this attribute hide
+  hide: {
+    type: Boolean,
+    optional: true,
+  },
 });
 
 const ComputedAttributeSchema = new SimpleSchema()

app/imports/api/properties/ClassLevels.js

@@ -9,6 +9,7 @@ let ClassLevelSchema = new SimpleSchema({
 	// The name of this class level's variable
 	variableName: {
     type: String,
+    min: 2,
 		regEx: VARIABLE_NAME_REGEX,
   },
 	level: {

app/imports/api/properties/Containers.js

@@ -18,12 +18,12 @@ let ContainerSchema = new SimpleSchema({
 	weight: {
 		type: Number,
 		min: 0,
-		defaultValue: 0
+    optional: true,
 	},
 	value: {
 		type: Number,
 		min: 0,
-		defaultValue: 0
+    optional: true,
 	},
 	description: {
 		type: String,
@@ -32,4 +32,16 @@ let ContainerSchema = new SimpleSchema({
 	},
 });
 
-export { ContainerSchema };
+const ComputedOnlyContainerSchema = new SimpleSchema({
+  // Weight of all the contents, zero if `contentsWeightless` is true
+  contentsWeight:{
+    type: Number,
+    optional: true,
+  },
+});
+
+const ComputedContainerSchema = new SimpleSchema()
+	.extend(ComputedOnlyContainerSchema)
+	.extend(ContainerSchema);
+
+export { ContainerSchema, ComputedContainerSchema };

app/imports/api/properties/DamageMultipliers.js

@@ -34,11 +34,11 @@ let DamageMultiplierSchema = new SimpleSchema({
     type: String,
   },
   // Tags which must be present to be affected by this multiplier (AND)
-  targetTags: {
+  includeTags: {
     type: Array,
     defaultValue: [],
   },
-  'targetTags.$': {
+  'includeTags.$': {
     type: String,
   },
 });

app/imports/api/properties/Damages.js

@@ -3,6 +3,7 @@ import DAMAGE_TYPES from '/imports/constants/DAMAGE_TYPES.js';
 
 const DamageSchema = new SimpleSchema({
 	// The roll that determines how much to damage the attribute
+  // This can be simplified, but only computed when applied
   amount: {
     type: String,
     optional: true,

app/imports/api/properties/Effects.js

@@ -1,5 +1,5 @@
 import SimpleSchema from 'simpl-schema';
-
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 /*
  * Effects are reason-value attached to skills and abilities
  * that modify their final value or presentation in some way
@@ -18,6 +18,7 @@ let EffectSchema = new SimpleSchema({
 			'mul',
 			'min',
 			'max',
+      'set',
 			'advantage',
 			'disadvantage',
 			'passiveAdd',
@@ -37,7 +38,6 @@ let EffectSchema = new SimpleSchema({
 	},
 	'stats.$': {
 		type: String,
-		optional: true,
 	},
 });
 
@@ -47,7 +47,15 @@ const ComputedOnlyEffectSchema = new SimpleSchema({
 		type: SimpleSchema.oneOf(Number, String, Boolean),
 		optional: true,
 	},
-})
+  // The errors encountered while computing the result
+  errors: {
+    type: Array,
+    optional: true,
+  },
+  'errors.$':{
+    type: ErrorSchema,
+  },
+});
 
 const ComputedEffectSchema = new SimpleSchema()
 	.extend(ComputedOnlyEffectSchema)

app/imports/api/properties/Items.js

@@ -24,13 +24,13 @@ const ItemSchema = new SimpleSchema({
 	weight: {
 		type: Number,
 		min: 0,
-		defaultValue: 0,
+    optional: true,
 	},
 	// Value per item in the stack, in gold pieces
 	value: {
 		type: Number,
 		min: 0,
-		defaultValue: 0,
+    optional: true,
 	},
 	// If this item is equipped, it requires attunement
 	// Being equipped is `enabled === true`

app/imports/api/properties/Proficiencies.js

@@ -12,7 +12,6 @@ let ProficiencySchema = new SimpleSchema({
 	},
 	'stats.$': {
 		type: String,
-		optional: true,
 	},
 	// A number representing how proficient the character is
 	value: {

app/imports/api/properties/Rolls.js

@@ -19,7 +19,7 @@ import SimpleSchema from 'simpl-schema';
  *  child rolls are applied
  */
 let RollSchema = new SimpleSchema({
-  // The roll
+  // The roll, can be simplified, but only computed in context
   roll: {
     type: String,
     optional: true,

app/imports/api/properties/SavingThrows.js

@@ -1,8 +1,13 @@
 import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 // These are the rolls made when saves are called for
 // For the saving throw bonus or proficiency, see ./Skills.js
 let SavingThrowSchema = new SimpleSchema ({
+  name: {
+    type: String,
+    optional: true,
+  },
   dc: {
     type: String,
     optional: true,
@@ -14,4 +19,22 @@ let SavingThrowSchema = new SimpleSchema ({
   },
 });
 
-export { SavingThrowSchema };
+const ComputedOnlySavingThrowSchema = new SimpleSchema({
+  dcResult: {
+    type: Number,
+    optional: true,
+  },
+  dcErrors: {
+    type: Array,
+    optional: true,
+  },
+  'dcErrors.$':{
+    type: ErrorSchema,
+  },
+});
+
+const ComputedSavingThrowSchema = new SimpleSchema()
+  .extend(SavingThrowSchema)
+  .extend(ComputedOnlySavingThrowSchema);
+
+export { SavingThrowSchema, ComputedOnlySavingThrowSchema, ComputedSavingThrowSchema };

app/imports/api/properties/Skills.js

@@ -1,4 +1,6 @@
 import SimpleSchema from 'simpl-schema';
+import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 /*
  * Skills are anything that results in a modifier to be added to a D20
@@ -13,7 +15,8 @@ let SkillSchema = new SimpleSchema({
   // Ignored for skilltype = save
   variableName: {
     type: String,
-		regEx: /^\w*[a-z]\w*$/i,
+    regEx: VARIABLE_NAME_REGEX,
+    min: 2,
   },
 	// The variable name of the ability this skill relies on
   ability: {
@@ -35,9 +38,9 @@ let SkillSchema = new SimpleSchema({
     ],
     defaultValue: 'skill',
   },
-	// If the baseValue is higher than the computed value, it will be used as `value`
-	baseValue: {
-		type: Number,
+  // The starting value, before effects
+	baseValueCalculation: {
+		type: String,
 		optional: true,
 	},
 	// The base proficiency of this skill
@@ -57,6 +60,18 @@ let ComputedOnlySkillSchema = new SimpleSchema({
   value: {
     type: Number,
 		defaultValue: 0,
+  },
+  // The result of baseValueCalculation
+  baseValue: {
+    type: SimpleSchema.oneOf(Number, String, Boolean),
+    optional: true,
+  },
+  baseValueErrors: {
+    type: Array,
+    optional: true,
+  },
+  'baseValueErrors.$': {
+    type: ErrorSchema,
   },
 	// Computed value added by the ability
 	abilityMod: {
@@ -101,6 +116,11 @@ let ComputedOnlySkillSchema = new SimpleSchema({
     type: SimpleSchema.Integer,
     optional: true,
   },
+  // Should this attribute hide
+  hide: {
+    type: Boolean,
+    optional: true,
+  },
 })
 
 const ComputedSkillSchema = new SimpleSchema()

app/imports/api/properties/SpellLists.js

@@ -1,4 +1,5 @@
 import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 let SpellListSchema = new SimpleSchema({
 	name: {
@@ -16,4 +17,22 @@ let SpellListSchema = new SimpleSchema({
 	},
 });
 
-export { SpellListSchema }
+const ComputedOnlySpellListSchema = new SimpleSchema({
+  maxPreparedResult: {
+    type: Number,
+    optional: true,
+  },
+  maxPreparedErrors: {
+    type: Array,
+    optional: true,
+  },
+  'maxPreparedErrors.$':{
+    type: ErrorSchema,
+  },
+});
+
+const ComputedSpellListSchema = new SimpleSchema()
+  .extend(SpellListSchema)
+  .extend(ComputedOnlySpellListSchema);
+
+export { SpellListSchema, ComputedOnlySpellListSchema, ComputedSpellListSchema };

app/imports/api/properties/Spells.js

@@ -1,4 +1,4 @@
-import { ActionSchema } from '/imports/api/properties/Actions.js';
+import { ActionSchema, ComputedOnlyActionSchema } from '/imports/api/properties/Actions.js';
 import SimpleSchema from 'simpl-schema';
 
 const magicSchools = [
@@ -93,4 +93,11 @@ let SpellSchema = new SimpleSchema({})
 	},
 });
 
-export { SpellSchema };
+const ComputedOnlySpellSchema = new SimpleSchema()
+  .extend(ComputedOnlyActionSchema);
+
+const ComputedSpellSchema = new SimpleSchema()
+  .extend(SpellSchema)
+  .extend(ComputedOnlySpellSchema);
+
+export { SpellSchema, ComputedOnlySpellSchema, ComputedSpellSchema };

app/imports/api/properties/Toggles.js

@@ -1,4 +1,5 @@
 import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 const ToggleSchema = new SimpleSchema({
   name: {
@@ -27,6 +28,14 @@ const ComputedOnlyToggleSchema = new SimpleSchema({
 		type: SimpleSchema.oneOf(Number, String, Boolean),
 		optional: true,
 	},
+  // The errors encountered while computing the result
+  errors: {
+    type: Array,
+    optional: true,
+  },
+  'errors.$': {
+    type: ErrorSchema,
+  },
 });
 
 const ComputedToggleSchema = new SimpleSchema()

app/imports/api/properties/computedPropertySchemasIndex.js

@@ -1,7 +1,7 @@
 import SimpleSchema from 'simpl-schema';
-import { ActionSchema } from '/imports/api/properties/Actions.js';
+import { ComputedActionSchema } from '/imports/api/properties/Actions.js';
 import { AdjustmentSchema } from '/imports/api/properties/Adjustments.js';
-import { AttackSchema } from '/imports/api/properties/Attacks.js';
+import { ComputedAttackSchema } from '/imports/api/properties/Attacks.js';
 import { ComputedAttributeSchema } from '/imports/api/properties/Attributes.js';
 import { BuffSchema } from '/imports/api/properties/Buffs.js';
 import { ClassLevelSchema } from '/imports/api/properties/ClassLevels.js';
@@ -9,41 +9,39 @@ import { ContainerSchema } from '/imports/api/properties/Containers.js';
 import { DamageSchema } from '/imports/api/properties/Damages.js';
 import { DamageMultiplierSchema } from '/imports/api/properties/DamageMultipliers.js';
 import { ComputedEffectSchema } from '/imports/api/properties/Effects.js';
-import { ExperienceSchema } from '/imports/api/properties/Experiences.js';
 import { FeatureSchema } from '/imports/api/properties/Features.js';
 import { FolderSchema } from '/imports/api/properties/Folders.js';
 import { ItemSchema } from '/imports/api/properties/Items.js';
 import { NoteSchema } from '/imports/api/properties/Notes.js';
 import { ProficiencySchema } from '/imports/api/properties/Proficiencies.js';
 import { RollSchema } from '/imports/api/properties/Rolls.js';
-import { SavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
+import { ComputedSavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
 import { ComputedSkillSchema } from '/imports/api/properties/Skills.js';
 import { SlotSchema } from '/imports/api/properties/Slots.js';
-import { SpellSchema } from '/imports/api/properties/Spells.js';
-import { SpellListSchema } from '/imports/api/properties/SpellLists.js';
+import { ComputedSpellSchema } from '/imports/api/properties/Spells.js';
+import { ComputedSpellListSchema } from '/imports/api/properties/SpellLists.js';
 import { ToggleSchema } from '/imports/api/properties/Toggles.js';
 
 const propertySchemasIndex = {
-  action: ActionSchema,
+  action: ComputedActionSchema,
   adjustment: AdjustmentSchema,
-  attack: AttackSchema,
+  attack: ComputedAttackSchema,
   attribute: ComputedAttributeSchema,
   buff: BuffSchema,
   classLevel: ClassLevelSchema,
   damage: DamageSchema,
   damageMultiplier: DamageMultiplierSchema,
   effect: ComputedEffectSchema,
-  experience: ExperienceSchema,
   feature: FeatureSchema,
   folder: FolderSchema,
   note: NoteSchema,
   proficiency: ProficiencySchema,
   roll: RollSchema,
-  savingThrow: SavingThrowSchema,
+  savingThrow: ComputedSavingThrowSchema,
   skill: ComputedSkillSchema,
   slot: SlotSchema,
-  spellList: SpellListSchema,
-  spell: SpellSchema,
+  spellList: ComputedSpellSchema,
+  spell: ComputedSpellListSchema,
   toggle: ToggleSchema,
   container: ContainerSchema,
   item: ItemSchema,

app/imports/api/properties/propertySchemasIndex.js

@@ -8,7 +8,6 @@ import { ClassLevelSchema } from '/imports/api/properties/ClassLevels.js';
 import { DamageSchema } from '/imports/api/properties/Damages.js';
 import { DamageMultiplierSchema } from '/imports/api/properties/DamageMultipliers.js';
 import { EffectSchema } from '/imports/api/properties/Effects.js';
-import { ExperienceSchema } from '/imports/api/properties/Experiences.js';
 import { FeatureSchema } from '/imports/api/properties/Features.js';
 import { FolderSchema } from '/imports/api/properties/Folders.js';
 import { NoteSchema } from '/imports/api/properties/Notes.js';
@@ -33,7 +32,6 @@ const propertySchemasIndex = {
   damage: DamageSchema,
   damageMultiplier: DamageMultiplierSchema,
   effect: EffectSchema,
-  experience: ExperienceSchema,
   feature: FeatureSchema,
   folder: FolderSchema,
   note: NoteSchema,

app/imports/api/properties/subSchemas/ErrorSchema.js

@@ -0,0 +1,12 @@
+import SimpleSchema from 'simpl-schema';
+
+const ErrorSchema = new SimpleSchema({
+  message: {
+    type: String,
+  },
+	type: {
+    type: String,
+	},
+});
+
+export default ErrorSchema;

app/imports/api/properties/subSchemas/ItemConsumedSchema.js

@@ -17,6 +17,10 @@ const ItemConsumedSchema = new SimpleSchema({
     type: Number,
     defaultValue: 1,
   },
+  itemId: {
+    type: String,
+    optional: true,
+  },
 });
 
 export default ItemConsumedSchema;

app/imports/api/sharing/sharing.js

@@ -4,13 +4,19 @@ import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
 import getCollectionByName from '/imports/api/parenting/getCollectionByName.js';
 import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
 const setPublic = new ValidatedMethod({
-  name: 'sharing.methods.setPublic',
+  name: 'sharing.setPublic',
 	validate: new SimpleSchema({
 		docRef: RefSchema,
     isPublic: { type: Boolean },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({docRef, isPublic}){
 		let doc = fetchDocByRef(docRef);
 		assertOwnership(doc, this.userId);
@@ -21,7 +27,7 @@ const setPublic = new ValidatedMethod({
 });
 
 const updateUserSharePermissions = new ValidatedMethod({
-  name: 'sharing.methods.updateUserSharePermissions',
+  name: 'sharing.updateUserSharePermissions',
 	validate: new SimpleSchema({
 		docRef: RefSchema,
     userId: {
@@ -33,6 +39,11 @@ const updateUserSharePermissions = new ValidatedMethod({
       allowedValues: ['reader', 'writer', 'none'],
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({docRef, userId, role}){
 		let doc = fetchDocByRef(docRef);
     if (role === 'none'){

app/imports/api/sharing/sharingPermissions.js

@@ -113,3 +113,17 @@ export function assertDocViewPermission(doc, userId){
   let root = getRoot(doc);
   assertViewPermission(root, userId);
 }
+
+export function assertAdmin(userId){
+  assertIdValid(userId);
+  let user = Meteor.users.findOne(userId, {fields: {roles: 1}});
+  if (!user){
+    throw new Meteor.Error('Permission denied',
+      'UserId does not match any existing user');
+  }
+  let isAdmin = user.roles && user.roles.includes('admin')
+  if (!isAdmin){
+    throw new Meteor.Error('Permission denied',
+      'User does not have the admin role');
+  }
+}

app/imports/api/users/Invites.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { getUserTier } from '/imports/api/users/patreon/tiers.js';
 
 let Invites= new Mongo.Collection('invites');
@@ -85,13 +86,18 @@ function alignInvitesWithPatreonTier(user){
 }
 
 const getInviteToken = new ValidatedMethod({
-  name: 'Invites.methods.getToken',
+  name: 'invites.getToken',
   validate: new SimpleSchema({
     inviteId: {
       type: String,
       regEx: SimpleSchema.RegEx.Id,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({inviteId}) {
     let invite = Invites.findOne(inviteId);
     if (this.userId !== invite.inviter) {
@@ -109,12 +115,17 @@ const getInviteToken = new ValidatedMethod({
 });
 
 const acceptInviteToken = new ValidatedMethod({
-  name: 'Invites.methods.acceptToken',
+  name: 'invites.acceptToken',
   validate: new SimpleSchema({
     inviteToken: {
       type: String,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({inviteToken}) {
     if (!this.userId) {
       throw new Meteor.Error('Invites.methods.acceptToken.denied',
@@ -146,13 +157,18 @@ const acceptInviteToken = new ValidatedMethod({
 });
 
 const revokeInvite = new ValidatedMethod({
-  name: 'Invites.methods.revokeInvite',
+  name: 'invites.revokeInvite',
   validate: new SimpleSchema({
     inviteId: {
       type: String,
       regEx: SimpleSchema.RegEx.Id,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({inviteId}) {
     if (!this.userId) {
       throw new Meteor.Error('Invites.methods.revokeInvite.denied',

app/imports/api/users/Users.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
 const userSchema = new SimpleSchema({
 	username: {
@@ -87,8 +88,13 @@ const userSchema = new SimpleSchema({
 Meteor.users.attachSchema(userSchema);
 
 Meteor.users.generateApiKey = new ValidatedMethod({
-  name: 'Users.methods.generateApiKey',
+  name: 'users.generateApiKey',
 	validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run(){
 		if(Meteor.isClient) return;
 		var user = Meteor.users.findOne(this.userId);
@@ -100,10 +106,15 @@ Meteor.users.generateApiKey = new ValidatedMethod({
 });
 
 Meteor.users.setDarkMode = new ValidatedMethod({
-  name: 'Users.methods.setDarkMode',
+  name: 'users.setDarkMode',
 	validate: new SimpleSchema({
     darkMode: { type: Boolean },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({darkMode}){
 		if (!this.userId) return;
 		Meteor.users.update(this.userId, {$set: {darkMode}});
@@ -111,7 +122,7 @@ Meteor.users.setDarkMode = new ValidatedMethod({
 });
 
 Meteor.users.sendVerificationEmail = new ValidatedMethod({
-	name: 'Users.methods.sendVerificationEmail',
+	name: 'users.sendVerificationEmail',
 	validate: new SimpleSchema({
 		userId:{
 			type: String,
@@ -121,6 +132,11 @@ Meteor.users.sendVerificationEmail = new ValidatedMethod({
 			type: String,
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({userId, address}){
 		userId = this.userId || userId;
 		let user = Meteor.users.findOne(userId);
@@ -143,8 +159,13 @@ Meteor.users.isAdmin = function(userId){
 }
 
 Meteor.users.canPickUsername = new ValidatedMethod({
-	name: 'Users.methods.canPickUsername',
+	name: 'users.canPickUsername',
 	validate: userSchema.pick('username').validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({username}){
 		if (Meteor.isClient) return;
 		let user = Accounts.findUserByUsername(username);
@@ -157,8 +178,13 @@ Meteor.users.canPickUsername = new ValidatedMethod({
 });
 
 Meteor.users.setUsername = new ValidatedMethod({
-  name: 'Users.methods.setUsername',
+  name: 'users.setUsername',
 	validate: userSchema.pick('username').validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({username}){
 		if (!this.userId) throw 'Can only set your username if logged in';
     if (Meteor.isClient) return;
@@ -167,7 +193,7 @@ Meteor.users.setUsername = new ValidatedMethod({
 });
 
 Meteor.users.subscribeToLibrary = new ValidatedMethod({
-  name: 'Users.methods.subscribeToLibrary',
+  name: 'users.subscribeToLibrary',
 	validate: new SimpleSchema({
 		libraryId:{
 			type: String,
@@ -177,6 +203,11 @@ Meteor.users.subscribeToLibrary = new ValidatedMethod({
       type: Boolean,
     },
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({libraryId, subscribe}){
 		if (!this.userId) throw 'Can only subscribe if logged in';
     if (subscribe){
@@ -192,12 +223,17 @@ Meteor.users.subscribeToLibrary = new ValidatedMethod({
 });
 
 Meteor.users.findUserByUsernameOrEmail = new ValidatedMethod({
-	name: 'Users.methods.findUserByUsernameOrEmail',
+	name: 'users.findUserByUsernameOrEmail',
 	validate: new SimpleSchema({
 		usernameOrEmail:{
 			type: String,
 		},
 	}).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
 	run({usernameOrEmail}){
 		if (Meteor.isClient) return;
 		let user = Accounts.findUserByUsername(usernameOrEmail) ||

app/imports/constants/DAMAGE_TYPES.js

@@ -1,17 +1,18 @@
 const DAMAGE_TYPES = Object.freeze([
-  "bludgeoning",
-  "piercing",
-  "slashing",
-  "acid",
-  "cold",
-  "fire",
-  "force",
-  "lightning",
-  "necrotic",
-  "poison",
-  "psychic",
-  "radiant",
-  "thunder",
+  'healing',
+  'bludgeoning',
+  'piercing',
+  'slashing',
+  'acid',
+  'cold',
+  'fire',
+  'force',
+  'lightning',
+  'necrotic',
+  'poison',
+  'psychic',
+  'radiant',
+  'thunder',
 ]);
 
 export default DAMAGE_TYPES;

app/imports/constants/PROPERTIES.js

@@ -1,44 +1,44 @@
 const PROPERTIES = Object.freeze({
   action: {
-    icon: 'offline_bolt',
+    icon: '$vuetify.icons.action',
     name: 'Action'
   },
-  adjustment: {
-    icon: 'warning',
-    name: 'Attribute damage'
-  },
   attack: {
-    icon: 'bolt',
+    icon: '$vuetify.icons.attack',
     name: 'Attack'
   },
   attribute: {
-    icon: 'donut_small',
+    icon: '$vuetify.icons.attribute',
     name: 'Attribute'
   },
+  adjustment: {
+    icon: '$vuetify.icons.attribute_damage',
+    name: 'Attribute damage'
+  },
   buff: {
-    icon: 'star',
+    icon: '$vuetify.icons.buff',
     name: 'Buff'
   },
   classLevel: {
-    icon: 'school',
+    icon: '$vuetify.icons.class_level',
     name: 'Class level'
   },
+  container: {
+    icon: 'work',
+    name: 'Container'
+  },
   damage: {
-    icon: 'report',
+    icon: '$vuetify.icons.damage',
     name: 'Damage'
   },
   damageMultiplier: {
-    icon: 'layers',
+    icon: '$vuetify.icons.damage_multiplier',
     name: 'Damage multiplier'
   },
   effect: {
-    icon: 'show_chart',
+    icon: '$vuetify.icons.effect',
     name: 'Effect'
   },
-  experience: {
-    icon: 'add',
-    name: 'Experience'
-  },
   feature: {
     icon: 'subject',
     name: 'Feature'
@@ -47,6 +47,10 @@ const PROPERTIES = Object.freeze({
     icon: 'folder',
     name: 'Folder'
   },
+  item: {
+    icon: '$vuetify.icons.item',
+    name: 'Item'
+  },
   note: {
     icon: 'note',
     name: 'Note'
@@ -56,35 +60,27 @@ const PROPERTIES = Object.freeze({
     name: 'Proficiency'
   },
   roll: {
-    icon: 'flare',
+    icon: '$vuetify.icons.roll',
     name: 'Roll'
   },
   savingThrow: {
-    icon: 'all_out',
+    icon: '$vuetify.icons.saving_throw',
     name: 'Saving throw'
   },
   skill: {
-    icon: 'check_box',
+    icon: '$vuetify.icons.skill',
     name: 'Skill'
   },
   spellList: {
-    icon: 'list',
+    icon: '$vuetify.icons.spell_list',
     name: 'Spell list'
   },
   spell: {
-    icon: 'whatshot',
+    icon: '$vuetify.icons.spell',
     name: 'Spell'
   },
-  container: {
-    icon: 'work',
-    name: 'Container'
-  },
-  item: {
-    icon: 'category',
-    name: 'Item'
-  },
   toggle: {
-    icon: 'power_settings_new',
+    icon: '$vuetify.icons.toggle',
     name: 'Toggle'
   },
 });

app/imports/server/config/SimpleRestConfig.js

@@ -0,0 +1,6 @@
+import { SimpleRest } from 'meteor/simple:rest';
+
+SimpleRest.configure({
+  // No default collection methods get end points
+  collections: [],
+});

app/imports/server/cron/deleteSoftRemovedDocuments.js

@@ -1,11 +1,18 @@
+import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 import LibraryNodes from '/imports/api/library/LibraryNodes.js';
+import { assertAdmin } from '/imports/api/sharing/sharingPermissions.js';
+import { SyncedCron } from 'meteor/percolate:synced-cron';
 
-let collections = [LibraryNodes];
+Meteor.startup(() => {
+	const collections = [
+		CreatureProperties,
+    LibraryNodes,
+	];
 
-if (Meteor.isServer) Meteor.startup(() => {
 	/**
 	 * Deletes all soft removed documents that were removed more than 30 minutes ago
 	 * and were not restored
+	 * @return {Number} Number of documents removed
 	 */
 	const deleteOldSoftRemovedDocs = function(){
 		const now = new Date();
@@ -14,30 +21,30 @@ if (Meteor.isServer) Meteor.startup(() => {
 			collection.remove({
 				removed: true,
 				removedAt: {$lt: thirtyMinutesAgo} // dates *before* 30 minutes ago
-			}, error => {
-				if (error) console.error(error);
+			}, function(error){
+				if (error){
+					console.error(error);
+				}
 			});
 		});
-		return;
 	};
 
 	SyncedCron.add({
-		name: "Delete all soft removed items that haven't been restored",
+		name: 'deleteSoftRemovedDocs',
 		schedule: function(parser) {
-			return parser.text('every 6 hours');
+			return parser.text('every 2 hours');
 		},
-		job: function() {
-			deleteOldSoftRemovedDocs();
-		}
+		job: deleteOldSoftRemovedDocs,
 	});
 
+	SyncedCron.start();
+
 	// Add a method to manually trigger removal
 	Meteor.methods({
 		deleteOldSoftRemovedDocs() {
-			const user = Meteor.users.findOne(this.userId);
-			if (user && _.contains(user.roles, "admin")){
-				return deleteOldSoftRemovedDocs();
-			}
+      assertAdmin(this.userId);
+			this.unblock();
+			deleteOldSoftRemovedDocs();
 		},
 	});
 });

app/imports/server/publications/experiences.js

@@ -0,0 +1,32 @@
+import SimpleSchema from 'simpl-schema';
+import Creatures from '/imports/api/creature/Creatures.js';
+import Experiences from '/imports/api/creature/experience/Experiences.js';
+
+let schema = new SimpleSchema({
+  creatureId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+  },
+});
+
+Meteor.publish('experiences', function(creatureId){
+  schema.validate({ creatureId });
+  this.autorun(function (){
+    let userId = this.userId;
+    let creatureCursor = Creatures.find({
+      _id: creatureId,
+      $or: [
+        {readers: userId},
+        {writers: userId},
+        {owner: userId},
+        {public: true},
+      ],
+    });
+    if (!creatureCursor.count()) return this.ready();
+    return [
+      Experiences.find({
+        creatureId,
+      }),
+    ];
+  });
+});

app/imports/server/publications/index.js

@@ -1,5 +1,7 @@
+import '/imports/server/publications/publicationRateLimit.js';
 import '/imports/server/publications/characterList.js';
 import '/imports/server/publications/library.js';
 import '/imports/server/publications/singleCharacter.js';
+import '/imports/server/publications/experiences.js';
 import '/imports/server/publications/users.js';
 import '/imports/server/publications/icons.js';

app/imports/server/publications/library.js

@@ -40,16 +40,23 @@ let libraryIdSchema = new SimpleSchema({
 Meteor.publish('library', function(libraryId){
   libraryIdSchema.validate({libraryId});
   this.autorun(function (){
-    if (!this.userId) return [];
-    let libraryCursor = Libraries.find({
-      _id: libraryId,
-      $or: [
-        {owner: this.userId},
-        {writers: this.userId},
-        {readers: this.userId},
-        {public: true},
-      ],
-    });
+    let libraryCursor
+    if (this.userId) {
+      libraryCursor = Libraries.find({
+        _id: libraryId,
+        $or: [
+          {owner: this.userId},
+          {writers: this.userId},
+          {readers: this.userId},
+          {public: true},
+        ],
+      });
+    } else {
+      libraryCursor = Libraries.find({
+        _id: libraryId,
+        public: true,
+      });
+    }
     if (!libraryCursor.count()) return this.ready();
     return [
       libraryCursor,

app/imports/server/publications/publicationRateLimit.js

@@ -0,0 +1,4 @@
+// Limit all subscriptions to 1/s
+DDPRateLimiter.addRule({
+  type: 'subscription',
+}, 10, 10000);

app/imports/ui/components/CoinValue.vue

@@ -0,0 +1,40 @@
+<template lang="html">
+  <div>
+    <span
+      v-if="coinValue.gp || value === 0"
+    >
+      {{ coinValue.gp }} gp
+    </span>
+    <span
+      v-if="coinValue.sp || (coinValue.gp && coinValue.cp)"
+    >
+      {{ coinValue.sp }} sp
+    </span>
+    <span
+      v-if="coinValue.cp"
+    >
+      {{ coinValue.cp }} cp
+    </span>
+  </div>
+</template>
+
+<script>
+import valueToCoins from '/imports/ui/utility/valueToCoins.js';
+
+export default {
+  props:{
+    value: {
+      type: Number,
+      default: undefined,
+    },
+  },
+  computed:{
+    coinValue(){
+      return valueToCoins(this.value);
+    }
+  },
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/components/ColorPicker.vue

@@ -56,7 +56,7 @@
               <v-scroll-y-transition>
                 <v-icon
                   v-if="kebabShade === shadeOption"
-                  :class="{dark: isDark(color, shade)}"
+                  :class="isDark(color, shade) ? 'dark' : 'light'"
                 >
                   check
                 </v-icon>

app/imports/ui/components/IconSearch.vue

@@ -1,79 +0,0 @@
-<template lang="html">
-	<v-autocomplete
-		v-model="model"
-		:search-input.sync="searchString"
-		:items="items"
-		:loading="!$subReady.searchIcons || isLoading"
-		item-text="name"
-		item-value="_id"
-		label="Search icons"
-		hide-no-data
-		@input="input"
-	>
-		<template
-			slot="item"
-			slot-scope="{ item, tile }"
-		>
-			<v-list-tile-avatar>
-				<svg class="avatar" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path :d="item.shape"/></svg>
-			</v-list-tile-avatar>
-			<v-list-tile-content>
-				<v-list-tile-title v-text="item.name"></v-list-tile-title>
-			</v-list-tile-content>
-		</template>
-	</v-autocomplete>
-</template>
-
-<script>
-import Icons from '/imports/api/icons/Icons.js';
-
-export default {
-	data(){ return {
-		model: this.value,
-		searchString: null,
-		serverSearchString: null,
-		isLoading: false,
-	}},
-	props: {
-		value: String,
-	},
-	watch: {
-		searchString(string){
-			this.isLoading = true;
-			this.searchServer(string)
-		},
-		value(newValue){
-			this.model = newValue;
-		},
-	},
-	methods: {
-		searchServer: _.debounce(function(string){
-			this.serverSearchString = string;
-		}, 200),
-		input(e){
-			this.$emit('input', e);
-		}
-	},
-	meteor: {
-		$subscribe: {
-			searchIcons() {
-				this.isLoading = false;
-				return [this.serverSearchString];
-			},
-		},
-		items(){
-			return Icons.find({}, { sort: [['score', 'desc']] }).fetch();
-		},
-	},
-}
-</script>
-
-<style lang="css" scoped>
-	.avatar {
-		width: 100%;
-		height: 100%;
-	}
-	.theme--dark .avatar {
-		fill: white;
-	}
-</style>

app/imports/ui/components/IncrementButton.vue

@@ -0,0 +1,58 @@
+<template lang="html">
+  <v-menu
+    v-model="open"
+    origin="center center"
+    transition="scale-transition"
+    :nudge-left="130"
+    :min-width="305"
+    :close-on-content-click="false"
+  >
+    <template #activator="{ on }">
+      <v-btn
+        v-bind="$attrs"
+        v-on="on"
+      >
+        <slot>
+          <v-icon>add</v-icon>
+        </slot>
+      </v-btn>
+    </template>
+    <v-card>
+      <increment-menu
+        flat
+        :value="value"
+        :open="open"
+        @change="changeIncrementMenu"
+        @close="open = false"
+      />
+    </v-card>
+  </v-menu>
+</template>
+
+<script>
+import IncrementMenu from '/imports/ui/components/IncrementMenu.vue';
+
+export default {
+  components: {
+    IncrementMenu,
+  },
+  props: {
+    value: {
+      type: Number,
+      required: true,
+    },
+  },
+  data(){return {
+    open: false
+  }},
+  methods: {
+    changeIncrementMenu(e){
+      this.$emit('change', e);
+      this.open = false;
+    },
+  },
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/components/IncrementMenu.vue

@@ -0,0 +1,166 @@
+<template>
+  <v-layout
+    row
+    align-center
+    justify-center
+    class="increment-menu"
+  >
+    <v-spacer />
+    <v-btn-toggle
+      :value="operation === 'add' ? 0: operation === 'subtract' ? 1 : null"
+      class="mx-2"
+      @click="$refs.editInput.focus()"
+    >
+      <v-btn
+        :disabled="context.editPermission === false"
+        class="filled"
+        @click="toggleAdd(); $nextTick(() => $refs.editInput.focus())"
+      >
+        <v-icon>add</v-icon>
+      </v-btn>
+      <v-btn
+        :disabled="context.editPermission === false"
+        class="filled"
+        @click="toggleSubtract(); $nextTick(() => $refs.editInput.focus())"
+      >
+        <v-icon>remove</v-icon>
+      </v-btn>
+    </v-btn-toggle>
+    <v-text-field
+      ref="editInput"
+      :solo="!flat"
+      :class="flat && 'ma-0 pa-0'"
+      hide-details
+      type="number"
+      style="max-width: 120px;"
+      min="0"
+      :value="editValue"
+      :prepend-inner-icon="operationIcon(operation)"
+      :disabled="context.editPermission === false"
+      @focus="$event.target.select()"
+      @keypress="keypress"
+      @input="input"
+    />
+    <v-btn
+      :small="!flat"
+      :fab="!flat"
+      :flat="flat"
+      :icon="flat"
+      class="filled"
+      @click="commitEdit"
+    >
+      <v-icon>done</v-icon>
+    </v-btn>
+    <v-btn
+      :small="!flat"
+      :fab="!flat"
+      :flat="flat"
+      :icon="flat"
+      class="mx-0 filled"
+      @click="cancelEdit"
+    >
+      <v-icon>close</v-icon>
+    </v-btn>
+    <v-spacer />
+  </v-layout>
+</template>
+
+<script>
+	export default {
+    inject: {
+      context: { default: {} }
+    },
+		props: {
+			value: {
+        type: Number,
+        required: true,
+      },
+      open: Boolean,
+      flat: Boolean,
+		},
+		data() {
+			return {
+				editValue: 0,
+				operation: 'set',
+				hover: false,
+			};
+		},
+    watch: {
+      open(newValue){
+        if (newValue){
+          this.resetData();
+        }
+      }
+    },
+		methods: {
+      resetData(){
+        this.editValue = this.value;
+        this.operation = 'set';
+        // this.$nextTick didn't work, using timeout instead did
+        setTimeout(() => {
+          if (this.$refs.editInput){
+            this.$refs.editInput.focus();
+          }
+        }, 100);
+      },
+			cancelEdit() {
+				this.$emit('close');
+			},
+			commitEdit() {
+				this.editing = false;
+				let value = +this.$refs.editInput.lazyValue;
+				if (this.operation === 'add') {
+					value = -value;
+				}
+				let type = this.operation === 'set' ? 'set' : 'increment';
+				this.$emit('change', { type, value });
+			},
+			operationIcon(operation) {
+				switch (operation) {
+					case 'set':
+						return 'forward';
+					case 'add':
+            return 'add';
+					case 'subtract':
+						return 'remove';
+				}
+			},
+			toggleAdd(){
+				this.operation = (this.operation === 'add') ? 'set': 'add';
+			},
+			toggleSubtract(){
+				this.operation = (this.operation === 'subtract') ? 'set': 'subtract';
+			},
+			keypress(event) {
+				let digitsOnly = /[0-9]/;
+				let key = event.key;
+				if (key === '+') {
+					this.toggleAdd();
+					event.preventDefault();
+				} else if (key === '-') {
+					this.toggleSubtract();
+					event.preventDefault();
+				} else if (key === 'Enter') {
+					this.commitEdit();
+				} else if (!digitsOnly.test(key)){
+					event.preventDefault();
+				}
+			},
+      input(value){
+        if (+value < 0){
+          this.editValue = -value;
+          this.operation = 'subtract';
+        }
+      }
+		}
+	};
+</script>
+
+<style scoped>
+	.filled.theme--light {
+		background: #fff !important;
+	}
+	.filled.theme--dark {
+		background: #424242 !important;
+	}
+</style>

app/imports/ui/components/ToolbarCard.vue

@@ -9,6 +9,7 @@
       :style="`transform: none; ${hasToolbarClickListener ? 'cursor: pointer;' : ''}`"
       :color="color"
       :dark="isDark"
+      :light="!isDark"
       @click="$emit('toolbarclick')"
     >
       <slot name="toolbar" />

app/imports/ui/components/global/IconPicker.vue

@@ -0,0 +1,131 @@
+<template lang="html">
+  <v-menu
+    v-model="menu"
+    :close-on-content-click="false"
+    lazy
+    transition="slide-y-transition"
+    min-width="290px"
+    style="overflow-y: auto;"
+  >
+    <template #activator="{ on }">
+      <div class="layout row align-center">
+        <v-label>{{ label }}</v-label>
+        <v-btn
+          :loading="loading"
+          large
+          icon
+          v-on="on"
+        >
+          <svg-icon
+            v-if="safeValue && safeValue.shape"
+            large
+            :shape="safeValue.shape"
+          />
+          <v-icon
+            v-else
+            large
+          >
+            highlight_alt
+          </v-icon>
+        </v-btn>
+      </div>
+    </template>
+    <v-card>
+      <v-card-text>
+        <div class="layout row">
+          <text-field
+            ref="iconSearchField"
+            label="Search icons"
+            append-icon="search"
+            clearable
+            :value="searchString"
+            @change="search"
+          />
+          <v-btn
+            icon
+            @click="select()"
+          >
+            <v-icon>
+              cancel
+            </v-icon>
+          </v-btn>
+        </div>
+        <v-layout
+          row
+          wrap
+          style="max-height: 400px; overflow-y: auto;"
+        >
+          <v-scale-transition
+            group
+            hide-on-leave
+          >
+            <v-btn
+              v-for="icon in icons"
+              :key="icon._id"
+              icon
+              large
+              @click="select(icon)"
+            >
+              <svg-icon
+                :shape="icon.shape"
+                x-large
+              />
+            </v-btn>
+          </v-scale-transition>
+        </v-layout>
+      </v-card-text>
+    </v-card>
+  </v-menu>
+</template>
+
+<script>
+import SvgIcon from '/imports/ui/components/global/SvgIcon.vue';
+import SmartInput from '/imports/ui/components/global/SmartInputMixin.js';
+import { findIcons } from '/imports/api/icons/Icons.js';
+
+export default {
+  components: {
+    SvgIcon,
+  },
+  mixins: [SmartInput],
+	props: {
+    label: {
+      type: String,
+      default: 'Icon',
+    },
+	},
+	data(){return {
+		menu: false,
+    searchString: '',
+    icons: [],
+	};},
+  watch: {
+    menu(value){
+      if (value){
+        setTimeout(() => {
+          if (this.$refs.iconSearchField){
+            this.$refs.iconSearchField.$children[0].focus();
+          }
+        }, 100);
+      }
+    },
+  },
+	methods: {
+    search(value, ack){
+      this.searchString = value;
+      this.icons = [];
+      findIcons.call({search: value}, (error, result) => {
+        ack(error);
+        this.icons = result;
+      });
+    },
+    select(icon){
+      this.menu = false;
+      this.change(icon);
+    },
+	},
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/components/global/SmartInputMixin.js

@@ -23,7 +23,7 @@ export default {
     inputValue: this.value,
   };},
   props: {
-    value: [String, Number, Date, Array, Boolean],
+    value: [String, Number, Date, Array, Object, Boolean],
     errorMessages: [String, Array],
     disabled: Boolean,
   },
@@ -93,6 +93,9 @@ export default {
       this.safeValue = null;
       this.$nextTick(() => this.safeValue = this.value);
     },
+    focus(){
+      this.$refs.input.focus();
+    }
   },
   computed: {
     errors(){

app/imports/ui/components/global/SvgIcon.vue

@@ -0,0 +1,97 @@
+<template lang="html">
+  <i
+    ref="icon"
+    aria-hidden
+    role="img"
+    class="v-icon"
+    :class="themeClasses"
+    :style="color && `color: ${color}`"
+  >
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      viewBox="0 0 512 512"
+      :style="`height: ${size}; width: ${size}`"
+    >
+      <path
+        :d="shape"
+      />
+    </svg>
+  </i>
+</template>
+
+<script>
+const SIZE_MAP = {
+  xSmall: '12px',
+  small: '16px',
+  default: '24px',
+  medium: '28px',
+  large: '36px',
+  xLarge: '40px',
+}
+export default {
+  inject: {
+    theme: {
+      default: {
+        isDark: false,
+      },
+    },
+  },
+  props: {
+    shape: {
+      type: String,
+      default: '',
+    },
+    color: {
+      type: String,
+      default: undefined,
+    },
+    xSmall: Boolean,
+    small: Boolean,
+    medium: Boolean,
+    large: Boolean,
+    xLarge: Boolean,
+  },
+  data(){return {
+    inheritedSize: undefined,
+  }},
+  computed: {
+    isDark () {
+      if (this.dark === true) {
+        // explicitly dark
+        return true
+      } else if (this.light === true) {
+        // explicitly light
+        return false
+      } else {
+        // inherit from parent, or default false if there is none
+        return this.theme.isDark
+      }
+    },
+    themeClasses() {
+      return {
+        'theme--dark': this.isDark,
+        'theme--light': !this.isDark,
+      }
+    },
+    size() {
+      if (this.inheritedSize) return this.inheritedSize;
+      if (this.xSmall) return SIZE_MAP['xSmall'];
+      if (this.small)  return SIZE_MAP['small'];
+      if (this.medium) return SIZE_MAP['medium'];
+      if (this.large)  return SIZE_MAP['large'];
+      if (this.xLarge) return SIZE_MAP['xLarge'];
+      return SIZE_MAP['default'];
+    },
+  },
+  mounted(){
+    this.inheritedSize = this.$refs.icon.style.fontSize;
+  }
+}
+</script>
+
+<style lang="css" scoped>
+  svg {
+    color: inherit;
+    fill: currentColor;
+  }
+</style>

app/imports/ui/components/global/TextField.vue

@@ -1,5 +1,6 @@
 <template lang="html">
   <v-text-field
+    ref="input"
     v-bind="$attrs"
     :loading="loading"
     :error-messages="errors"

app/imports/ui/components/global/globalIndex.js

@@ -1,17 +1,21 @@
 import Vue from 'vue';
 // Global components
 import DatePicker from '/imports/ui/components/global/DatePicker.vue';
+import IconPicker from '/imports/ui/components/global/IconPicker.vue';
 import TextField from '/imports/ui/components/global/TextField.vue';
 import TextArea from '/imports/ui/components/global/TextArea.vue';
 import SmartSelect from '/imports/ui/components/global/SmartSelect.vue';
 import SmartCombobox from '/imports/ui/components/global/SmartCombobox.vue';
 import SmartCheckbox from '/imports/ui/components/global/SmartCheckbox.vue';
 import SmartSwitch from '/imports/ui/components/global/SmartSwitch.vue';
+import SvgIcon from '/imports/ui/components/global/SvgIcon.vue';
 
 Vue.component('DatePicker', DatePicker);
+Vue.component('IconPicker', IconPicker);
 Vue.component('TextField', TextField);
 Vue.component('TextArea', TextArea);
 Vue.component('SmartSelect', SmartSelect);
 Vue.component('SmartCombobox', SmartCombobox);
 Vue.component('SmartCheckbox', SmartCheckbox);
 Vue.component('SmartSwitch', SmartSwitch);
+Vue.component('SvgIcon', SvgIcon);

app/imports/ui/components/propertyToolbar.vue

@@ -2,14 +2,15 @@
   <v-toolbar
     :color="color || 'secondary'"
     :dark="isDark"
+    :light="!isDark"
     :flat="flat"
   >
     <property-icon
-      :type="model && model.type"
+      :model="model"
       class="mr-2"
     />
     <v-toolbar-title v-if="model">
-      {{ model.name || getPropertyName(model.type) }}
+      {{ title }}
     </v-toolbar-title>
     <v-spacer />
     <v-slide-y-transition
@@ -141,13 +142,25 @@ export default {
     },
     color(){
       return this.model && this.model.color || this.$vuetify.theme.secondary;
+    },
+    title(){
+      let model = this.model;
+      if (model.quantity !== 1 && model.quantity !== undefined){
+        if (model.plural){
+          return `${model.quantity} ${model.plural}`;
+        } else if (model.name) {
+          return `${model.quantity} ${model.name}`;
+        } else {
+          return `${model.quantity} × ${getPropertyName(model.type)}`
+        }
+      }
+      return model.name || getPropertyName(model.type);
     }
   },
   methods: {
     colorChanged(value){
       this.$emit('color-changed', value);
     },
-    getPropertyName,
   }
 }
 </script>

app/imports/ui/components/tree/TreeNode.vue

@@ -34,8 +34,7 @@
           drag_handle
         </v-icon>
         <!--{{node && node.order}}-->
-        <component
-          :is="treeNodeView"
+        <tree-node-view
           :model="node"
           :selected="selected"
         />
@@ -80,13 +79,13 @@
 	**/
 	import { canBeParent } from '/imports/api/parenting/parenting.js';
 	import { getPropertyIcon } from '/imports/constants/PROPERTIES.js';
-  import treeNodeViewIndex from '/imports/ui/properties/treeNodeViews/treeNodeViewIndex.js';
+  import TreeNodeView from '/imports/ui/properties/treeNodeViews/TreeNodeView.vue';
 
 	export default {
 		name: 'TreeNode',
-		components: {
-      ...treeNodeViewIndex
-		},
+    components: {
+      TreeNodeView,
+    },
 		props: {
 			node: Object,
 			group: String,
@@ -100,10 +99,6 @@
 			expanded: false,
 		}},
 		computed: {
-      treeNodeView(){
-        let type = this.node.type;
-        return treeNodeViewIndex[type] || treeNodeViewIndex.default;
-      },
 			hasChildren(){
 				return this.children && this.children.length || this.lazy && !this.expanded;
 			},

app/imports/ui/components/tree/TreeNodeList.vue

@@ -107,7 +107,6 @@
 				let allowed = isParentAllowed({parentType, childType});
 				return allowed;
 			},
-      log: console.log,
 		},
 	};
 </script>

app/imports/ui/creature/CreatureForm.vue

@@ -42,9 +42,28 @@
       :disabled="disabled"
       @change="(value, ack) => $emit('change', {path: ['avatarPicture'], value, ack})"
     />
-    <!--
-		<form-sections>
-			<form-section name="settings">
+    <form-sections>
+      <form-section name="settings">
+        <v-switch
+          label="Hide redundant stats"
+          :input-value="model.settings.hideUnusedStats"
+          :disabled="disabled"
+          @change="value => $emit('change', {path: ['settings','hideUnusedStats'], value: !!value})"
+        />
+        <text-field
+          label="Hit Dice reset multiplier"
+          hint="What fraction of your hit dice are reset every long rest"
+          placeholder="0.5"
+          type="number"
+          min="0"
+          max="1"
+          step="0.1"
+          :value="model.settings.hitDiceResetMultiplier"
+          :debounce-time="debounceTime"
+          :disabled="disabled"
+          @change="(value, ack) => $emit('change', {path: ['settings','hitDiceResetMultiplier'], value, ack})"
+        />
+      <!--
 				<v-switch
 					label="Use variant encumbrance"
 					:input-value="model.settings.useVariantEncumbrance"
@@ -66,9 +85,9 @@
           :disabled="disabled"
 					@change="value => $emit('change', {path: ['settings','swapStatAndModifier'], value})"
 				/>
-			</form-section>
-		</form-sections>
-    -->
+        -->
+      </form-section>
+    </form-sections>
   </div>
 </template>
 

app/imports/ui/creature/CreatureFormDialog.vue

@@ -1,8 +1,15 @@
 <template lang="html">
-  <dialog-base>
-    <v-toolbar-title slot="toolbar">
-      Creature Form Dialog
-    </v-toolbar-title>
+  <dialog-base :color="model.color">
+    <template slot="toolbar">
+      <v-toolbar-title>
+        Creature Form Dialog
+      </v-toolbar-title>
+      <v-spacer />
+      <color-picker
+        :value="model.color"
+        @input="value => change({path: ['color'], value})"
+      />
+    </template>
     <div>
       <creature-form
         :model="model"
@@ -27,11 +34,13 @@ import {updateCreature} from '/imports/api/creature/Creatures.js';
 import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
 import CreatureForm from '/imports/ui/creature/CreatureForm.vue'
 import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import ColorPicker from '/imports/ui/components/ColorPicker.vue';
 
 export default {
 	components: {
 		DialogBase,
 		CreatureForm,
+    ColorPicker,
 	},
 	props: {
 		_id: String,
@@ -52,8 +61,16 @@ export default {
 	},
 	methods: {
 		change({path, value, ack}){
-			updateCreature.call({_id: this._id, path, value}, (error, result) =>{
-				ack && ack(error && error.reason || error);
+			updateCreature.call({_id: this._id, path, value}, (error) =>{
+        if (error){
+          if(ack){
+            ack(error && error.reason || error)
+          } else {
+            console.error(error)
+          }
+        } else if (ack) {
+          ack();
+        }
 			});
 		},
 	}

app/imports/ui/creature/RestButton.vue

@@ -0,0 +1,50 @@
+<template lang="html">
+  <v-btn
+    :loading="loading"
+    outline
+    style="width: 160px;"
+    @click="rest"
+  >
+    <v-icon left>
+      {{ type === 'shortRest' ? 'snooze' : 'bedtime' }}
+    </v-icon>
+    {{ type === 'shortRest' ? 'Short Rest' : 'Long Rest' }}
+  </v-btn>
+</template>
+
+<script>
+import restCreature from '/imports/api/creature/restCreature.js';
+
+export default {
+  props:{
+    type: {
+      type: String,
+      required: true,
+    },
+    creatureId: {
+      type: String,
+      required: true,
+    },
+  },
+  data(){return {
+    loading: false,
+  }},
+  methods: {
+    rest(){
+      this.loading = true;
+      restCreature.call({
+        creatureId: this.creatureId,
+        restType: this.type,
+      }, error => {
+        this.loading = false;
+        if (error){
+          console.error(error);
+        }
+      });
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/creature/character/CharacterSheetToolbar.vue

@@ -0,0 +1,247 @@
+<template lang="html">
+  <v-toolbar
+    app
+    class="character-sheet-toolbar"
+    :color="toolbarColor"
+    :dark="isDark"
+    :light="!isDark"
+    tabs
+    dense
+  >
+    <v-toolbar-side-icon @click="toggleDrawer" />
+    <v-toolbar-title>
+      <v-fade-transition
+        mode="out-in"
+      >
+        <div :key="$store.state.pageTitle">
+          {{ $store.state.pageTitle }}
+        </div>
+      </v-fade-transition>
+    </v-toolbar-title>
+    <v-spacer />
+    <v-fade-transition
+      mode="out-in"
+    >
+      <div :key="$route.meta.title">
+        <v-toolbar-items v-if="creature">
+          <v-btn
+            v-if="editPermission"
+            flat
+            icon
+            @click="recompute(creature._id)"
+          >
+            <v-icon>refresh</v-icon>
+          </v-btn>
+          <v-menu
+            bottom
+            left
+            transition="slide-y-transition"
+            data-id="creature-menu"
+          >
+            <template #activator="{ on }">
+              <v-btn
+                icon
+                v-on="on"
+              >
+                <v-icon>more_vert</v-icon>
+              </v-btn>
+            </template>
+            <v-list v-if="editPermission">
+              <v-list-tile @click="deleteCharacter">
+                <v-list-tile-title>
+                  <v-icon>delete</v-icon> Delete
+                </v-list-tile-title>
+              </v-list-tile>
+              <v-list-tile @click="showCharacterForm">
+                <v-list-tile-title>
+                  <v-icon>create</v-icon> Edit details
+                </v-list-tile-title>
+              </v-list-tile>
+              <v-list-tile @click="showShareDialog">
+                <v-list-tile-title>
+                  <v-icon>share</v-icon> Sharing
+                </v-list-tile-title>
+              </v-list-tile>
+            </v-list>
+            <v-list v-else>
+              <v-list-tile @click="unshareWithMe">
+                <v-list-tile-title>
+                  <v-icon>delete</v-icon> Unshare with me
+                </v-list-tile-title>
+              </v-list-tile>
+            </v-list>
+          </v-menu>
+        </v-toolbar-items>
+      </div>
+    </v-fade-transition>
+    <v-fade-transition
+      slot="extension"
+      mode="out-in"
+    >
+      <div
+        :key="$route.meta.title"
+        style="width: 100%"
+      >
+        <v-tabs
+          v-if="creature"
+          slot="extension"
+          :value="value"
+          centered
+          grow
+          max="100px"
+          @change="e => $emit('input', e)"
+        >
+          <v-tab>
+            Stats
+          </v-tab>
+          <v-tab>
+            Features
+          </v-tab>
+          <v-tab>
+            Inventory
+          </v-tab>
+          <v-tab>
+            Spells
+          </v-tab>
+          <v-tab>
+            Persona
+          </v-tab>
+          <v-tab>
+            Tree
+          </v-tab>
+        </v-tabs>
+      </div>
+    </v-fade-transition>
+  </v-toolbar>
+</template>
+
+<script>
+import Creatures from '/imports/api/creature/Creatures.js';
+import removeCreature from '/imports/api/creature/removeCreature.js';
+import { mapMutations } from 'vuex';
+import { theme } from '/imports/ui/theme.js';
+import { recomputeCreature } from '/imports/api/creature/computation/recomputeCreature.js';
+import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { updateUserSharePermissions } from '/imports/api/sharing/sharing.js';
+import isDarkColor from '/imports/ui/utility/isDarkColor.js';
+
+export default {
+  props: {
+    value: {
+      type: Number,
+      required: true,
+    },
+  },
+  data(){return {
+    theme,
+  }},
+  computed: {
+    creatureId(){
+      return this.$route.params.id;
+    },
+    toolbarColor(){
+      if (this.creature && this.creature.color){
+        return this.creature.color;
+      } else {
+        return this.$vuetify.theme.secondary;
+      }
+    },
+    isDark(){
+      return isDarkColor(this.toolbarColor);
+    },
+  },
+  methods: {
+    ...mapMutations([
+      'toggleDrawer',
+    ]),
+		recompute(charId){
+			recomputeCreature.call({charId});
+		},
+		showCharacterForm(){
+			this.$store.commit('pushDialogStack', {
+				component: 'creature-form-dialog',
+				elementId: 'creature-menu',
+				data: {
+					_id: this.creatureId,
+				},
+			});
+		},
+		showShareDialog(){
+			this.$store.commit('pushDialogStack', {
+				component: 'share-dialog',
+				elementId: 'creature-menu',
+				data: {
+					docRef: {
+						id: this.creatureId,
+						collection: 'creatures',
+					}
+				},
+			});
+		},
+		deleteCharacter(){
+			let that = this;
+			this.$store.commit('pushDialogStack', {
+				component: 'delete-confirmation-dialog',
+				elementId: 'creature-menu',
+				data: {
+					name: this.creature.name,
+					typeName: 'Character'
+				},
+				callback(confirmation){
+					if(!confirmation) return;
+					removeCreature.call({charId: that.creatureId}, (error) => {
+						if (error) {
+							console.error(error);
+						} else {
+							that.$router.push('/characterList');
+						}
+					});
+				}
+			});
+		},
+    unshareWithMe(){
+      updateUserSharePermissions.call({
+        docRef: {
+          collection: 'creatures',
+          id: this.creatureId,
+        },
+        userId: Meteor.userId(),
+        role: 'none',
+      }, (error) => {
+        if (error) {
+          console.error(error);
+        } else {
+          this.$router.push('/characterList');
+        }
+      });
+    },
+  },
+  meteor: {
+    $subscribe: {
+      'singleCharacter'(){
+        return [this.creatureId];
+      },
+    },
+    creature(){
+      return Creatures.findOne(this.creatureId);
+    },
+    editPermission(){
+      try {
+        assertEditPermission(this.creature, Meteor.userId());
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+  },
+}
+</script>
+
+<style lang="css">
+.character-sheet-toolbar .v-tabs__container--grow .v-tabs__div {
+  max-width: 120px !important;
+}
+.character-sheet-toolbar .v-tabs__bar {
+  background: none !important;
+}
+</style>

app/imports/ui/creature/character/CharacterSheetToolbarItems.vue

@@ -53,7 +53,6 @@
 <script>
 import Creatures from '/imports/api/creature/Creatures.js';
 import removeCreature from '/imports/api/creature/removeCreature.js';
-import isDarkColor from '/imports/ui/utility/isDarkColor.js';
 import { mapMutations } from 'vuex';
 import { theme } from '/imports/ui/theme.js';
 import { recomputeCreature } from '/imports/api/creature/computation/recomputeCreature.js';
@@ -134,7 +133,6 @@ export default {
         }
       });
     },
-		isDarkColor,
   },
   meteor: {
     $subscribe: {

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

@@ -2,7 +2,7 @@
   <div class="inventory">
     <column-layout>
       <div>
-        <toolbar-card color="">
+        <toolbar-card :color="$vuetify.theme.secondary">
           <v-spacer slot="toolbar" />
           <v-switch
             v-if="context.editPermission !== false"

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

@@ -20,6 +20,70 @@
           </v-card-text>
         </v-card>
       </div>
+      <div>
+        <v-card class="class-details">
+          <v-card-title
+            v-if="creature.variables.level"
+            class="title"
+          >
+            Level {{ creature.variables.level.value }}
+          </v-card-title>
+          <v-list>
+            <v-list-tile>
+              <v-list-tile-content>
+                <v-list-tile-title
+                  v-if="
+                    creature.variables.milestoneLevels &&
+                      creature.variables.milestoneLevels.value
+                  "
+                >
+                  {{ creature.variables.milestoneLevels.value }} Milestone levels
+                </v-list-tile-title>
+                <v-list-tile-title v-else>
+                  {{
+                    creature.variables.xp &&
+                      creature.variables.xp.value ||
+                      0
+                  }} XP
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-action>
+                <v-btn
+                  flat
+                  icon
+                  data-id="experience-info-button"
+                  @click="showExperienceList"
+                >
+                  <v-icon>info</v-icon>
+                </v-btn>
+              </v-list-tile-action>
+              <v-list-tile-action>
+                <v-btn
+                  flat
+                  icon
+                  data-id="experience-add-button"
+                  @click="addExperience"
+                >
+                  <v-icon>add</v-icon>
+                </v-btn>
+              </v-list-tile-action>
+            </v-list-tile>
+            <v-list-tile
+              v-for="classLevel in highestClassLevels"
+              :key="classLevel._id"
+            >
+              <v-list-tile-content>
+                <v-list-tile-title>
+                  {{ classLevel.name }}
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-avatar>
+                {{ classLevel.level }}
+              </v-list-tile-avatar>
+            </v-list-tile>
+          </v-list>
+        </v-card>
+      </div>
       <div
         v-for="note in notes"
         :key="note._id"
@@ -37,6 +101,7 @@ import Creatures from '/imports/api/creature/Creatures.js';
 import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 import ColumnLayout from '/imports/ui/components/ColumnLayout.vue';
 import NoteCard from '/imports/ui/properties/components/persona/NoteCard.vue';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js'
 
 export default {
 	components: {
@@ -44,7 +109,10 @@ export default {
 		NoteCard,
 	},
 	props: {
-		creatureId: String,
+		creatureId: {
+      type: String,
+      required: true,
+    },
 	},
 	meteor: {
 		notes(){
@@ -58,8 +126,34 @@ export default {
 		},
 		creature(){
 			return Creatures.findOne(this.creatureId);
-		}
+		},
+    classLevels(){
+      return getActiveProperties({
+        ancestorId: this.creatureId,
+        filter: {type: 'classLevel'},
+      });
+    },
 	},
+  computed: {
+    highestClassLevels(){
+      let highestLevels = {};
+      let highestLevelsList = [];
+      this.classLevels.forEach(classLevel => {
+        let name = classLevel.vairableName;
+        if (
+          !highestLevels[name] ||
+          highestLevels[name].level < classLevel.level
+        ){
+          highestLevels[name] = classLevel;
+        }
+      });
+      for (let name in highestLevels){
+        highestLevelsList.push(highestLevels[name]);
+      }
+      highestLevelsList.sort((a, b) => a.level - b.level);
+      return highestLevelsList;
+    },
+  },
 	methods: {
 		showCharacterForm(){
 			this.$store.commit('pushDialogStack', {
@@ -70,6 +164,28 @@ export default {
 				},
 			});
 		},
+    addExperience(){
+      this.$store.commit('pushDialogStack', {
+				component: 'experience-insert-dialog',
+				elementId: 'experience-add-button',
+				data: {
+					creatureIds: [this.creatureId],
+          startAsMilestone: this.creature.variables.milestoneLevels &&
+            !!this.creature.variables.milestoneLevels.value,
+				},
+			});
+    },
+    showExperienceList(){
+      this.$store.commit('pushDialogStack', {
+				component: 'experience-list-dialog',
+				elementId: 'experience-info-button',
+				data: {
+					creatureId: this.creatureId,
+          startAsMilestone: this.creature.variables.milestoneLevels &&
+            !!this.creature.variables.milestoneLevels.value,
+				},
+			});
+    },
 	},
 };
 </script>

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

@@ -1,10 +1,26 @@
 <template lang="html">
-  <div class="stats-tab ma-2">
+  <div
+    class="stats-tab ma-2"
+  >
     <div class="px-2 pt-2">
       <health-bar-card-container :creature-id="creatureId" />
     </div>
 
     <column-layout>
+      <div class="character-buttons">
+        <v-card>
+          <v-card-text class="layout column align-center">
+            <rest-button
+              :creature-id="creatureId"
+              type="shortRest"
+            />
+            <rest-button
+              :creature-id="creatureId"
+              type="longRest"
+            />
+          </v-card-text>
+        </v-card>
+      </div>
       <div class="ability-scores">
         <v-card>
           <v-list>
@@ -231,44 +247,27 @@
       </div>
 
       <div
-        v-if="actions.length"
+        v-for="action in actions"
+        :key="action._id"
         class="actions"
       >
-        <v-card>
-          <v-list
-            two-line
-            subheader
-          >
-            <v-subheader>Actions</v-subheader>
-            <action-list-tile
-              v-for="action in actions"
-              :key="action._id"
-              :model="action"
-              :data-id="action._id"
-              @click="clickProperty({_id: action._id})"
-            />
-          </v-list>
-        </v-card>
+        <action-card
+          :model="action"
+          :data-id="action._id"
+          @click="clickProperty({_id: action._id})"
+        />
       </div>
       <div
-        v-if="attacks.length"
-        class="actions"
+        v-for="attack in attacks"
+        :key="attack._id"
+        class="attacks"
       >
-        <v-card>
-          <v-list
-            two-line
-            subheader
-          >
-            <v-subheader>Attacks</v-subheader>
-            <attack-list-tile
-              v-for="attack in attacks"
-              :key="attack._id"
-              :model="attack"
-              :data-id="attack._id"
-              @click="clickProperty({_id: attack._id})"
-            />
-          </v-list>
-        </v-card>
+        <action-card
+          attack
+          :model="attack"
+          :data-id="attack._id"
+          @click="clickProperty({_id: attack._id})"
+        />
       </div>
     </column-layout>
   </div>
@@ -276,7 +275,7 @@
 
 <script>
   import Creatures from '/imports/api/creature/Creatures.js';
-	import CreatureProperties, { damageProperty } from '/imports/api/creature/CreatureProperties.js';
+	import { damageProperty } from '/imports/api/creature/CreatureProperties.js';
 	import AttributeCard from '/imports/ui/properties/components/attributes/AttributeCard.vue';
 	import AbilityListTile from '/imports/ui/properties/components/attributes/AbilityListTile.vue';
 	import ColumnLayout from '/imports/ui/components/ColumnLayout.vue';
@@ -286,27 +285,31 @@
 	import SkillListTile from '/imports/ui/properties/components/skills/SkillListTile.vue';
 	import ResourceCard from '/imports/ui/properties/components/attributes/ResourceCard.vue';
 	import SpellSlotListTile from '/imports/ui/properties/components/attributes/SpellSlotListTile.vue';
-  import ActionListTile from '/imports/ui/properties/components/actions/ActionListTile.vue';
-  import AttackListTile from '/imports/ui/properties/components/actions/AttackListTile.vue';
+  import ActionCard from '/imports/ui/properties/components/actions/ActionCard.vue';
+  import RestButton from '/imports/ui/creature/RestButton.vue';
   import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
-  const getProperties = function(creatureId, filter){
+  const getProperties = function(creature, filter,){
+    if (!creature) return;
+    if (creature.settings.hideUnusedStats){
+      filter.hide = {$ne: true};
+    }
     return getActiveProperties({
-      ancestorId: creatureId,
+      ancestorId: creature._id,
       filter,
       options: {sort: {order: 1}},
     });
   };
 
-	const getAttributeOfType = function(creatureId, type){
-    return getProperties(creatureId, {
+	const getAttributeOfType = function(creature, type){
+    return getProperties(creature, {
       type: 'attribute',
       attributeType: type,
     });
 	};
 
-  const getSkillOfType = function(creatureId, type){
-    return getProperties(creatureId, {
+  const getSkillOfType = function(creature, type){
+    return getProperties(creature, {
       type: 'skill',
       skillType: type,
     });
@@ -314,6 +317,7 @@
 
 	export default {
 		components: {
+      RestButton,
 			AbilityListTile,
 			AttributeCard,
 			ColumnLayout,
@@ -323,8 +327,7 @@
 			SkillListTile,
 			ResourceCard,
 			SpellSlotListTile,
-      ActionListTile,
-      AttackListTile,
+      ActionCard,
 		},
 		props: {
 			creatureId: {
@@ -337,49 +340,56 @@
         return Creatures.findOne(this.creatureId);
       },
 			abilities(){
-				return getAttributeOfType(this.creatureId, 'ability');
+				return getAttributeOfType(this.creature, 'ability');
 			},
 			stats(){
-				return getAttributeOfType(this.creatureId, 'stat');
+				return getAttributeOfType(this.creature, 'stat');
 			},
 			modifiers(){
-				return getAttributeOfType(this.creatureId, 'modifier');
+				return getAttributeOfType(this.creature, 'modifier');
 			},
 			resources(){
-				return getAttributeOfType(this.creatureId, 'resource');
+				return getAttributeOfType(this.creature, 'resource');
 			},
 			spellSlots(){
-				return getAttributeOfType(this.creatureId, 'spellSlot');
+				return getAttributeOfType(this.creature, 'spellSlot');
 			},
 			hitDice(){
-        return getAttributeOfType(this.creatureId, 'hitDice');
+        return getAttributeOfType(this.creature, 'hitDice');
 			},
 			checks(){
-        return getSkillOfType(this.creatureId, 'check');
+        return getSkillOfType(this.creature, 'check');
 			},
 			savingThrows(){
-        return getSkillOfType(this.creatureId, 'save');
+        return getSkillOfType(this.creature, 'save');
 			},
 			skills(){
-        return getSkillOfType(this.creatureId, 'skill');
+        return getSkillOfType(this.creature, 'skill');
 			},
       tools(){
-        return getSkillOfType(this.creatureId, 'tool');
+        return getSkillOfType(this.creature, 'tool');
 			},
       weapons(){
-        return getSkillOfType(this.creatureId, 'weapon');
+        return getSkillOfType(this.creature, 'weapon');
 			},
       armors(){
-        return getSkillOfType(this.creatureId, 'armor');
+        return getSkillOfType(this.creature, 'armor');
 			},
       languages(){
-        return getSkillOfType(this.creatureId, 'language');
+        return getSkillOfType(this.creature, 'language');
 			},
       actions(){
-        return getProperties(this.creatureId, {type: 'action'});
+        return getProperties(this.creature, {type: 'action'});
 			},
       attacks(){
-        return getProperties(this.creatureId, {type: 'attack'});
+        let props = getProperties(this.creature, {type: 'attack'}).map(attack => {
+          attack.children = getActiveProperties({
+            ancestorId: attack._id,
+            options: {sort: {order: 1}},
+          });
+          return attack;
+        });
+        return props;
 			},
 		},
 		methods: {

app/imports/ui/creature/creatureProperties/CreaturePropertyDialog.vue

@@ -35,7 +35,7 @@
         </p>
       </v-fade-transition>
       <template v-if="!editing && !embedded">
-        <v-divider />
+        <v-divider class="my-2" />
         <creature-properties-tree
           v-if="!editing"
           :root="{collection: 'creatureProperties', id: model._id}"
@@ -175,7 +175,11 @@ export default {
 		},
 		remove(){
 			softRemoveProperty.call({_id: this._id});
-			this.$store.dispatch('popDialogStack');
+      if (this.embedded){
+        this.$emit('removed');
+      } else {
+        this.$store.dispatch('popDialogStack');
+      }
 		},
 		selectSubProperty(_id){
 			this.$store.commit('pushDialogStack', {

app/imports/ui/creature/creatureProperties/CreaturePropertyInsertForm.vue

@@ -1,8 +1,18 @@
 <template lang="html">
-  <dialog-base :override-back-button="() => $emit('back')">
-    <v-toolbar-title slot="toolbar">
-      Add {{ propertyName }}
-    </v-toolbar-title>
+  <dialog-base
+    :override-back-button="() => $emit('back')"
+    :color="model.color"
+  >
+    <template slot="toolbar">
+      <v-toolbar-title>
+        Add {{ propertyName }}
+      </v-toolbar-title>
+      <v-spacer />
+      <color-picker
+        :value="model.color"
+        @input="value => change({path: ['color'], value})"
+      />
+    </template>
     <component
       :is="type"
       v-if="type"
@@ -32,11 +42,14 @@
 import propertySchemasIndex from '/imports/api/properties/propertySchemasIndex.js';
 import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
 import propertyFormIndex from '/imports/ui/properties/forms/shared/propertyFormIndex.js';
+import ColorPicker from '/imports/ui/components/ColorPicker.vue';
 import schemaFormMixin from '/imports/ui/properties/forms/shared/schemaFormMixin.js';
+
 export default {
 	components: {
 		...propertyFormIndex,
 		DialogBase,
+    ColorPicker,
 	},
 	mixins: [schemaFormMixin],
 	props: {

app/imports/ui/creature/experiences/ExperienceForm.vue

@@ -0,0 +1,68 @@
+<template lang="html">
+  <div class="experience-form">
+    <div class="layout column align-center">
+      <smart-switch
+        label="Milestone"
+        class="mx-3"
+        :value="milestone"
+        @change="makeMilestone"
+      />
+      <text-field
+        v-if="milestone"
+        label="Levels"
+        type="number"
+        class="base-value-field text-xs-center large-format no-flex"
+        :value="model.levels"
+        :error-messages="errors.levels"
+        @change="change('levels', ...arguments)"
+      />
+      <text-field
+        v-else
+        type="number"
+        class="base-value-field text-xs-center large-format no-flex"
+        suffix="XP"
+        autofocus
+        :value="model.xp"
+        :error-messages="errors.xp"
+        @change="change('xp', ...arguments)"
+      />
+    </div>
+    <text-field
+      label="Name"
+      :autofocus="milestone"
+      :value="model.name"
+      :error-messages="errors.name"
+      @change="change('name', ...arguments)"
+    />
+  </div>
+</template>
+
+<script>
+import propertyFormMixin from '/imports/ui/properties/forms/shared/propertyFormMixin.js';
+
+export default {
+  mixins: [propertyFormMixin],
+  props: {
+    startAsMilestone: {
+      type: Boolean,
+    },
+  },
+  data(){return {
+    milestone: this.startAsMilestone,
+  }},
+  methods: {
+    makeMilestone(milestone, ack){
+      this.milestone = milestone;
+      if (milestone){
+        this.change('xp', undefined);
+        this.change('levels', 1, ack);
+      } else {
+        this.change('levels', undefined, ack);
+      }
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/creature/experiences/ExperienceInsertDialog.vue

@@ -0,0 +1,83 @@
+<template lang="html">
+  <dialog-base>
+    <experience-form
+      :start-as-milestone="startAsMilestone"
+      :model="model"
+      :errors="errors"
+      @change="change"
+      @push="push"
+      @pull="pull"
+    />
+    <div
+      slot="actions"
+      class="layout row justify-end"
+    >
+      <v-btn
+        flat
+        :disabled="!valid"
+        @click="insertExperience"
+      >
+        Insert
+      </v-btn>
+    </div>
+  </dialog-base>
+</template>
+
+<script>
+import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
+import ExperienceForm from '/imports/ui/creature/experiences/ExperienceForm.vue';
+import { ExperienceSchema, insertExperience } from '/imports/api/creature/experience/Experiences.js';
+import schemaFormMixin from '/imports/ui/properties/forms/shared/schemaFormMixin.js';
+
+export default {
+  components: {
+		DialogBase,
+    ExperienceForm,
+	},
+  mixins: [schemaFormMixin],
+  provide: {
+    context: {
+      debounceTime: 0,
+    },
+  },
+  props: {
+    creatureIds: {
+      type: Array,
+      required: true,
+    },
+    startAsMilestone: {
+      type: Boolean,
+    },
+  },
+  data(){
+    let schema = ExperienceSchema.omit('creatureId');
+    let startingModel = {};
+    if (this.startAsMilestone){
+      startingModel.levels = 1;
+    }
+    return {
+      model: schema.clean(startingModel),
+      schema: schema,
+      validationContext: schema.newContext(),
+      debounceTime: 0,
+    };
+  },
+  methods:{
+    insertExperience(){
+      let experience = this.schema.clean(this.model);
+      let id = insertExperience.call({
+        experience,
+        creatureIds: this.creatureIds,
+      }, (error) =>  {
+        if (error){
+          console.error(error);
+        }
+      });
+      this.$store.dispatch('popDialogStack', id);
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/creature/experiences/ExperienceListDialog.vue

@@ -0,0 +1,174 @@
+<template lang="html">
+  <dialog-base>
+    <template slot="toolbar">
+      <v-toolbar-title>
+        Experiences
+      </v-toolbar-title>
+      <v-spacer />
+      <v-btn
+        icon
+        flat
+        data-id="experience-add-button"
+        @click="addExperience"
+      >
+        <v-icon>add</v-icon>
+      </v-btn>
+      <v-btn
+        icon
+        flat
+        @click="recompute"
+      >
+        <v-icon>refresh</v-icon>
+      </v-btn>
+    </template>
+    <div
+      v-if="!$subReady.experiences"
+      class="layout column align-center justify-center fill-height"
+    >
+      <v-progress-circular
+        indeterminate
+        size="240"
+      />
+    </div>
+    <div
+      v-else-if="experiences.length === 0"
+      class="layout column align-center justify-center fill-height"
+    >
+      <v-icon style="font-size: 240px; width: 240px; height: 240px;">
+        $vuetify.icons.baby_face
+      </v-icon>
+      <p class="headline">
+        No experiences
+      </p>
+    </div>
+    <v-list v-else>
+      <v-slide-x-transition
+        group
+        mode="out"
+      >
+        <v-list-tile
+          v-for="experience in experiences"
+          :key="experience._id"
+          :data-id="experience._id"
+        >
+          <v-list-tile-action class="mr-3">
+            <v-list-tile-action-text>
+              {{ formatDate(experience.date) }}
+            </v-list-tile-action-text>
+          </v-list-tile-action>
+          <v-list-tile-content>
+            <template v-if="experience.name">
+              <v-list-tile-title>
+                {{ experience.name }}
+              </v-list-tile-title>
+              <v-list-tile-sub-title>
+                {{ xpText(experience) }}
+              </v-list-tile-sub-title>
+            </template>
+            <template v-else>
+              <v-list-tile-title>
+                {{ xpText(experience) }}
+              </v-list-tile-title>
+            </template>
+          </v-list-tile-content>
+          <v-list-tile-action>
+            <v-btn
+              icon
+              flat
+              :loading="experiencesRemovalLoading.has(experience._id)"
+              @click="removeExperience(experience._id)"
+            >
+              <v-icon>delete</v-icon>
+            </v-btn>
+          </v-list-tile-action>
+        </v-list-tile>
+      </v-slide-x-transition>
+    </v-list>
+  </dialog-base>
+</template>
+
+<script>
+import { format } from 'date-fns';
+import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
+import Experiences, { removeExperience, recomputeExperiences } from '/imports/api/creature/experience/Experiences.js';
+
+export default {
+  components: {
+    DialogBase,
+  },
+  props: {
+    creatureId: {
+      type: String,
+      required: true,
+    },
+    startAsMilestone: {
+      type: Boolean,
+    },
+  },
+  data(){ return {
+    experiencesRemovalLoading: new Set(),
+    recomputeLoading: false,
+  }},
+  meteor: {
+    $subscribe: {
+      'experiences'(){
+        return [this.creatureId];
+      },
+    },
+    experiences(){
+      return Experiences.find({
+        creatureId: this.creatureId
+      }, {
+        sort: {date: 1}
+      });
+    }
+  },
+  methods: {
+    xpText(experience){
+      let xpText = [];
+      if (experience.levels === 1){
+        xpText.push('1 Milestone level');
+      } else if (experience.levels){
+        xpText.push(`${experience.levels} Milestone levels`);
+      }
+      if (experience.xp || !experience.levels){
+        xpText.push(`${experience.xp || 0} XP`);
+      }
+      return xpText.join(', ');
+    },
+    formatDate(date){
+      return format(date, 'YYYY-MM-DD');
+    },
+    removeExperience(experienceId){
+      this.experiencesRemovalLoading.add(experienceId);
+      removeExperience.call({experienceId}, (error) => {
+        this.experiencesRemovalLoading.delete(experienceId);
+        if (error) console.error(error);
+      });
+    },
+    recompute(){
+      this.recomputeLoading = true;
+      recomputeExperiences.call({creatureId: this.creatureId}, error => {
+        this.recomputeLoading = false;
+        if (error) console.error(error);
+      });
+    },
+    addExperience(){
+      this.$store.commit('pushDialogStack', {
+        component: 'experience-insert-dialog',
+        elementId: 'experience-add-button',
+        data: {
+          creatureIds: [this.creatureId],
+          startAsMilestone: this.startAsMilestone,
+        },
+        callback(id){
+          return id;
+        }
+      });
+    },
+  },
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/dialogStack/DialogBase.vue

@@ -10,6 +10,7 @@
       <v-toolbar
         :color="computedColor"
         :dark="isDark"
+        :light="!isDark"
         class="base-dialog-toolbar"
         :flat="!offsetTop"
       >

app/imports/ui/dialogStack/DialogComponentIndex.js

@@ -3,6 +3,8 @@ import CreaturePropertyCreationDialog from '/imports/ui/creature/creaturePropert
 import CreaturePropertyDialog from '/imports/ui/creature/creatureProperties/CreaturePropertyDialog.vue'
 import CreaturePropertyFromLibraryDialog from '/imports/ui/creature/creatureProperties/CreaturePropertyFromLibraryDialog.vue'
 import DeleteConfirmationDialog from '/imports/ui/dialogStack/DeleteConfirmationDialog.vue';
+import ExperienceInsertDialog from  '/imports/ui/creature/experiences/ExperienceInsertDialog.vue';
+import ExperienceListDialog from  '/imports/ui/creature/experiences/ExperienceListDialog.vue';
 import InviteDialog from '/imports/ui/user/InviteDialog.vue';
 import LibraryCreationDialog from '/imports/ui/library/LibraryCreationDialog.vue';
 import LibraryEditDialog from '/imports/ui/library/LibraryEditDialog.vue';
@@ -13,13 +15,14 @@ import ShareDialog from '/imports/ui/sharing/ShareDialog.vue';
 import TierTooLowDialog from '/imports/ui/user/TierTooLowDialog.vue';
 import UsernameDialog from '/imports/ui/user/UsernameDialog.vue';
 
-
 export default {
   CreatureFormDialog,
   CreaturePropertyCreationDialog,
   CreaturePropertyDialog,
   CreaturePropertyFromLibraryDialog,
   DeleteConfirmationDialog,
+  ExperienceInsertDialog,
+  ExperienceListDialog,
   InviteDialog,
   LibraryCreationDialog,
   LibraryEditDialog,

app/imports/ui/icons/IconAdmin.vue

@@ -8,47 +8,17 @@
             align-center
           >
             <upload-btn
-              :file-changed-callback="fileChanged"
+              title="Metadata JSON"
+              @file-update="metadataFileChanged"
             />
-            <v-text-field
-              ref="iconSearchField"
-              label="Search"
-              append-icon="search"
-              @click:append="updateSearchString"
-              @keydown.enter="updateSearchString"
+            <upload-btn
+              title="Sprite JSON"
+              @file-update="fileChanged"
+            />
+            <icon-picker
+              :value="testIcon"
+              @change="testIconChange"
             />
-            <v-container
-              grid-list-md
-              fill-height
-            >
-              <v-layout
-                row
-                wrap
-              >
-                <v-flex
-                  v-for="icon in icons"
-                  :key="icon._id._str || icon._id"
-                  xs3
-                  md2
-                  xl1
-                >
-                  <v-card>
-                    <v-card-title class="title">
-                      {{ icon.name }}
-                    </v-card-title>
-                    <v-card-text>
-                      <svg
-                        xmlns="http://www.w3.org/2000/svg"
-                        viewBox="0 0 512 512"
-                      ><path
-                        fill="#000"
-                        :d="icon.shape"
-                      /></svg>
-                    </v-card-text>
-                  </v-card>
-                </v-flex>
-              </v-layout>
-            </v-container>
           </v-layout>
         </v-card-text>
       </v-card>
@@ -57,29 +27,31 @@
 </template>
 
 <script>
-  import importIcons from '/imports/ui/icons/importIcons.js';
-  import Icons from '/imports/api/icons/Icons.js';
+  import {importIcons, importIconMetadata} from '/imports/ui/icons/importIcons.js';
+  import IconPicker from '/imports/ui/components/global/IconPicker.vue';
+  import UploadButton from 'vuetify-upload-button';
 
   export default {
+    components: {
+      IconPicker,
+      UploadBtn: UploadButton,
+    },
     data(){ return {
       searchString: '',
+      testIcon: undefined,
     }},
     methods: {
       fileChanged (file) {
         importIcons(file);
       },
-      updateSearchString(){
-        this.searchString = this.$refs.iconSearchField.internalValue;
+      metadataFileChanged(file){
+        importIconMetadata(file);
       },
-    },
-    meteor: {
-      $subscribe: {
-        searchIcons() {
-          return [this.searchString];
-        },
-      },
-      icons(){
-        return Icons.find({}, { sort: [['score', 'desc']] });
+      testIconChange(value, ack){
+        setTimeout(() => {
+          this.testIcon = value;
+          ack();
+        }, 1000);
       },
     },
   };

app/imports/ui/icons/SvgIconByName.vue

@@ -0,0 +1,30 @@
+<template lang="html">
+  <svg-icon
+    :shape="shape"
+  />
+</template>
+
+<script>
+import SvgIcon from '/imports/ui/components/global/SvgIcon.vue'
+import SVG_ICONS from '/imports/constants/SVG_ICONS.js';
+
+export default {
+  components: {
+    SvgIcon,
+  },
+  props: {
+    name: {
+      type: String,
+      required: true,
+    }
+  },
+  computed: {
+    shape(){
+      return SVG_ICONS[this.name].shape;
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/icons/importIcons.js

@@ -1,31 +1,50 @@
 import { writeIcons } from '/imports/api/icons/Icons.js';
 
 /*
- * Import a SVG sprite file. All the icons must contain one id and one path with a
- * single 'd' attribute.
+ * Import a SVG sprite file.
  *
  * A svg sprite file can be created by downloading the entire archive of
  * https://game-icons.net/ then using the search function with *.svg to copy
- * all the individual files into a single directory, and then using the npm
- * sprite-generator to run `svg-sprite-generate -d icons -o sprite.svg` to save
- * the sprite file.
+ * all the individual files into a single directory, and then using
+ * `npm i -g svg-sprite-generator` `npm i -g xml-js`
+ * run `svg-sprite-generate -d icons -o sprite.xml`
+ * run `xml-js sprite.xml --out sprite.json --compact true `
+ * to save the sprite file as json.
 */
+let metadata;
 
-export default function importIcons(file){
-  let id, d, icons = [];
+export function importIcons(file){
   let reader = new FileReader();
+  if (! metadata) throw 'No metadata to build with';
 
   reader.onload = function(){
-    reader.result.match(/i?d="([^"])+"/gi).forEach(s => {
-      if (s[0] === 'i'){
-        id = s.slice(4, -1);
-      } else if (s[0] === 'd'){
-        d = s.slice(3, -1);
-        icons.push ({_id: Random.id(), name: id, shape: d});
-      }
+    let data = JSON.parse(reader.result);
+    let icons = [];
+    data.svg.symbol.forEach(iconData => {
+      let name = iconData._attributes.id;
+      let shape = iconData.path[1]._attributes.d;
+      let icon = metadata[name] || {};
+      icon._id = Random.id();
+      icon.name = name;
+      icon.shape = shape;
+      icons.push(icon);
     });
     writeIcons.call(icons);
   };
 
   reader.readAsText(file);
-};
+}
+
+// Get metadata here:
+// https://gist.github.com/ThaumRystra/ffb264dea8c32e15de95f775596194a4
+// It is probably out of date though
+export function importIconMetadata(file){
+  let reader = new FileReader();
+
+  reader.onload = function(){
+    metadata = JSON.parse(reader.result);
+    console.log(metadata);
+  };
+
+  reader.readAsText(file);
+}

app/imports/ui/layouts/AppLayout.vue

@@ -4,14 +4,17 @@
     :light="!darkMode"
   >
     <v-navigation-drawer
-      v-if="$route.path !== '/countdown'"
       v-model="drawer"
       app
     >
       <Sidebar />
     </v-navigation-drawer>
+    <router-view
+      v-model="tabs"
+      name="toolbar"
+    />
     <v-toolbar
-      v-if="$route.path !== '/countdown'"
+      v-if="!$route.matched[0].components.toolbar"
       app
       color="secondary"
       dark

app/imports/ui/layouts/Sidebar.vue

@@ -1,7 +1,6 @@
 <template>
   <div class="sidebar">
     <v-alert
-      v-if="$route.path !== '/countdown'"
       icon="priority_high"
       type="error"
       dismissible
@@ -136,8 +135,9 @@
           {title: 'Home', icon: 'home', to: '/'},
           {title: 'Characters', icon: 'portrait', to: '/characterList', requireLogin: true},
           {title: 'Library', icon: 'book', to: '/library', requireLogin: true},
-          {title: 'Friends', icon: 'people', to: '/friends', requireLogin: true},
-          {title: 'Send Feedback', icon: 'bug_report', to: '/feedback'},
+          //{title: 'Friends', icon: 'people', to: '/friends', requireLogin: true},
+          {title: 'Feedback', icon: 'bug_report', to: '/feedback'},
+          {title: 'About', icon: 'subject', to: '/about'},
           {title: 'Patreon', icon: '', href: 'https://www.patreon.com/dicecloud'},
           {title: 'Github', icon: '', href: 'https://github.com/ThaumRystra/DiceCloud/tree/version-2'},
         ];

app/imports/ui/layouts/SingleCardLayout.vue

@@ -0,0 +1,15 @@
+<template
+  lang="html"
+  functional
+>
+  <div
+    class="pa-4 layout column align-center"
+    style="height: calc(100vh - 96px); display: flex;"
+  >
+    <v-card
+      style="height: 100%; width: 100%; max-width: 1800px;"
+    >
+      <slot />
+    </v-card>
+  </div>
+</template>

app/imports/ui/library/LibraryAndNode.vue

@@ -14,7 +14,8 @@
       <v-toolbar
         flat
         :color="selectedNode && selectedNode.color || 'secondary'"
-        :dark="isDarkColor(selectedNode && selectedNode.color || $vuetify.theme.secondary)"
+        :dark="isToolbarDark"
+        :light="!isToolbarDark"
       >
         <v-spacer />
         <v-switch
@@ -35,6 +36,7 @@
     <div
       slot="detail"
       data-id="selected-node-card"
+      style="overflow: hidden;"
     >
       <library-node-dialog
         :_id="selected"
@@ -67,6 +69,14 @@ export default {
     organize: false,
     selected: undefined,
   };},
+  computed: {
+    isToolbarDark(){
+      return isDarkColor(
+        this.selectedNode && this.selectedNode.color ||
+        this.$vuetify.theme.secondary
+      );
+    }
+  },
   watch:{
     selectedNode(val){
       this.$emit('selected', val)
@@ -92,7 +102,6 @@ export default {
             selection: this.selection,
           },
           callback: result => {
-            console.log(result)
             if (result){
               this.selected = id;
             }
@@ -101,7 +110,6 @@ export default {
       }
     },
     getPropertyName,
-    isDarkColor,
   },
   meteor: {
     $subscribe: {

app/imports/ui/library/LibraryNodeInsertForm.vue

@@ -1,8 +1,18 @@
 <template lang="html">
-  <dialog-base :override-back-button="() => $emit('back')">
-    <v-toolbar-title slot="toolbar">
-      Add {{ propertyName }}
-    </v-toolbar-title>
+  <dialog-base
+    :override-back-button="() => $emit('back')"
+    :color="model.color"
+  >
+    <template slot="toolbar">
+      <v-toolbar-title>
+        Add {{ propertyName }}
+      </v-toolbar-title>
+      <v-spacer />
+      <color-picker
+        :value="model.color"
+        @input="value => change({path: ['color'], value})"
+      />
+    </template>
     <component
       :is="type"
       v-if="type"
@@ -32,12 +42,14 @@
 import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
 import propertyFormIndex from '/imports/ui/properties/forms/shared/propertyFormIndex.js';
 import schemaFormMixin from '/imports/ui/properties/forms/shared/schemaFormMixin.js';
+import ColorPicker from '/imports/ui/components/ColorPicker.vue';
 import propertySchemasIndex from '/imports/api/properties/propertySchemasIndex.js';
 
 export default {
 	components: {
 		...propertyFormIndex,
 		DialogBase,
+    ColorPicker,
 	},
 	mixins: [schemaFormMixin],
 	props: {

app/imports/ui/library/SingleLibrary.vue

@@ -41,7 +41,7 @@
         flat
       >
         <property-icon
-          :type="selectedNode && selectedNode.type"
+          :model="selectedNode"
           class="mr-2"
         />
         <div class="title">

app/imports/ui/library/SingleLibraryToolbarItems.vue

@@ -29,7 +29,6 @@ export default {
   }},
   meteor: {
     library(){
-      console.log(this.$route);
       return Libraries.findOne(this.$route.params.id);
     },
     subscribed(){
@@ -41,7 +40,6 @@ export default {
       let userId = Meteor.userId();
       let library = this.library;
       if (!library) return;
-      console.log({library, userId});
       if (
         library.readers.includes(userId) ||
         library.writers.includes(userId) ||
@@ -55,10 +53,8 @@ export default {
     canEdit(){
       try {
         assertDocEditPermission(this.library, Meteor.userId());
-        console.log('can edit');
         return true
       } catch (e) {
-        console.log(e);
         return false;
       }
     }

app/imports/ui/pages/About.vue

@@ -0,0 +1,88 @@
+<template lang="html">
+  <div>
+    <section>
+      <v-parallax
+        src="/images/paper-dice-crown-with-candy.png"
+        height="400"
+      >
+        <v-layout
+          column
+          align-center
+          justify-center
+          class="white--text"
+        >
+          <p
+            class="white--text ma-2 headline text-xs-center"
+            style="max-width: 1200px;"
+          >
+            DiceCloud is a single-developer project started in 2014 with the aim of
+            being a character sheet that stayed in sync between the DM and their
+            players, and made it clear where every value in the sheet came from, and
+            how it was calculated.
+          </p>
+        </v-layout>
+      </v-parallax>
+    </section>
+    <section class="layout column align-center ma-2 mt-4">
+      <div>
+        <h3 class="headline mb-2">
+          Special Thanks
+        </h3>
+        <p>
+          <b>Sam</b> My fiancée, without whom DiceCloud could not hope to exist
+        </p><p>
+          <b>The "Heroes" of Asaea</b> The D&amp;D party whose joy was the fuel
+          with which DiceCloud was powered
+        </p>
+        <h3 class="title">
+          Paragon tier Patrons
+        </h3>
+        <v-list
+          avatar
+          two-line
+          style="background: inherit;"
+        >
+          <v-list-tile
+            v-for="paragon in paragons"
+            :key="paragon.name"
+          >
+            <v-list-tile-avatar>
+              <v-img :src="`/images/paragons/${paragon.avatar}.png`" />
+            </v-list-tile-avatar>
+            <v-list-tile-content>
+              <v-list-tile-title>
+                {{ paragon.name }}
+              </v-list-tile-title>
+              <v-list-tile-sub-title>
+                {{ paragon.title }}
+              </v-list-tile-sub-title>
+            </v-list-tile-content>
+          </v-list-tile>
+        </v-list>
+      </div>
+    </section>
+  </div>
+</template>
+
+<script>
+export default {
+  data(){ return {
+    paragons:[{
+      name: 'Kira Ametrine',
+      title: 'Cleric of Lewd',
+      avatar: 'kira'
+    },{
+      name: 'Satherian',
+      title: 'Defender of Naptime',
+      avatar: 'satherian'
+    },{
+      name: 'Vinton',
+      title: 'The Gravekeeper',
+      avatar: 'vinton'
+    }],
+  }},
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/pages/Home.vue

@@ -3,7 +3,7 @@
     <div class="content">
       <section>
         <v-parallax
-          src="/png/paper-dice-crown.png"
+          src="/images/paper-dice-crown.png"
           height="300"
         >
           <v-layout
@@ -78,9 +78,7 @@
               Inventory manager
             </h3>
             <p>
-              Equiping items changes your characters stats automatically. Drag
-              items to other characters, or between sheets open on different
-              tabs.
+              Equiping items changes your characters stats automatically.
             </p>
           </v-layout>
         </v-layout>
@@ -117,7 +115,6 @@
         >
           <v-btn
             v-for="btn in [
-              {link: 'https://reddit.com/r/dicecloud', name: 'Reddit'},
               {link: 'https://discord.gg/qEvdfeB', name: 'Discord'},
               {link: 'https://www.patreon.com/dicecloud', name: 'Patreon'},
               {link: 'https://github.com/ThaumRystra/DiceCloud', name: 'Github'},