Overhauled inventory tab again. Closer in functionality to V1

app/.meteor/packages

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

app/.meteor/versions

@@ -72,6 +72,7 @@ meteorhacks:subs-manager@1.6.4
 meteortesting:browser-tests@1.3.3
 meteortesting:mocha@1.1.5
 meteortesting:mocha-core@7.0.1
+mikowals:batch-insert@1.1.9
 minifier-css@1.5.0
 minifier-js@2.6.0
 minimongo@1.6.0
@@ -115,6 +116,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/campaign/Encounter.js

@@ -1,11 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-
-let Encounters = new Mongo.Collection("encounters");
-
-let EncounterSchema = new SimpleSchema({
-	//an encounter is a single flow of time all parties in an encounter are in-sync time wise
-});
-
-Encounters.attachSchema(EncounterSchema);
-
-export default Encounters;

app/imports/api/campaign/Parties.js

@@ -1,49 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-
-let Parties = new Mongo.Collection("parties");
-
-let partySchema = new SimpleSchema({
-	name: {
-		type: String,
-		defaultValue: "New Party",
-		trim: false,
-		optional: true,
-	},
-	characters: {
-		type: Array,
-		defaultValue: [],
-	},
-	characters: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-		index: 1,
-	},
-	owner: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-	},
-});
-
-Parties.attachSchema(partySchema);
-
-Parties.allow({
-	insert: function(userId, doc) {
-		return userId && doc.owner === userId;
-	},
-	update: function(userId, doc, fields, modifier) {
-		return userId && doc.owner === userId;
-	},
-	remove: function(userId, doc) {
-		return userId && doc.owner === userId;
-	},
-	fetch: ["owner"],
-});
-
-Parties.deny({
-	update: function(userId, docs, fields, modifier) {
-		// can't change owners
-		return _.contains(fields, "owner");
-	}
-});
-
-export default Parties;

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';
@@ -19,6 +20,8 @@ import {
 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');
 
 let CreaturePropertySchema = new SimpleSchema({
@@ -55,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');
@@ -76,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);
@@ -88,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);
@@ -105,7 +118,7 @@ const duplicateProperty = new ValidatedMethod({
 });
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'CreatureProperties.methods.insertPropertyFromLibraryNode',
+	name: 'creatureProperties.insertPropertyFromLibraryNode',
 	validate: new SimpleSchema({
 		nodeId: {
 			type: String,
@@ -115,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});
@@ -140,7 +158,7 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 			'ancestors.id': nodeId,
 			removed: {$ne: true},
 		}).fetch();
-		// The root node is last in the array of nodes
+    // The root node is last in the array of nodes
 		nodes.push(node);
 
 		// re-map all the ancestors
@@ -163,22 +181,21 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 		});
 
 		// Insert the creature properties
-		let docId;
+    let insertedDocIds = CreatureProperties.batchInsert(nodes);
-		nodes.forEach(doc => {
+
-			docId = CreatureProperties.insert(doc);
+    // get the root inserted doc
-		});
+    let rootId = insertedDocIds[insertedDocIds.length - 1];
 
 		// Recompute the creatures doc was attached to
-		let doc = CreatureProperties.findOne(docId);
+		recomputeCreatures(node);
-		recomputeCreatures(doc);
 
 		// Return the docId of the last property, the inserted root property
-		return docId;
+		return rootId;
 	},
 })
 
 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
@@ -192,6 +209,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);
@@ -210,8 +232,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: {
@@ -220,6 +273,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
@@ -232,40 +290,41 @@ const damageProperty = new ValidatedMethod({
 				`Property of type "${currentProperty.type}" can't be damaged`
 			);
 		}
-		if (operation === 'set'){
+		damagePropertyWork({property: currentProperty, operation, value})
-			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
-			});
-		}
 		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.methods.adjustQuantity',
+  name: 'creatureProperties.adjustQuantity',
   validate: new SimpleSchema({
     _id: SimpleSchema.RegEx.Id,
     operation: {
@@ -274,41 +333,65 @@ const adjustQuantity = new ValidatedMethod({
     },
     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);
-		// Check if property can take damage
+    adjustQuantityWork({property: currentProperty, operation, value});
-		let schema = CreatureProperties.simpleSchema(currentProperty);
+    recomputeCreatures(currentProperty);
-		if (!schema.allowsKey('quantity')){
+  },
-			throw new Meteor.Error(
+});
-				'Adjust quantity failed',
+
-				`Property of type "${currentProperty.type}" doesn't have a quantity`
+const selectAmmoItem = new ValidatedMethod({
-			);
+  name: 'creatureProperties.selectAmmoItem',
-		}
+  validate: new SimpleSchema({
-		if (operation === 'set'){
+    actionId: SimpleSchema.RegEx.Id,
-			CreatureProperties.update(_id, {
+    itemId: SimpleSchema.RegEx.Id,
-				$set: {quantity: value}
+    itemConsumedIndex: Number,
-			}, {
+  }).validator(),
-				selector: currentProperty
+  mixins: [RateLimiterMixin],
-			});
+  rateLimit: {
-		} else if (operation === 'increment'){
+    numRequests: 5,
-      // value here is 'damage'
+    timeInterval: 5000,
-      value = -value;
+  },
-			let currentQuantity = currentProperty.quantity;
+  run({actionId, itemId, itemConsumedIndex}) {
-      if (currentQuantity + value < 0) value = -currentQuantity;
+		let action = CreatureProperties.findOne(actionId);
-			CreatureProperties.update(_id, {
+		// Check permissions
-				$inc: {quantity: value}
+		assertPropertyEditPermission(action, this.userId);
-			}, {
+    // Check that this index has a document to edit
-				selector: currentProperty
+    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);
@@ -322,8 +405,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);
@@ -338,10 +426,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);
@@ -360,6 +453,7 @@ export {
 	updateProperty,
 	damageProperty,
   adjustQuantity,
+  selectAmmoItem,
 	pushToProperty,
 	pullFromProperty,
 	softRemoveProperty,

app/imports/api/creature/Creatures.js

@@ -1,10 +1,11 @@
 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';
 import SharingSchema from '/imports/api/sharing/SharingSchema.js';
 import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+import { assertUserHasPaidBenefits } from '/imports/api/users/patreon/tiers.js';
 
 import '/imports/api/creature/removeCreature.js';
 import '/imports/api/creature/restCreature.js';
@@ -106,6 +107,17 @@ let CreatureSchema = new SimpleSchema({
 		defaultValue: {}
 	},
 
+  // Tabletop
+  tabletop: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+    optional: true,
+  },
+  initiativeRoll: {
+    type: SimpleSchema.Integer,
+    optional: true,
+  },
+
 	// Settings
 	settings: {
 		type: CreatureSettingsSchema,
@@ -120,20 +132,22 @@ 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',
       'You need to be logged in to insert a creature');
     }
-    let tier = getUserTier(this.userId);
+    assertUserHasPaidBenefits(this.userId);
-    if (!tier.paidBenefits){
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      `The ${tier.name} tier does not allow you to insert a creature`);
-    }
 
 		// Create the creature document
     let charId = Creatures.insert({
@@ -146,7 +160,7 @@ const insertCreature = new ValidatedMethod({
 });
 
 const updateCreature = new ValidatedMethod({
-  name: 'Creatures.methods.update',
+  name: 'creatures.update',
   validate({_id, path}){
 		if (!_id) return false;
 		// Allowed fields
@@ -164,6 +178,11 @@ const updateCreature = new ValidatedMethod({
       '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);

app/imports/api/creature/Parties.js

@@ -0,0 +1,28 @@
+import SimpleSchema from 'simpl-schema';
+
+let Parties = new Mongo.Collection('parties');
+
+let partySchema = new SimpleSchema({
+	name: {
+		type: String,
+		defaultValue: 'New Party',
+		trim: false,
+		optional: true,
+	},
+	creatures: {
+		type: Array,
+		defaultValue: [],
+	},
+	'creatures.$': {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+	},
+	owner: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+	},
+});
+
+Parties.attachSchema(partySchema);
+
+export default Parties;

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

@@ -0,0 +1,5 @@
+import spendResources from '/imports/api/creature/actions/spendResources.js'
+
+export default function applyAction({prop}){
+  spendResources(prop);
+}

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

@@ -0,0 +1,21 @@
+import math from '/imports/math.js';
+//if (Meteor.isServer){
+//  var sendWebhook = require('/imports/server/discord/webhook.js').default;
+//}
+
+export default function applyAttack({
+  prop,
+  //children,
+  creature,
+  //targets,
+  //actionContext
+}){
+  let result = math.roll(1, 20) + prop.rollBonusResult;
+  if (Meteor.isClient){
+    console.log(`${creature.name} makes a ${prop.name} attack! Rolls ${result} to hit`);
+  }
+  //if (Meteor.isServer) sendWebhook({
+  //  webhook: creature.webhook,
+  //  message: `${creature.name} makes a ${prop.name} attack! Rolls ${result} to hit`,
+  //});
+}

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

@@ -0,0 +1,61 @@
+import {
+	setLineageOfDocs,
+	renewDocIds
+} from '/imports/api/parenting/parenting.js';
+import {setDocToLastOrder} from '/imports/api/parenting/order.js';
+import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
+
+export default function applyBuff({
+  prop,
+  children,
+  creature,
+  targets = [],
+  //actionContext,
+}){
+  let buffTargets = prop.target === 'self' ? [creature] : targets;
+
+  //let scope = {
+  //  ...creature.variables,
+  //  ...actionContext,
+  //};
+
+  // TODO
+  // If the target is not self, walk through all decendants and replace
+  // variables in calculations with their values from the creature scope
+  // If the target is self, replace all the target.x references with just x
+
+  // Then copy the decendants of the buff to the targets
+  prop.applied = true;
+  let propList = [prop];
+  function addChildrenToPropList(children){
+    children.forEach(child => {
+      propList.push(child.node);
+      addChildrenToPropList(child.children);
+    });
+  }
+  addChildrenToPropList(children);
+  let oldParent = {
+    id: prop.parent.id,
+    collection: prop.parent.collection,
+  };
+  buffTargets.forEach(target => {
+    copyNodeListToTarget(propList, target, oldParent);
+  });
+}
+
+function copyNodeListToTarget(propList, target, oldParent){
+  let ancestry = [{collection: 'creatures', id: target._id}];
+  setLineageOfDocs({
+    docArray: propList,
+    newAncestry: ancestry,
+    oldParent,
+  });
+  renewDocIds({
+    docArray: propList,
+  });
+  setDocToLastOrder({
+    collection: CreatureProperties,
+    doc: propList[0],
+  });
+  CreatureProperties.batchInsert(propList);
+}

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

@@ -0,0 +1,27 @@
+import evaluateAndRollString from '/imports/api/creature/computation/afterComputation/evaluateAndRollString.js';
+
+//if (Meteor.isServer){
+//  var sendWebhook = require('/imports/server/discord/webhook.js').default;
+//}
+
+export default function applyDamage({
+  prop,
+  creature,
+  //targets,
+  actionContext
+}){
+  //let damageTargets = prop.target === 'self' ? [creature] : targets;
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  let {result, errors} = evaluateAndRollString(prop.amount, scope);
+  if (Meteor.isClient){
+    errors.forEach(e => console.error(e));
+    console.log(`${result} ${prop.damageType}${prop.damageType !== 'healing'? ' damage': ''}`);
+  }
+  //if (Meteor.isServer) sendWebhook({
+  //  webhook: creature.webhook,
+  //  message: `${result} ${prop.damageType}${prop.damageType !== 'healing'? ' damage': ''}`,
+  //});
+}

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

@@ -0,0 +1,66 @@
+import applyAction from '/imports/api/creature/actions/applyAction.js';
+import applyAttack from '/imports/api/creature/actions/applyAttack.js';
+import applyDamage from '/imports/api/creature/actions/applyDamage.js';
+import applyBuff from '/imports/api/creature/actions/applyBuff.js';
+
+function applyProperty(options){
+  let prop = options.prop;
+  if (
+    prop.disabled === true || // ignore disabled props
+    prop.equipped === false || // ignore unequipped items
+    prop.toggleResult === false || // ignore untoggled toggles
+    prop.applied === true // ignore buffs that are already applied
+  ){
+    return false;
+  }
+  switch (prop.type){
+    case 'action':
+    case 'spell':
+      applyAction(options);
+      return true;
+    case 'attack':
+      applyAttack(options);
+      applyAction(options);
+      return true;
+    case 'damage':
+      applyDamage(options);
+      return true;
+    case 'adjustment':
+      // applyAdjustment(options);
+      return true;
+    case 'buff':
+      applyBuff(options);
+      return false;
+    case 'roll':
+      // applyRoll(options);
+      return true;
+    case 'savingThrow':
+      // applySavingThrow(options);
+      return false;
+  }
+}
+
+export default function applyProperties({
+  forest,
+  creature,
+  targets,
+  actionContext
+}){
+  forest.forEach(child => {
+    let walkChildren = applyProperty({
+      prop: child.node,
+      children: child.children,
+      creature,
+      targets,
+      actionContext
+    });
+    if (walkChildren){
+      applyProperties({
+        forest: child.children,
+        creature,
+        targets,
+        actionContext
+      });
+    }
+  });
+}

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

@@ -0,0 +1,62 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import CreatureProperties, { getCreature } from '/imports/api/creature/CreatureProperties.js';
+import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/recomputeCreature.js';
+import { nodesToTree } from '/imports/api/parenting/parenting.js';
+import applyProperties from '/imports/api/creature/actions/applyProperties.js';
+
+const doAction = new ValidatedMethod({
+  name: 'creatureProperties.doAction',
+  validate: new SimpleSchema({
+    actionId: SimpleSchema.RegEx.Id,
+    targetId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+      optional: true,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  run({actionId, targetId}) {
+    let action = CreatureProperties.findOne(actionId);
+		// Check permissions
+    let creature = getCreature(action);
+    assertEditPermission(creature, this.userId);
+    let target = undefined;
+    if (targetId) {
+      target = getCreature(targetId);
+      assertEditPermission(target, this.userId);
+    }
+		doActionWork({action, creature, target});
+    // Note this only recomputes the top-level creature, not the nearest one
+		recomputeCreatureByDoc(creature);
+    if (target){
+      recomputeCreatureByDoc(target);
+    }
+  },
+});
+
+function doActionWork({action, creature, target}){
+  let actionContext = {};
+  let decendantForest = nodesToTree({
+    collection: CreatureProperties,
+    ancestorId: action._id,
+  });
+  let startingForest = [{
+    node: action,
+    children: decendantForest,
+  }];
+  applyProperties({
+    forest: startingForest,
+    creature,
+    target,
+    actionContext
+  });
+}
+
+export default doAction;

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

@@ -0,0 +1,57 @@
+import CreatureProperties, { damagePropertyWork, adjustQuantityWork } from '/imports/api/creature/CreatureProperties.js';
+
+export default 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,
+    });
+  });
+}

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

@@ -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,6 +57,8 @@ 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){
@@ -181,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){
@@ -206,10 +224,17 @@ function isSkillOperation(prop){
 }
 
 function propDetails(prop){
-  return propDetailsByType[prop.type]() || {};
+  return propDetailsByType[prop.type] && propDetailsByType[prop.type]() ||
+    propDetailsByType.default();
 }
 
 const propDetailsByType = {
+  default(){
+    return {
+      toggleAncestors: [],
+      disabledByToggle: false,
+    };
+  },
   toggle(){
     return {
       computed: false,

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

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

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

@@ -0,0 +1,28 @@
+import math from '/imports/math.js';
+
+const diceRegex = /d\d+/;
+
+export default function substituteRollsWithFunctions(node){
+  // TODO also replace dx as 1dx
+  if (
+    node.isOperatorNode &&
+    node.fn === 'multiply' &&
+    node.implicit &&
+    node.args[1].isSymbolNode &&
+    diceRegex.test(node.args[1].name)
+  ){
+    let diceSize = node.args[1].name.slice(1);
+    let diceSizeNode = new math.ConstantNode(diceSize);
+    return new math.FunctionNode('roll', [node.args[0], diceSizeNode]);
+  } else if (
+    node.isSymbolNode &&
+    diceRegex.test(node.name)
+  ) {
+    let diceSize = node.name.slice(1);
+    let diceSizeNode = new math.ConstantNode(diceSize);
+    let diceNumberNode = new math.ConstantNode(1);
+    return new math.FunctionNode('roll', [diceNumberNode, diceSizeNode]);
+  } else {
+    return node;
+  }
+}

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

@@ -1,9 +1,10 @@
 import computeStat from '/imports/api/creature/computation/computeStat.js';
 import applyToggles from '/imports/api/creature/computation/applyToggles.js';
+import evaluateCalculation from '/imports/api/creature/computation/evaluateCalculation.js';
 
 export default function combineStat(stat, aggregator, memo){
   if (stat.type === 'attribute'){
-    combineAttribute(stat, aggregator);
+    combineAttribute(stat, aggregator, memo);
   } else if (stat.type === 'skill'){
     combineSkill(stat, aggregator, memo);
   } else if (stat.type === 'damageMultiplier'){
@@ -28,13 +29,18 @@ function getAggregatorResult(stat, aggregator){
   return result;
 }
 
-function combineAttribute(stat, aggregator){
+function combineAttribute(stat, aggregator, memo){
   stat.value = getAggregatorResult(stat, aggregator);
   stat.baseValue = aggregator.statBaseValue;
   stat.baseValueErrors = aggregator.baseValueErrors;
   if (stat.attributeType === 'ability') {
     stat.modifier = Math.floor((stat.value - 10) / 2);
   }
+  if (stat.attributeType === 'spellSlot'){
+    let {value, errors} = evaluateCalculation(stat.spellSlotLevelCalculation, memo);
+    stat.spellSlotLevelValue = value,
+    stat.spellSlotLevelErrors = errors;
+  }
   stat.currentValue = stat.value - (stat.damage || 0);
   stat.hide = aggregator.hasNoEffects &&
     stat.baseValue === undefined ||

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

@@ -0,0 +1,108 @@
+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;
+    case 'propertySlot':
+      computeSlot(prop, memo);
+  }
+}
+
+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;
+  }
+}
+
+function computeSlot(prop, memo){
+  let {value, errors} = evaluateCalculation(prop.slotCondition, memo);
+  prop.slotConditionResult = value;
+  if (errors.length){
+    prop.slotConditionErrors = errors;
+  } else {
+    delete prop.slotConditionErrors;
+  }
+}

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/evaluateCalculation.js

@@ -3,7 +3,7 @@ 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;
@@ -79,7 +79,7 @@ function symbolSubtitutor(scope, errors){
           return new math.ConstantNode(0);
         }
       }
-    } else if (node.isAccessorNode){
+    } else if (node.isAccessorNode && node.object.isSymbolNode){
       try {
         let value = node.evaluate(scope);
         if (value === undefined) throw 'Not found';

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';
@@ -11,12 +12,18 @@ 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
@@ -35,6 +42,14 @@ const calculationPropertyTypes = [
   'proficiency',
   'classLevel',
   'toggle',
+  'item',
+  // End step types
+  'action',
+  'attack',
+  'savingThrow',
+  'spellList',
+  'spell',
+  'propertySlot',
 ];
 
 export function recomputeCreatureById(creatureId){
@@ -78,7 +93,7 @@ export function recomputeCreatureById(creatureId){
  *   - Mark the stat as computed
  * - Write the computed results back to the database
  */
-function recomputeCreatureByDoc(creature){
+export function recomputeCreatureByDoc(creature){
   const creatureId = creature._id;
   let props = getActiveProperties({
     ancestorId: creatureId,

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

@@ -1,16 +1,31 @@
 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';
+import { ComputedOnlySlotSchema } from '/imports/api/properties/Slots.js';
 
 const schemasByType = {
   'skill': ComputedOnlySkillSchema,
   'attribute': ComputedOnlyAttributeSchema,
   'effect': ComputedOnlyEffectSchema,
   'toggle': ComputedOnlyToggleSchema,
+  'action': ComputedOnlyActionSchema,
+  'attack': ComputedOnlyAttackSchema,
+  'savingThrow': ComputedOnlySavingThrowSchema,
+  'spellList': ComputedOnlySpellListSchema,
+  'spell': ComputedOnlySpellSchema,
+  'propertySlot': ComputedOnlySlotSchema,
 };
 
 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

@@ -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';
 import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
 import Creatures from '/imports/api/creature/Creatures.js';
@@ -64,7 +65,7 @@ const insertExperienceForCreature = function({experience, creatureId, userId}){
 };
 
 const insertExperience = new ValidatedMethod({
-  name: 'Experiences.methods.insert',
+  name: 'experiences.insert',
   validate: new SimpleSchema({
     experience: {
       type: ExperienceSchema.omit('creatureId'),
@@ -78,6 +79,11 @@ const insertExperience = new ValidatedMethod({
       regEx: SimpleSchema.RegEx.Id,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({experience, creatureIds}) {
     let userId = this.userId;
     if (!userId) {
@@ -99,13 +105,18 @@ const insertExperience = new ValidatedMethod({
 });
 
 const removeExperience = new ValidatedMethod({
-  name: 'Experiences.methods.remove',
+  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) {
@@ -139,13 +150,18 @@ const removeExperience = new ValidatedMethod({
 });
 
 const recomputeExperiences = new ValidatedMethod({
-  name: 'Experiences.methods.recompute',
+  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) {

app/imports/api/creature/getActiveProperties.js

@@ -4,17 +4,30 @@ import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 export default function getActiveProperties({
   ancestorId,
   filter = {},
-  options,
+  options = {sort: {order: 1}},
-  includeUntoggled = false
+  includeUntoggled = false,
+  includeUnprepared = false,
+  includeUnequipped = false,
+  excludeAncestors,
 }){
-  filter = getActivePropertyFilter({ancestorId, filter, includeUntoggled});
+  filter = getActivePropertyFilter({
+    ancestorId,
+    filter,
+    includeUntoggled,
+    includeUnprepared,
+    includeUnequipped,
+    excludeAncestors,
+  });
   return CreatureProperties.find(filter, options).fetch();
 }
 
 export function getActivePropertyFilter({
   ancestorId,
   filter = {},
-  includeUntoggled = false
+  includeUntoggled = false,
+  includeUnprepared = false,
+  includeUnequipped = false,
+  excludeAncestors = [],
 }){
   if (!ancestorId){
     throw 'Ancestor Id is required to get active properties'
@@ -24,13 +37,22 @@ export function getActivePropertyFilter({
     'ancestors.id': ancestorId,
     $or: [
       {disabled: true}, // Everything can be disabled
-      {equipped: false}, // Items can be equipped
       {applied: false}, // Buffs can be applied
     ],
   };
+  if (!includeUnequipped){
+    disabledAncestorsFilter.$or.push({type: 'item', equipped: {$ne: true}});
+  }
   if (!includeUntoggled){
     disabledAncestorsFilter.$or.push({toggleResult: false});
   }
+  if (!includeUnprepared){
+    disabledAncestorsFilter.$or.push({
+      type: 'spell',
+      prepared: {$ne: true},
+      alwaysPrepared: {$ne: true}
+    });
+  }
   let disabledAncestorIds = CreatureProperties.find(disabledAncestorsFilter, {
     fields: {_id: 1},
   }).map(prop => prop._id);
@@ -47,9 +69,12 @@ export function getActivePropertyFilter({
 
   // Get all the properties that are decendents of the ancestor of interest but
   // aren't from the excluded decendents
+  if (filter['ancestors.id'] && Meteor.isClient){
+    console.warn('Filtering on ancestor id is ignored')
+  }
   filter['ancestors.id'] = {
     $eq: ancestorId,
-    $nin: disabledAncestorIds,
+    $nin: disabledAncestorIds.concat(excludeAncestors),
   };
   // Get properties that aren't removed
   filter.removed = {$ne: true};

app/imports/api/creature/removeCreature.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 Creatures from '/imports/api/creature/Creatures.js';
 import CreatureProperties from '/imports/api/creature/CreatureProperties.js'
 import { assertOwnership } from '/imports/api/creature/creaturePermissions.js';
@@ -18,6 +19,11 @@ const removeCreature = new ValidatedMethod({
       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

@@ -1,5 +1,6 @@
 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';
@@ -18,6 +19,11 @@ const restCreature = new ValidatedMethod({
       allowedValues: ['shortRest', 'longRest'],
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
   run({creatureId, restType}) {
     let creature = Creatures.findOne(creatureId, {
       fields: {

app/imports/api/icons/Icons.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 { assertAdmin } from '/imports/api/sharing/sharingPermissions.js';
 
 let Icons = new Mongo.Collection('icons');
@@ -48,7 +49,7 @@ Icons.attachSchema(iconsSchema);
 
 // This method does not validate icons against the schema, use wisely;
 const writeIcons = new ValidatedMethod({
-	name: 'icons.methods.write',
+	name: 'icons.write',
 	validate: null,
 	run(icons){
     assertAdmin(this.userId);
@@ -60,7 +61,7 @@ const writeIcons = new ValidatedMethod({
 });
 
 const findIcons = new ValidatedMethod({
-  name: 'icons.methods.find',
+  name: 'icons.find',
   validate: new SimpleSchema({
     search: {
       type: String,
@@ -68,6 +69,11 @@ const findIcons = new ValidatedMethod({
       optional: true,
     },
   }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 20,
+    timeInterval: 10000,
+  },
   run({search}){
     if (!search) return [];
     if (!Meteor.isServer) return;

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';
@@ -56,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);
@@ -66,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);
@@ -82,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
@@ -94,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);
@@ -112,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);
@@ -126,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);
@@ -141,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/parenting/parenting.js

@@ -130,7 +130,7 @@ export function renewDocIds({docArray, collectionMap}){
   const remapReference = ref => {
     if (idMap[ref.id]){
       ref.id = idMap[ref.id];
-      ref.collection = collectionMap[ref.collection] || ref.collection;
+      ref.collection = collectionMap && collectionMap[ref.collection] || ref.collection;
     }
   }
   docArray.forEach(doc => {
@@ -154,6 +154,14 @@ export function updateParent({docRef, parentRef}){
   // Get the parent and its ancestry
   let {parentDoc, parent, ancestors} = getAncestry({parentRef});
 
+  // Check that the doc isn't its own ancestor
+  ancestors.forEach(ancestor => {
+    if (docRef.id === ancestor.id){
+      throw new Meteor.Error('invalid parenting',
+        'A doc can\'t be its own ancestor')
+    }
+  });
+
   // If the doc and its parent are in the same collection, apply the allowed
   // parent rules based on type
   if (docRef.collection === parentRef.collection){
@@ -204,17 +212,11 @@ export function getName(doc){
   }
 }
 
-export function nodesToTree({collection, ancestorId, filter, options}){
+export function nodeArrayToTree(nodes){
-  // Store a dict of all the nodes
+  // Store a dict and list of all the nodes
   let nodeIndex = {};
   let nodeList = [];
-  if (!options) options = {};
+  nodes.forEach( node => {
-  options.sort = {order: 1};
-  collection.find({
-    'ancestors.id': ancestorId,
-		removed: {$ne: true},
-    ...filter,
-  }, options).forEach( node => {
     let treeNode = {
       node: node,
       children: [],
@@ -238,3 +240,12 @@ export function nodesToTree({collection, ancestorId, filter, options}){
   });
   return forest;
 }
+
+export function nodesToTree({collection, ancestorId, filter = {}, options = {}}){
+  if (!('ancestors.id' in filter)) filter['ancestors.id'] = ancestorId;
+  if (!('removed' in filter)) filter['removed'] = {$ne: true};
+  if (!options.sort) options.sort = {order: 1};
+  if (!('order' in options.sort)) options.sort.order = 1;
+  let nodes = collection.find(filter, options);
+  return nodeArrayToTree(nodes);
+}

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

@@ -39,6 +39,11 @@ let AttributeSchema = new SimpleSchema({
     type: String,
     allowedValues: ['d4', 'd6', 'd8', 'd10', 'd12', 'd20'],
     optional: true,
+  },
+  // For type spellSlot, the level needs to be stored separately
+  spellSlotLevelCalculation: {
+    type: String,
+		optional: true,
   },
 	// The starting value, before effects
 	baseValueCalculation: {
@@ -81,6 +86,18 @@ let ComputedOnlyAttributeSchema = new SimpleSchema({
   },
   'baseValueErrors.$': {
     type: ErrorSchema,
+  },
+  // The result of spellSlotLevelCalculation
+  spellSlotLevelValue: {
+    type: SimpleSchema.oneOf(Number, String, Boolean),
+    optional: true,
+  },
+  spellSlotLevelErrors: {
+    type: Array,
+    optional: true,
+  },
+  'spellSlotLevelErrors.$': {
+    type: ErrorSchema,
   },
 	// The computed value of the attribute
   value: {

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

@@ -38,7 +38,6 @@ let EffectSchema = new SimpleSchema({
 	},
 	'stats.$': {
 		type: String,
-		optional: 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,4 +1,5 @@
 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
@@ -18,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/Slots.js

@@ -1,6 +1,19 @@
 import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 
 let SlotSchema = new SimpleSchema({
+  name: {
+    type: String,
+    optional: true,
+  },
+  description: {
+    type: String,
+    optional: true,
+  },
+  slotType: {
+    type: String,
+    optional: true,
+  },
 	slotTags: {
     type: Array,
 		defaultValue: [],
@@ -8,6 +21,43 @@ let SlotSchema = new SimpleSchema({
 	'slotTags.$': {
 		type: String,
 	},
+  quantityExpected: {
+    type: SimpleSchema.Integer,
+    defaultValue: 1,
+  },
+  ignored: {
+    type: Boolean,
+    optional: true,
+  },
+  slotCondition: {
+    type: String,
+    optional: true,
+  },
+  // How many properties have been selected to fill this slot
+  quantityFilled: {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
 });
 
-export { SlotSchema };
+const ComputedOnlySlotSchema = new SimpleSchema({
+	// The computed result of the effect
+	slotConditionResult: {
+		type: SimpleSchema.oneOf(Number, String, Boolean),
+		optional: true,
+	},
+  // The errors encountered while computing the result
+  slotConditionErrors: {
+    type: Array,
+    optional: true,
+  },
+  'slotConditionErrors.$':{
+    type: ErrorSchema,
+  },
+});
+
+const ComputedSlotSchema = new SimpleSchema()
+	.extend(ComputedOnlySlotSchema)
+	.extend(SlotSchema);
+
+export { SlotSchema, ComputedSlotSchema, ComputedOnlySlotSchema };

app/imports/api/properties/SpellLists.js

@@ -1,4 +1,6 @@
 import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
+import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 
 let SpellListSchema = new SimpleSchema({
 	name: {
@@ -9,6 +11,12 @@ let SpellListSchema = new SimpleSchema({
 		type: String,
 		optional: true,
 	},
+  variableName: {
+    type: String,
+		regEx: VARIABLE_NAME_REGEX,
+    min: 2,
+    optional: true,
+  },
 	// Calculation of how many spells in this list can be prepared
 	maxPrepared: {
 		type: String,
@@ -16,4 +24,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,5 +1,6 @@
-import { ActionSchema } from '/imports/api/properties/Actions.js';
+import { ActionSchema, ComputedOnlyActionSchema } from '/imports/api/properties/Actions.js';
 import SimpleSchema from 'simpl-schema';
+import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 
 const magicSchools = [
 	'abjuration',
@@ -25,6 +26,10 @@ let SpellSchema = new SimpleSchema({})
 		type: Boolean,
 		optional: true,
 	},
+  prepared: {
+		type: Boolean,
+		optional: true,
+	},
   // This spell ignores spell slot rules
   castWithoutSpellSlots: {
     type: Boolean,
@@ -33,14 +38,6 @@ let SpellSchema = new SimpleSchema({})
   hasAttackRoll: {
     type: Boolean,
     optional: true,
-  },
-	// Spell lists that this spell appears on
-  spellLists: {
-    type: Array,
-    defaultValue: [],
-  },
-  'spellLists.$': {
-    type: String,
   },
 	description: {
 		type: String,
@@ -93,4 +90,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/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';
@@ -15,17 +15,17 @@ 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 { ComputedSlotSchema } from '/imports/api/properties/Slots.js';
-import { SpellSchema } from '/imports/api/properties/Spells.js';
+import { ComputedSpellSchema } from '/imports/api/properties/Spells.js';
-import { SpellListSchema } from '/imports/api/properties/SpellLists.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,
@@ -37,11 +37,11 @@ const propertySchemasIndex = {
   note: NoteSchema,
   proficiency: ProficiencySchema,
   roll: RollSchema,
-  savingThrow: SavingThrowSchema,
+  savingThrow: ComputedSavingThrowSchema,
   skill: ComputedSkillSchema,
-  slot: SlotSchema,
+  propertySlot: ComputedSlotSchema,
-  spellList: SpellListSchema,
+  spellList: ComputedSpellListSchema,
-  spell: SpellSchema,
+  spell: ComputedSpellSchema,
   toggle: ToggleSchema,
   container: ContainerSchema,
   item: ItemSchema,

app/imports/api/properties/propertySchemasIndex.js

@@ -39,7 +39,7 @@ const propertySchemasIndex = {
   roll: RollSchema,
   savingThrow: SavingThrowSchema,
   skill: SkillSchema,
-  slot: SlotSchema,
+  propertySlot: SlotSchema,
   spellList: SpellListSchema,
   spell: SpellSchema,
   toggle: ToggleSchema,

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

@@ -1,11 +1,9 @@
 import SimpleSchema from 'simpl-schema';
 
 const ErrorSchema = new SimpleSchema({
-	// The roll that determines how much to change the attribute
   message: {
     type: String,
   },
-	// Who this adjustment applies to
 	type: {
     type: String,
 	},

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/tabletop/Messages.js

@@ -0,0 +1,115 @@
+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 Tabletops, { assertUserInTabletop } from '/imports/api/tabletop/Tabletops.js';
+
+let Messages = new Mongo.Collection('messages');
+
+let MessagesSchema = new SimpleSchema({
+  tabletopId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+  },
+  content: {
+    type: String,
+    max: 1000,
+  },
+  timestamp: {
+    type: Date,
+    index: 1,
+  },
+  userId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+  },
+  username: {
+    type: String,
+  },
+});
+
+Messages.attachSchema(MessagesSchema);
+
+const sendMessage = new ValidatedMethod({
+
+  name: 'messages.send',
+
+  validate: new SimpleSchema({
+    content: {
+      type: String,
+      max: 1000,
+    },
+    tabletopId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.id,
+    },
+  }).validator(),
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+
+  run({content, tabletopId}) {
+    let user = Meteor.user();
+    if (!user) {
+      throw new Meteor.Error('messages.send.denied',
+      'You need to be logged in to send a message');
+    }
+    assertUserInTabletop(tabletopId, this.userId);
+
+    return Messages.insert({
+			content,
+      tabletopId,
+      timestamp: new Date(),
+      userId: user._id,
+      username: user.username,
+		});
+  },
+
+});
+
+const removeMessages = new ValidatedMethod({
+
+  name: 'messages.remove',
+
+  validate: new SimpleSchema({
+    messageId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.id,
+    },
+  }).validator(),
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
+  run({messageId, tabletopId}) {
+    if (!this.userId) {
+      throw new Meteor.Error('messages.remove.denied',
+      'You need to be logged in to remove a tabletop');
+    }
+    let message = Messages.findOne(messageId);
+    let tabletop = Tabletops.findOne(message.tabletopId);
+    if (this.userId !== message.userId && this.userId !== tabletop.gameMaster){
+      throw new Meteor.Error('messages.remove.denied',
+      'You don\'t have permission to remove this message');
+    }
+    let removed = Messages.remove({
+			_id: messageId,
+		});
+    Creatures.update({
+      tabletop: tabletopId,
+    }, {
+      $unset: {tabletop: 1},
+    });
+    return removed;
+  },
+
+});
+
+export default Messages;
+export { sendMessage, removeMessages };

app/imports/api/tabletop/Tabletops.js

@@ -0,0 +1,201 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertUserHasPaidBenefits } from '/imports/api/users/patreon/tiers.js';
+import Creatures from '/imports/api/creature/Creatures.js';
+
+let Tabletops = new Mongo.Collection('tabletops');
+
+const InitiativeSchema = new SimpleSchema({
+  active: {
+    type: Boolean,
+    defaultValue: false,
+  },
+  roundNumber: {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
+  initiativeNumber: {
+    type: SimpleSchema.Integer,
+    optional: true,
+  },
+  activeCreature: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+    optional: true,
+  },
+});
+
+// All creatures in a tabletop have a shared time and space.
+let TabletopSchema = new SimpleSchema({
+  name: {
+    type: String,
+    optional: true,
+  },
+  initiative: {
+    type: InitiativeSchema,
+    defaultValue: {},
+  },
+  gameMaster: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+  },
+  players: {
+    type: Array,
+    defaultValue: [],
+  },
+  'players.$': {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+  },
+});
+
+Tabletops.attachSchema(TabletopSchema);
+
+function assertUserIsTabletopOwner(tabletopId, userId){
+  let tabletop = Tabletops.findOne(tabletopId);
+  if (!tabletop){
+    throw new Meteor.Error('Tabletop does not exist',
+    'No tabletop could be found for the given tabletop id');
+  }
+  if (tabletop.gameMaster !== userId){
+    throw new Meteor.Error('Not the owner',
+    'The user is not the owner of the given tabletop');
+  }
+}
+
+export function assertUserInTabletop(tabletopId, userId){
+  let tabletop = Tabletops.findOne(tabletopId);
+  if (!tabletop){
+    throw new Meteor.Error('Tabletop does not exist',
+    'No tabletop could be found for the given tabletop id');
+  }
+  if (tabletop.gameMaster !== userId && !tabletop.players.includes(userId)){
+    throw new Meteor.Error('Not in tabletop',
+    'The user is not the gamemaster or a player in the given tabletop');
+  }
+}
+
+function assertUserIsAdmin(userId){
+  if (!Meteor.users.isAdmin(userId)){
+    throw new Meteor.Error('Admin only',
+    'This is restricted to admins for now');
+  }
+}
+
+const insertTabletop = new ValidatedMethod({
+
+  name: 'tabletops.insert',
+
+  validate: null,
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
+  run() {
+    if (!this.userId) {
+      throw new Meteor.Error('tabletops.insert.denied',
+      'You need to be logged in to insert a tabletop');
+    }
+    assertUserHasPaidBenefits(this.userId);
+    assertUserIsAdmin(this.userId);
+
+    return Tabletops.insert({
+			gameMaster: this.userId,
+		});
+  },
+
+});
+
+const removeTabletop = new ValidatedMethod({
+
+  name: 'tabletops.remove',
+
+  validate: new SimpleSchema({
+    tabletopId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.id,
+    },
+  }).validator(),
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
+  run({tabletopId}) {
+    if (!this.userId) {
+      throw new Meteor.Error('tabletops.remove.denied',
+      'You need to be logged in to remove a tabletop');
+    }
+    assertUserHasPaidBenefits(this.userId);
+    assertUserIsTabletopOwner(tabletopId, this.userId);
+    assertUserIsAdmin(this.userId);
+
+    let removed = Tabletops.remove({
+			_id: tabletopId,
+		});
+    Creatures.update({
+      tabletop: tabletopId,
+    }, {
+      $unset: {tabletop: 1},
+    });
+    return removed;
+  },
+
+});
+
+const addCreaturesToTabletop = new ValidatedMethod({
+
+  name: 'tabletops.addCreatures',
+
+  validate: new SimpleSchema({
+    'creatureIds': {
+      type: Array,
+    },
+    'creatureIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.id,
+    },
+    tabletopId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.id,
+    },
+  }).validator(),
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+
+  run({tabletopId, creatureIds}) {
+    if (!this.userId) {
+      throw new Meteor.Error('tabletops.addCreatures.denied',
+      'You need to be logged in to remove a tabletop');
+    }
+    assertUserHasPaidBenefits(this.userId);
+    assertUserInTabletop(tabletopId, this.userId);
+    assertUserIsAdmin(this.userId);
+
+    Creatures.update({
+      _id: {$in: creatureIds},
+      $or: [
+        {writers: this.userId},
+        {owner: this.userId},
+      ],
+    }, {
+      $set: {tabletop: tabletopId},
+    }, {
+      multi: true,
+    });
+  },
+
+});
+
+export default Tabletops;
+export { insertTabletop, removeTabletop, addCreaturesToTabletop };

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: {
@@ -82,13 +83,27 @@ const userSchema = new SimpleSchema({
     blackbox: true,
     optional: true,
   },
+  preferences: {
+    type: Object,
+    optional: true,
+    defaultValue: {},
+  },
+  'preferences.swapAbilityScoresAndModifiers': {
+    type: Boolean,
+    optional: true,
+  },
 });
 
 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 +115,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 +131,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 +141,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 +168,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 +187,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;
@@ -166,8 +201,38 @@ Meteor.users.setUsername = new ValidatedMethod({
 	}
 });
 
+Meteor.users.setPreference = new ValidatedMethod({
+  name: 'users.setPreference',
+	validate: new SimpleSchema({
+    preference:{
+      type: String,
+    },
+    value: {
+      type: SimpleSchema.oneOf(Boolean),
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+	run({preference, value}){
+		if (!this.userId) throw 'You can only set preferences once logged in';
+    let prefPath = `preferences.${preference}`
+    if (value == true){
+      return Meteor.users.update(this.userId, {
+        $set: {[prefPath]: true},
+      });
+    } else {
+      return Meteor.users.update(this.userId, {
+        $unset: {[prefPath]: 1},
+      });
+    }
+	},
+});
+
 Meteor.users.subscribeToLibrary = new ValidatedMethod({
-  name: 'Users.methods.subscribeToLibrary',
+  name: 'users.subscribeToLibrary',
 	validate: new SimpleSchema({
 		libraryId:{
 			type: String,
@@ -177,6 +242,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 +262,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/api/users/patreon/tiers.js

@@ -77,5 +77,13 @@ export function getUserTier(user){
   }
 }
 
+export function assertUserHasPaidBenefits(user){
+  let tier = getUserTier(user);
+  if (!tier.paidBenefits){
+    throw new Meteor.Error('Creatures.methods.insert.denied',
+    `The ${tier.name} tier does not allow you to insert a creature`);
+  }
+}
+
 export default TIERS;
 export { GUEST_TIER };

app/imports/constants/PROPERTIES.js

@@ -71,6 +71,10 @@ const PROPERTIES = Object.freeze({
     icon: '$vuetify.icons.skill',
     name: 'Skill'
   },
+  propertySlot: {
+    icon: 'tab_unselected',
+    name: 'Slot'
+  },
   spellList: {
     icon: '$vuetify.icons.spell_list',
     name: 'Spell list'

app/imports/math.js

@@ -1,8 +1,20 @@
 import { create, all } from 'mathjs';
+
 const math = create(all);
 math.import({
   'if': function(pred, a, b) {
       return pred ? a : b;
+  },
+  'roll': function(number, diceSize){
+    let randomSrc = DDP.randomStream('diceRoller');
+    if (number > 100) throw 'Can only roll 100 dice at a time';
+    let rollTotal = 0;
+    let i, roll;
+    for (i = 0; i < number; i++){
+      roll = ~~(randomSrc.fraction() * diceSize) + 1
+      rollTotal += roll;
+    }
+    return rollTotal;
   }
 });
 

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/discord/webhook.js

@@ -0,0 +1,7 @@
+import Discord from 'discord.js'
+export default function sendWebhook({webhook, message}){
+  // const hook = new Discord.WebhookClient(webhook.id, webhook.token);
+  const hook = new Discord.WebhookClient('420492135716880394', 'KHmRsf9QHd81C4LZOyQe_cUw5ua4ugSaIlpDMNWo3vcNHs0p0JBOHfeGWtHKqPXMYgkk');
+  // Send a message using the webhook
+  hook.send(message);
+}

app/imports/server/publications/characterList.js

@@ -1,5 +1,5 @@
 import Creatures from '/imports/api/creature/Creatures.js';
-import Parties from '/imports/api/campaign/Parties.js';
+import Parties from '/imports/api/creature/Parties.js';
 
 Meteor.publish('characterList', function(){
   this.autorun(function (){

app/imports/server/publications/index.js

@@ -1,6 +1,8 @@
+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';
+import '/imports/server/publications/tabletops.js';

app/imports/server/publications/publicationRateLimit.js

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

app/imports/server/publications/tabletops.js

@@ -0,0 +1,60 @@
+import Tabletops from '/imports/api/tabletop/Tabletops.js';
+import Creatures from '/imports/api/creature/Creatures.js';
+import Messages from '/imports/api/tabletop/Messages.js';
+
+Meteor.publish('tabletops', function(){
+  var userId = this.userId;
+  if (!userId) {
+    return this.ready();
+  }
+  return Tabletops.find({
+    $or: [
+      {players: userId},
+      {gameMaster: userId},
+    ],
+  });
+});
+
+Meteor.publish('tabletop', function(tabletopId){
+  var userId = this.userId;
+  if (!userId) {
+    return this.ready();
+  }
+  this.autorun(function (){
+    let tabletopCursor = Tabletops.find({
+      _id: tabletopId,
+      $or: [
+        {players: userId},
+        {gameMaster: userId},
+      ]
+    });
+    let tabletop = tabletopCursor.fetch()[0];
+    if (!tabletop){
+      return this.ready();
+    }
+    // Warning, this leaks data to users of the same tabletop who may not have
+    // read permission of this specific creature, so publish as few fields as
+    // possible
+    let creatureSummaries = Creatures.find({
+      tabletop: tabletopId,
+    }, {
+      fields: {
+        name: 1,
+        picture: 1,
+        avatarPicture: 1,
+        variables: 1,
+        tabletop: 1,
+        initiativeRoll: 1,
+      },
+    });
+    let recentMessages = Messages.find({
+      tabletopId,
+    }, {
+      sort: {
+        timeStamp: -1,
+      },
+      limit: 100,
+    });
+    return [ tabletopCursor, creatureSummaries, recentMessages]
+  })
+});

app/imports/server/publications/users.js

@@ -11,6 +11,7 @@ Meteor.publish('user', function(){
       darkMode: 1,
       subscribedLibraries: 1,
       profile: 1,
+      preferences: 1,
       'services.patreon.id': 1,
       'services.patreon.entitledCents': 1,
       'services.patreon.entitledCentsOverride': 1,

app/imports/ui/components/IncrementButton.vue

@@ -11,6 +11,7 @@
       <v-btn
         v-bind="$attrs"
         v-on="on"
+        @click.stop
       >
         <slot>
           <v-icon>add</v-icon>

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

@@ -75,7 +75,9 @@ export default {
 				this.ackErrors = null;
 			} else if (typeof error === 'string'){
 				this.ackErrors = error;
-			} else {
+			} else if (error.reason){
+        this.ackErrors = error.reason;
+      } else {
 				this.ackErrors = 'Something went wrong'
 				console.error(error);
 			}

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

@@ -34,8 +34,7 @@
           drag_handle
         </v-icon>
         <!--{{node && node.order}}-->
-        <component
+        <tree-node-view
-          :is="treeNodeView"
           :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: {
+    components: {
-      ...treeNodeViewIndex
+      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/creature/CreatureListTile.vue

@@ -0,0 +1,47 @@
+<template
+  lang="html"
+  functional
+>
+  <v-list-tile v-bind="$attrs">
+    <v-list-tile-avatar :color="model.color || 'grey'">
+      <img
+        v-if="model.avatarPicture"
+        :src="model.avatarPicture"
+        :alt="model.name"
+      >
+      <template v-else>
+        {{ model.initial }}
+      </template>
+    </v-list-tile-avatar>
+    <v-list-tile-content>
+      <v-list-tile-title>
+        {{ model.name }}
+      </v-list-tile-title>
+      <v-list-tile-sub-title>
+        {{ model.alignment }} {{ model.gender }} {{ model.race }}
+      </v-list-tile-sub-title>
+    </v-list-tile-content>
+    <v-list-tile-action v-if="selection">
+      <v-checkbox
+        :input-value="selected && selected.has(model._id)"
+        @change="$emit('select')"
+      />
+    </v-list-tile-action>
+  </v-list-tile>
+</template>
+
+<script type="text/javascript">
+export default {
+  props: {
+    model: {
+      type: Object,
+      required: true,
+    },
+    selection: Boolean,
+    selected: {
+      type: Set,
+      default: () => new Set(),
+    },
+  }
+}
+</script>

app/imports/ui/creature/RestButton.vue

@@ -1,7 +1,6 @@
 <template lang="html">
   <v-btn
     :loading="loading"
-    :disabled="loading"
     outline
     style="width: 160px;"
     @click="rest"

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

@@ -0,0 +1,11 @@
+<template lang="html">
+  <div class="mini-character-sheet" />
+</template>
+
+<script>
+export default {
+}
+</script>
+
+<style lang="css" scoped>
+</style>

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

@@ -16,7 +16,7 @@
 </template>
 
 <script>
-	import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 	import ColumnLayout from '/imports/ui/components/ColumnLayout.vue';
 	import FeatureCard from '/imports/ui/properties/components/features/FeatureCard.vue';
 
@@ -33,13 +33,12 @@
 		},
 		meteor: {
 			features(){
-				return CreatureProperties.find({
+        return getActiveProperties({
-					'ancestors.id': this.creatureId,
+          ancestorId: this.creatureId,
-					type: 'feature',
+          filter: {
-					removed: {$ne: true},
+            type: 'feature',
-				}, {
+          },
-					sort: {order: 1},
+        });
-				});
 			},
 		},
 		methods: {

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

@@ -1,27 +1,33 @@
 <template lang="html">
   <div class="inventory">
-    <column-layout>
+    <column-layout wide-columns>
       <div>
-        <toolbar-card :color="$vuetify.theme.secondary">
+        <toolbar-card
-          <v-spacer slot="toolbar" />
+          :color="context.creature.color"
-          <v-switch
+        >
-            v-if="context.editPermission !== false"
+          <v-toolbar-title slot="toolbar">
-            slot="toolbar"
+            Equipped
-            v-model="organize"
+          </v-toolbar-title>
-            label="Organize"
-            class="justify-end"
-          />
           <v-card-text class="px-0">
-            <creature-properties-tree
+            <item-list
-              :root="{collection: 'creatures', id: creatureId}"
+              equipment
-              :filter="{
+              :items="equippedItems"
-                type: {$in: ['item']},
+              :parent-ref="{id: creatureId, collection: 'creatures'}"
-                'ancestors.id': {$nin: containerIds}
+            />
-              }"
+          </v-card-text>
-              :organize="organize"
+        </toolbar-card>
-              group="inventory"
+      </div>
-              @selected="e => clickProperty(e)"
+      <div>
-              @reorganized="({doc}) => setEquipped(doc, false)"
+        <toolbar-card
+          :color="context.creature.color"
+        >
+          <v-toolbar-title slot="toolbar">
+            Carried
+          </v-toolbar-title>
+          <v-card-text class="px-0">
+            <item-list
+              :items="carriedItems"
+              :parent-ref="{id: creatureId, collection: 'creatures'}"
             />
           </v-card-text>
         </toolbar-card>
@@ -32,7 +38,6 @@
       >
         <container-card
           :model="container"
-          :organize="organize"
         />
       </div>
     </column-layout>
@@ -42,23 +47,27 @@
 <script>
 import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 import ColumnLayout from '/imports/ui/components/ColumnLayout.vue';
-import CreaturePropertiesTree from '/imports/ui/creature/creatureProperties/CreaturePropertiesTree.vue';
 import ContainerCard from '/imports/ui/properties/components/inventory/ContainerCard.vue';
 import ToolbarCard from '/imports/ui/components/ToolbarCard.vue';
+import ItemList from '/imports/ui/properties/components/inventory/ItemList.vue';
 import { updateProperty } from '/imports/api/creature/CreatureProperties.js';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
 export default {
 	components: {
 		ColumnLayout,
-		CreaturePropertiesTree,
 		ContainerCard,
     ToolbarCard,
+    ItemList,
 	},
   inject: {
     context: { default: {} }
   },
 	props: {
-		creatureId: String,
+		creatureId: {
+      type: String,
+      required: true,
+    },
 	},
 	data(){ return {
 		organize: false,
@@ -85,6 +94,26 @@ export default {
 				sort: {order: 1},
 			});
 		},
+    carriedItems(){
+      return getActiveProperties({
+        ancestorId: this.creatureId,
+        includeUnequipped: true,
+        filter: {
+          type: 'item',
+          equipped: {$ne: true},
+          'parent.id': this.creatureId
+        },
+      });
+    },
+    equippedItems(){
+      return getActiveProperties({
+        ancestorId: this.creatureId,
+        filter: {
+          type: 'item',
+          equipped: true,
+        },
+      });
+    },
 	},
 	computed: {
 		containerIds(){

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

@@ -139,7 +139,7 @@ export default {
       let highestLevels = {};
       let highestLevelsList = [];
       this.classLevels.forEach(classLevel => {
-        let name = classLevel.vairableName;
+        let name = classLevel.variableName;
         if (
           !highestLevels[name] ||
           highestLevels[name].level < classLevel.level

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

@@ -1,27 +1,12 @@
 <template lang="html">
   <div class="spells">
-    <column-layout>
+    <column-layout wide-columns>
-      <div>
+      <div v-if="spellsWithoutList.length">
         <v-card>
-          <v-card-text>
+          <spell-list
-            <v-switch
+            :spells="spellsWithoutList"
-              v-if="context.editPermission !== false"
+            :parent-ref="{id: creatureId, collection: 'creatures'}"
-              v-model="organize"
+          />
-              label="Organize"
-              class="justify-end"
-            />
-            <creature-properties-tree
-              :root="{collection: 'creatures', id: creatureId}"
-              :filter="{
-                equipped: {$ne: true},
-                type: 'spell',
-                'ancestors.id': {$nin: spellListIds}
-              }"
-              :organize="organize"
-              group="spells"
-              @selected="e => clickProperty(e)"
-            />
-          </v-card-text>
         </v-card>
       </div>
       <div
@@ -38,15 +23,15 @@
 </template>
 
 <script>
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 import ColumnLayout from '/imports/ui/components/ColumnLayout.vue';
-import CreaturePropertiesTree from '/imports/ui/creature/creatureProperties/CreaturePropertiesTree.vue';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 import SpellListCard from '/imports/ui/properties/components/spells/SpellListCard.vue';
+import SpellList from '/imports/ui/properties/components/spells/SpellList.vue';
 
 export default {
 	components: {
 		ColumnLayout,
-		CreaturePropertiesTree,
+    SpellList,
 		SpellListCard,
 	},
   inject: {
@@ -63,25 +48,36 @@ export default {
 	}},
 	meteor: {
 		spellLists(){
-			return CreatureProperties.find({
+      return getActiveProperties({
-				'ancestors.id': this.creatureId,
+        ancestorId: this.creatureId,
-				type: 'spellList',
+        filter: {
-				removed: {$ne: true},
+          type: 'spellList',
-			}, {
+        },
-				sort: {order: 1},
+      });
-			});
 		},
+    spellsWithoutList(){
+      return getActiveProperties({
+        ancestorId: this.creatureId,
+        excludeAncestors: this.spellListIds,
+        filter: {
+          type: 'spell',
+        },
+        options: {
+          sort: {
+            level: 1,
+            order: 1,
+          },
+        },
+      });
+    },
 		spellListsWithoutAncestorSpellLists(){
-			return CreatureProperties.find({
+      return getActiveProperties({
-				'ancestors.id': {
+        ancestorId: this.creatureId,
-					$eq: this.creatureId,
+        excludeAncestors: this.spellListIds,
-					$nin: this.spellListIds
+        filter: {
-				},
+          type: 'spellList',
-				type: 'spellList',
+        },
-				removed: {$ne: true},
+      });
-			}, {
-				sort: {order: 1},
-			});
 		},
 	},
 	computed: {
@@ -93,7 +89,7 @@ export default {
 		clickProperty(_id){
 			this.$store.commit('pushDialogStack', {
 				component: 'creature-property-dialog',
-				elementId: `tree-node-${_id}`,
+				elementId: `spell-list-tile-${_id}`,
 				data: {_id},
 			});
 		},

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

@@ -21,6 +21,39 @@
           </v-card-text>
         </v-card>
       </div>
+
+      <div
+        v-if="appliedBuffs.length"
+        class="buffs"
+      >
+        <v-card>
+          <v-list>
+            <v-subheader>Buffs and conditions</v-subheader>
+            <v-list-tile
+              v-for="buff in appliedBuffs"
+              :key="buff._id"
+              :data-id="buff._id"
+              @click="clickProperty({_id: buff._id})"
+            >
+              <v-list-tile-content>
+                <v-list-tile-title>
+                  {{ buff.name }}
+                </v-list-tile-title>
+              </v-list-tile-content>
+              <v-list-tile-action>
+                <v-btn
+                  icon
+                  flat
+                  @click.stop="softRemove(buff._id)"
+                >
+                  <v-icon>delete</v-icon>
+                </v-btn>
+              </v-list-tile-action>
+            </v-list-tile>
+          </v-list>
+        </v-card>
+      </div>
+
       <div class="ability-scores">
         <v-card>
           <v-list>
@@ -165,6 +198,30 @@
         </v-card>
       </div>
 
+      <div
+        v-for="action in actions"
+        :key="action._id"
+        class="actions"
+      >
+        <action-card
+          :model="action"
+          :data-id="action._id"
+          @click="clickProperty({_id: action._id})"
+        />
+      </div>
+      <div
+        v-for="attack in attacks"
+        :key="attack._id"
+        class="attacks"
+      >
+        <action-card
+          attack
+          :model="attack"
+          :data-id="attack._id"
+          @click="clickProperty({_id: attack._id})"
+        />
+      </div>
+
       <div
         v-if="weapons && weapons.length"
         class="weapon-proficiencies"
@@ -187,7 +244,7 @@
       </div>
       <div
         v-if="armors && armors.length"
-        class="weapon-proficiencies"
+        class="armor-proficiencies"
       >
         <v-card>
           <v-list>
@@ -207,7 +264,7 @@
       </div>
       <div
         v-if="tools && tools.length"
-        class="weapon-proficiencies"
+        class="tool-proficiencies"
       >
         <v-card>
           <v-list>
@@ -245,54 +302,13 @@
           </v-list>
         </v-card>
       </div>
-
-      <div
-        v-if="actions.length"
-        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>
-      </div>
-      <div
-        v-if="attacks.length"
-        class="actions"
-      >
-        <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>
-      </div>
     </column-layout>
   </div>
 </template>
 
 <script>
   import Creatures from '/imports/api/creature/Creatures.js';
-	import { damageProperty } from '/imports/api/creature/CreatureProperties.js';
+	import { damageProperty, softRemoveProperty } 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';
@@ -302,8 +318,7 @@
 	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 ActionCard from '/imports/ui/properties/components/actions/ActionCard.vue';
-  import AttackListTile from '/imports/ui/properties/components/actions/AttackListTile.vue';
   import RestButton from '/imports/ui/creature/RestButton.vue';
   import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
@@ -345,8 +360,7 @@
 			SkillListTile,
 			ResourceCard,
 			SpellSlotListTile,
-      ActionListTile,
+      ActionCard,
-      AttackListTile,
 		},
 		props: {
 			creatureId: {
@@ -400,8 +414,18 @@
       actions(){
         return getProperties(this.creature, {type: 'action'});
 			},
+      appliedBuffs(){
+        return getProperties(this.creature, {type: 'buff', applied: true});
+			},
       attacks(){
-        return getProperties(this.creature, {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: {
@@ -421,6 +445,11 @@
         if (!obj) return 0;
         return Object.keys(obj).length;
       },
+      softRemove(_id){
+        softRemoveProperty.call({_id}, error => {
+          if (error) console.error(error);
+        });
+      }
 		},
 	};
 </script>

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}"

app/imports/ui/dialogStack/DialogComponentIndex.js

@@ -11,6 +11,7 @@ import LibraryEditDialog from '/imports/ui/library/LibraryEditDialog.vue';
 import LibraryNodeCreationDialog from '/imports/ui/library/LibraryNodeCreationDialog.vue';
 import LibraryNodeDialog from '/imports/ui/library/LibraryNodeDialog.vue';
 import MoveLibraryNodeDialog from '/imports/ui/library/MoveLibraryNodeDialog.vue'
+import SelectCreaturesDialog from '/imports/ui/tabletop/SelectCreaturesDialog.vue';
 import ShareDialog from '/imports/ui/sharing/ShareDialog.vue';
 import TierTooLowDialog from '/imports/ui/user/TierTooLowDialog.vue';
 import UsernameDialog from '/imports/ui/user/UsernameDialog.vue';
@@ -29,6 +30,7 @@ export default {
   LibraryNodeCreationDialog,
   LibraryNodeDialog,
   MoveLibraryNodeDialog,
+  SelectCreaturesDialog,
 	ShareDialog,
   TierTooLowDialog,
   UsernameDialog,

app/imports/ui/layouts/Sidebar.vue

@@ -115,7 +115,7 @@
 
 <script>
   import Creatures from '/imports/api/creature/Creatures.js';
-  import Parties from '/imports/api/campaign/Parties.js';
+  import Parties from '/imports/api/creature/Parties.js';
 
   export default {
     meteor: {
@@ -135,6 +135,7 @@
           {title: 'Home', icon: 'home', to: '/'},
           {title: 'Characters', icon: 'portrait', to: '/characterList', requireLogin: true},
           {title: 'Library', icon: 'book', to: '/library', requireLogin: true},
+          //{title: 'Tabletops', icon: 'api', to: '/tabletops', requireLogin: true},
           //{title: 'Friends', icon: 'people', to: '/friends', requireLogin: true},
           {title: 'Feedback', icon: 'bug_report', to: '/feedback'},
           {title: 'About', icon: 'subject', to: '/about'},

app/imports/ui/library/LibraryAndNode.vue

@@ -36,6 +36,7 @@
     <div
       slot="detail"
       data-id="selected-node-card"
+      style="overflow: hidden;"
     >
       <library-node-dialog
         :_id="selected"

app/imports/ui/library/LibraryBrowser.vue

@@ -8,6 +8,7 @@
     <v-expansion-panel
       v-model="expandedLibrary"
       style="box-shadow: none;"
+      expand
     >
       <v-expansion-panel-content
         v-for="library in libraries"

app/imports/ui/library/LibraryContentsContainer.vue

@@ -1,14 +1,13 @@
 <template lang="html">
-	<tree-node-list
+  <tree-node-list
-
+    group="library"
-		:children="libraryChildren"
+    :children="libraryChildren"
-		:group="library && library._id"
+    :organize="organizeMode"
-		:organize="organizeMode"
+    :selected-node-id="selectedNodeId"
-		:selected-node-id="selectedNodeId"
+    @selected="e => $emit('selected', e)"
-		@selected="e => $emit('selected', e)"
+    @reordered="reordered"
-		@reordered="reordered"
+    @reorganized="reorganized"
-		@reorganized="reorganized"
+  />
-	/>
 </template>
 
 <script>

app/imports/ui/pages/Account.vue

@@ -6,12 +6,23 @@
     >
       <v-list>
         <v-list-tile>
-          <v-switch
+          <smart-switch
-            :input-value="darkMode"
+            :value="darkMode"
             label="Dark mode"
             @change="setDarkMode"
           />
         </v-list-tile>
+        <v-list-tile>
+          <smart-switch
+            label="Swap ability scores and modifiers"
+            :value="
+              user &&
+                user.preferences &&
+                user.preferences.swapAbilityScoresAndModifiers
+            "
+            @change="swapAbilityScoresAndModifiers"
+          />
+        </v-list-tile>
 
         <v-subheader>
           Username
@@ -186,8 +197,14 @@
         Meteor.logout();
         router.push('/');
       },
-      setDarkMode(value){
+      setDarkMode(value, ack){
-        Meteor.users.setDarkMode.call({darkMode: !!value});
+        Meteor.users.setDarkMode.call({darkMode: !!value}, ack);
+      },
+      swapAbilityScoresAndModifiers(value, ack){
+        Meteor.users.setPreference.call({
+          preference: 'swapAbilityScoresAndModifiers',
+          value: !!value,
+        }, ack);
       },
       generateKey(){
         Meteor.users.gnerateApiKey.call(error => {

app/imports/ui/pages/CharacterList.vue

@@ -2,30 +2,12 @@
   <div>
     <v-card class="ma-4">
       <v-list v-if="CreaturesWithNoParty.length">
-        <v-list-tile
+        <creature-list-tile
           v-for="character in CreaturesWithNoParty"
           :key="character._id"
           :to="character.url"
-        >
+          :model="character"
-          <v-list-tile-avatar :color="character.color || 'grey'">
+        />
-            <img
-              v-if="character.avatarPicture"
-              :src="character.avatarPicture"
-              :alt="character.name"
-            >
-            <template v-else>
-              {{ character.initial }}
-            </template>
-          </v-list-tile-avatar>
-          <v-list-tile-content>
-            <v-list-tile-title>
-              {{ character.name }}
-            </v-list-tile-title>
-            <v-list-tile-sub-title>
-              {{ character.alignment }} {{ character.gender }} {{ character.race }}
-            </v-list-tile-sub-title>
-          </v-list-tile-content>
-        </v-list-tile>
       </v-list>
       <v-expansion-panel popout>
         <v-expansion-panel-content
@@ -98,9 +80,10 @@
 
 <script>
   import Creatures, {insertCreature} from '/imports/api/creature/Creatures.js';
-  import Parties from '/imports/api/campaign/Parties.js';
+  import Parties from '/imports/api/creature/Parties.js';
   import LabeledFab from '/imports/ui/components/LabeledFab.vue';
   import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+  import CreatureListTile from '/imports/ui/creature/CreatureListTile.vue';
 
   const characterTransform = function(char){
     char.url = `/character/${char._id}/${char.urlName || '-'}`;
@@ -110,6 +93,7 @@
   export default {
     components: {
       LabeledFab,
+      CreatureListTile,
     },
     data(){ return{
       fab: false,

app/imports/ui/pages/Tabletop.vue

@@ -0,0 +1,46 @@
+<template lang="html">
+  <div
+    class="tabletop-page"
+    style="height: 100%;"
+  >
+    <div
+      v-if="!this.$subReady.tabletop"
+      class="layout column align-center justify-center"
+      style="height: 100%;"
+    >
+      <v-progress-circular indeterminate />
+    </div>
+    <tabletop-component
+      v-else-if="tabletop"
+      :model="tabletop"
+    />
+    <div
+      v-else
+      class="pa-4"
+    >
+      <p>This tabletop was not found</p>
+      <p>Either it does not exist, or you do not have permission to view it</p>
+    </div>
+  </div>
+</template>
+
+<script>
+import Tabletops from '/imports/api/tabletop/Tabletops.js';
+import TabletopComponent from '/imports/ui/tabletop/TabletopComponent.vue';
+
+export default {
+  components: {
+    TabletopComponent,
+  },
+  meteor: {
+    tabletop(){
+      return Tabletops.findOne(this.$route.params.id);
+    },
+    $subscribe: {
+      'tabletop'(){
+        return [this.$route.params.id];
+      },
+    }
+  }
+}
+</script>

app/imports/ui/pages/Tabletops.vue

@@ -0,0 +1,67 @@
+<template lang="html">
+  <single-card-layout class="tabletops">
+    <v-list
+      v-if="tabletops.length"
+      class="tabletops"
+    >
+      <v-list-tile
+        v-for="tabletop in tabletops"
+        :key="tabletop._id"
+        :to="`/tabletop/${tabletop._id}`"
+      >
+        <v-list-tile-content>
+          <v-list-tile-title>
+            {{ tabletop.name || 'Unnamed Tabletop' }}
+          </v-list-tile-title>
+        </v-list-tile-content>
+      </v-list-tile>
+    </v-list>
+    <v-card-text v-else>
+      You don't own or belong to any tabletops yet
+    </v-card-text>
+    <v-btn
+      color="primary"
+      fab
+      fixed
+      bottom
+      right
+      :loading="addTabletopLoading"
+      @click="addTabletop"
+    >
+      <v-icon>add</v-icon>
+    </v-btn>
+  </single-card-layout>
+</template>
+
+<script>
+import SingleCardLayout from '/imports/ui/layouts/SingleCardLayout.vue'
+import Tabletops, { insertTabletop } from '/imports/api/tabletop/Tabletops.js';
+
+export default {
+  components: {
+    SingleCardLayout,
+  },
+  data(){return {
+    addTabletopLoading: false,
+  }},
+  meteor: {
+    tabletops(){
+      return Tabletops.find();
+    },
+    $subscribe: {
+      'tabletops': [],
+    },
+  },
+  methods: {
+    addTabletop(){
+      this.addTabletopLoading = true;
+      insertTabletop.call(() => {
+        this.addTabletopLoading = false;
+      });
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/properties/components/actions/ActionCard.vue

@@ -0,0 +1,244 @@
+<template lang="html">
+  <v-card
+    class="action-card"
+    :class="cardClasses"
+    :elevation="hovering ? 8 : undefined"
+  >
+    <div class="layout row align-center px-3">
+      <div class="avatar">
+        <v-btn
+          flat
+          icon
+          outline
+          style="margin-left: -4px; font-size: 18px;"
+          :color="model.color || 'primary'"
+          :loading="doActionLoading"
+          :disabled="model.insufficientResources || !context.editPermission"
+          @click.stop="doAction"
+        >
+          <template v-if="attack && !rollBonusTooLong">
+            {{ rollBonus }}
+          </template>
+          <property-icon
+            v-else
+            :model="model"
+          />
+        </v-btn>
+      </div>
+      <div
+        class="action-header flex layout column justify-center pl-1"
+        style="height: 72px; cursor: pointer;"
+        @mouseover="hovering = true"
+        @mouseleave="hovering = false"
+        @click="$emit('click')"
+      >
+        <div
+          class="action-title my-1"
+        >
+          {{ model.name || propertyName }}
+        </div>
+        <div class="action-sub-title layout row align-center">
+          <div class="flex">
+            {{ model.actionType }}
+          </div>
+          <div v-if="model.uses">
+            {{ usesLeft }} uses
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="px-3 pb-3">
+      <template
+        v-if="model.resources.attributesConsumed.length ||
+          model.resources.itemsConsumed.length"
+      >
+        <attribute-consumed-view
+          v-for="attributeConsumed in model.resources.attributesConsumed"
+          :key="attributeConsumed._id"
+          class="action-child"
+          :model="attributeConsumed"
+        />
+        <item-consumed-view
+          v-for="itemConsumed in model.resources.itemsConsumed"
+          :key="itemConsumed._id"
+          class="action-child"
+          :model="itemConsumed"
+          :action="model"
+        />
+        <v-divider
+          v-if="model.summary || children.length"
+          class="my-2"
+        />
+      </template>
+      <template v-if="model.summary">
+        <property-description :value="model.summary" />
+        <v-divider
+          v-if="children.length"
+          class="my-2"
+        />
+      </template>
+      <tree-node-view
+        v-for="child in children"
+        :key="child._id"
+        class="action-child"
+        :model="child"
+      />
+    </div>
+  </v-card>
+</template>
+
+<script>
+import { getPropertyName } from '/imports/constants/PROPERTIES.js';
+import numberToSignedString from '/imports/ui/utility/numberToSignedString.js';
+import doAction from '/imports/api/creature/actions/doAction.js';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
+import TreeNodeView from '/imports/ui/properties/treeNodeViews/TreeNodeView.vue';
+import AttributeConsumedView from '/imports/ui/properties/components/actions/AttributeConsumedView.vue';
+import ItemConsumedView from '/imports/ui/properties/components/actions/ItemConsumedView.vue';
+import PropertyDescription from '/imports/ui/properties/viewers/shared/PropertyDescription.vue';
+import PropertyIcon from '/imports/ui/properties/shared/PropertyIcon.vue';
+
+export default {
+  components: {
+    TreeNodeView,
+    AttributeConsumedView,
+    ItemConsumedView,
+    PropertyDescription,
+    PropertyIcon,
+  },
+  inject: {
+    context: {
+      default: {},
+    },
+    theme: {
+      default: {
+        isDark: false,
+      },
+    },
+  },
+  props: {
+    model: {
+      type: Object,
+      required: true,
+    },
+    attack: {
+      type: Boolean,
+    },
+  },
+  data(){return {
+    activated: undefined,
+    doActionLoading: false,
+    hovering: false,
+  }},
+  computed: {
+    rollBonus(){
+      if (!this.attack) return;
+      return numberToSignedString(this.model.rollBonusResult);
+    },
+    rollBonusTooLong(){
+      return this.rollBonus && this.rollBonus.length > 3;
+    },
+    totalUses(){
+      return Math.max(this.model.usesResult, 0);
+    },
+    usesLeft(){
+      return Math.max(this.model.usesResult - this.model.usesUsed, 0);
+    },
+    propertyName(){
+      return getPropertyName(this.model.type);
+    },
+    cardClasses() {
+      return {
+        'theme--dark': this.theme.isDark,
+        'theme--light': !this.theme.isDark,
+        'muted-text': this.model.insufficientResources,
+        'shrink': this.activated,
+      }
+    },
+    actionTypeIcon() {
+      return `$vuetify.icons.${this.model.actionType}`;
+    },
+	},
+  meteor: {
+    children(){
+      return getActiveProperties({
+        ancestorId: this.model._id,
+        filter: {'parent.id': this.model._id},
+        options: {sort: {order: 1}},
+      });
+    },
+  },
+  methods: {
+    click(e){
+			this.$emit('click', e);
+		},
+    doAction(){
+      this.doActionLoading = true;
+      this.shwing();
+      doAction.call({actionId: this.model._id}, error => {
+        this.doActionLoading = false;
+        if (error){
+          console.error(error);
+        }
+      });
+    },
+    shwing(){
+      this.activated = true;
+      setTimeout(() => {
+        this.activated = undefined;
+      }, 300);
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+.action-title {
+  font-size: 16px;
+  font-weight: 400;
+  height: 24px;
+  line-height: 24px;
+  position: relative;
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  transition: .3s cubic-bezier(.25,.8,.5,1);
+  width: 100%;
+}
+.action-sub-title {
+  color: #9e9e9e;
+  flex-grow: 0;
+  font-size: 12px;
+  line-height: 12px;
+  height: 14px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  width: 100%;
+}
+.action-child {
+  height: 32px;
+}
+.theme--light.muted-text {
+  color: rgba(0,0,0,.3) !important;
+}
+.theme--dark.muted-text {
+  color: hsla(0,0%,100%,.3) !important;
+}
+.action-card {
+  transition: transform 0.15s cubic;
+}
+</style>
+
+<style lang="css">
+.action-card.theme--light.muted-text .v-icon {
+  color: rgba(0,0,0,.3) !important;
+}
+.action-card.theme--dark.muted-text .v-icon {
+  color: hsla(0,0%,100%,.3) !important;
+}
+.action-card .property-description > p:last-of-type {
+  margin-bottom: 0;
+}
+</style>

app/imports/ui/properties/components/actions/ActionListTile.vue

@@ -1,36 +0,0 @@
-<template lang="html">
-  <v-list-tile
-    class="ability-list-tile"
-    v-on="hasClickListener ? {click} : {}"
-  >
-    <v-list-tile-content>
-      <v-list-tile-title>
-        {{ model.name }}
-      </v-list-tile-title>
-    </v-list-tile-content>
-  </v-list-tile>
-</template>
-
-<script>
-export default {
-  props: {
-    model: {
-      type: Object,
-      required: true,
-    }
-  },
-  computed: {
-		hasClickListener(){
-      return this.$listeners && this.$listeners.click
-		},
-	},
-  methods: {
-    click(e){
-			this.$emit('click', e);
-		},
-  }
-}
-</script>
-
-<style lang="css" scoped>
-</style>

app/imports/ui/properties/components/actions/AttackListTile.vue

@@ -1,49 +0,0 @@
-<template lang="html">
-  <v-list-tile
-    class="ability-list-tile"
-    avatar
-    v-on="hasClickListener ? {click} : {}"
-  >
-    <v-list-tile-avatar color="grey darken-1">
-      <computed
-        signed
-        :value="model.rollBonus"
-        class="white--text headline"
-      />
-    </v-list-tile-avatar>
-    <v-list-tile-content>
-      <v-list-tile-title>
-        {{ model.name }}
-      </v-list-tile-title>
-    </v-list-tile-content>
-  </v-list-tile>
-</template>
-
-<script>
-import ComputedForCreature from '/imports/ui/components/computation/ComputedForCreature.vue';
-
-export default {
-  components: {
-    Computed: ComputedForCreature,
-  },
-  props: {
-    model: {
-      type: Object,
-      required: true,
-    }
-  },
-  computed: {
-		hasClickListener(){
-      return this.$listeners && this.$listeners.click
-		},
-	},
-  methods: {
-    click(e){
-			this.$emit('click', e);
-		},
-  }
-}
-</script>
-
-<style lang="css" scoped>
-</style>

app/imports/ui/properties/components/actions/AttributeConsumedView.vue

@@ -0,0 +1,34 @@
+<template lang="html">
+  <div
+    class="layout row align-center justify-start"
+    :class="insufficient && 'error--text'"
+  >
+    <div
+      class="mr-2"
+      style="width: 24px; text-align: center;"
+    >
+      {{ model.quantity }}
+    </div>
+    <div
+      class="text-no-wrap text-truncate"
+    >
+      {{ model.statName || model.variableName }}
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  props: {
+    model: {
+      type: Object,
+      default: () => ({}),
+    },
+  },
+  computed: {
+    insufficient(){
+      return this.model.quantity > this.model.available;
+    },
+  },
+}
+</script>

app/imports/ui/properties/components/actions/ItemConsumedView.vue

@@ -0,0 +1,133 @@
+<template lang="html">
+  <div
+    :class="{
+      'theme--dark': theme.isDark,
+      'theme--light': !theme.isDark,
+    }"
+  >
+    <v-menu
+      v-if="context.creature"
+      transition="slide-y-transition"
+      lazy
+      :disabled="!context.editPermission"
+    >
+      <template #activator="{ on }">
+        <div
+          class="layout row align-center justify-start"
+          style="height: 100%;"
+          :class="{
+            'error--text': insufficient,
+            'clickable': context.creature && context.editPermission,
+            'left-pad': leftPad,
+          }"
+          v-on="on"
+        >
+          <svg-icon
+            v-if="model.itemIcon"
+            class="mr-2"
+            :shape="model.itemIcon.shape"
+            :color="model.itemColor"
+          />
+          <div
+            class="mr-2 text-no-wrap"
+            style="min-width: 24px; text-align: center;"
+          >
+            <template v-if="model.quantity !== 0 && insufficient">
+              {{ model.available }} / {{ model.quantity }}
+            </template>
+            <template v-else>
+              {{ model.available }}
+            </template>
+          </div>
+          <div
+            class="text-no-wrap text-truncate flex"
+          >
+            <template v-if="model.itemId">
+              {{ model.itemName }}
+            </template>
+            <span
+              v-else
+              class="error--text"
+            >
+              Select ammo
+            </span>
+          </div>
+          <v-icon v-if="context.editPermission">
+            arrow_drop_down
+          </v-icon>
+        </div>
+      </template>
+      <select-item-to-consume
+        :action="action"
+        :item-consumed="model"
+      />
+    </v-menu>
+    <div
+      v-else
+      class="layout row align-center justify-start"
+      :class="{'left-pad': leftPad}"
+    >
+      <div
+        class="mr-2"
+        style="width: 24px; text-align: center;"
+      >
+        {{ model.quantity }}
+      </div>
+      <div
+        class="text-no-wrap text-truncate"
+      >
+        [{{ model.tag }}]
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+import SelectItemToConsume from '/imports/ui/properties/components/actions/SelectItemToConsume.vue';
+export default {
+  components: {
+    SelectItemToConsume,
+  },
+  inject: {
+    context: {
+      default: {},
+    },
+    theme: {
+      default: {
+        isDark: false,
+      },
+    },
+  },
+  props: {
+    model: {
+      type: Object,
+      default: () => ({}),
+    },
+    action: {
+      type: Object,
+      required: true,
+    },
+    leftPad: Boolean,
+  },
+  computed: {
+    insufficient(){
+      return this.model.quantity > this.model.available;
+    },
+  },
+}
+</script>
+
+<style lang="css" scoped>
+.clickable {
+  cursor: pointer;
+}
+.theme--light .clickable:hover {
+  background: rgba(0,0,0,.04);
+}
+.theme--dark .clickable:hover {
+  background: hsla(0,0%,100%,.08);
+}
+.left-pad {
+  padding-left: 44px;
+}
+</style>

app/imports/ui/properties/components/actions/SelectItemToConsume.vue

@@ -0,0 +1,73 @@
+<template lang="html">
+  <v-list v-if="items.length">
+    <v-list-tile
+      v-for="item in items"
+      :key="item._id"
+      @click="selectItem(item._id)"
+    >
+      <item-tree-node
+        :model="item"
+        :selected="itemConsumed.itemId === item._id"
+      />
+    </v-list-tile>
+  </v-list>
+  <v-card v-else>
+    <v-card-text>
+      No equipped items found with the tag "{{ itemConsumed.tag }}"
+    </v-card-text>
+  </v-card>
+</template>
+
+<script>
+import ItemTreeNode from '/imports/ui/properties/treeNodeViews/ItemTreeNode.vue';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
+import { selectAmmoItem } from '/imports/api/creature/CreatureProperties.js';
+import { findIndex } from 'lodash';
+export default {
+  components: {
+    ItemTreeNode
+  },
+  props: {
+    action: {
+      type: Object,
+      required: true,
+    },
+    itemConsumed: {
+      type: Object,
+      required: true,
+    },
+  },
+  meteor: {
+    items(){
+      return getActiveProperties({
+        ancestorId: this.action.ancestors[0].id,
+        filter: {
+          tags: this.itemConsumed.tag,
+          equipped: true,
+        },
+        options: {
+          fields: {equipped: false},
+        }
+      });
+    }
+  },
+  methods:{
+    selectItem(itemId){
+      let itemConsumedIndex = findIndex(
+        this.action.resources.itemsConsumed,
+        item => item._id === this.itemConsumed._id
+      );
+      selectAmmoItem.call({
+        actionId: this.action._id,
+        itemId,
+        itemConsumedIndex
+      }, error => {
+        if (error) console.error(error);
+      });
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/properties/components/attributes/AbilityListTile.vue

@@ -5,10 +5,20 @@
   >
     <v-list-tile-action class="mr-4">
       <div class="display-1 mod">
-        {{ numberToSignedString(model.modifier) }}
+        <template v-if="swapScoresAndMods">
+          {{ model.value }}
+        </template>
+        <template v-else>
+          {{ numberToSignedString(model.modifier) }}
+        </template>
       </div>
       <div class="title value">
-        {{ model.value }}
+        <template v-if="swapScoresAndMods">
+          {{ numberToSignedString(model.modifier) }}
+        </template>
+        <template v-else>
+          {{ model.value }}
+        </template>
       </div>
     </v-list-tile-action>
 
@@ -36,7 +46,15 @@ export default {
 		click(e){
 			this.$emit('click', e);
 		},
-	}
+	},
+  meteor: {
+    swapScoresAndMods(){
+      let user = Meteor.user();
+      return user &&
+        user.preferences &&
+        user.preferences.swapAbilityScoresAndModifiers;
+    }
+  }
 }
 </script>
 

app/imports/ui/properties/components/attributes/HealthBarCard.vue

@@ -10,6 +10,25 @@
       @change="e => $emit('change', {_id: attribute._id, change: e})"
       @click="e => $emit('click', {_id: attribute._id})"
     />
+    <div class="ma-3">
+      <span
+        v-if="multipliers.vulnerabilities.length"
+        :class="{'mr-2': multipliers.resistances.length || multipliers.immunities.length}"
+      >
+        <b>Vulnerability:</b> {{ multipliers.vulnerabilities.join(', ') }}
+      </span>
+      <span
+        v-if="multipliers.resistances.length"
+        :class="{'mr-2': multipliers.immunities.length}"
+      >
+        <b>Resistance:</b> {{ multipliers.resistances.join(', ') }}
+      </span>
+      <span
+        v-if="multipliers.immunities.length"
+      >
+        <b>Immunity:</b> {{ multipliers.immunities.join(', ') }}
+      </span>
+    </div>
   </v-card>
 </template>
 
@@ -17,11 +36,33 @@
 	import HealthBar from '/imports/ui/properties/components/attributes/HealthBar.vue';
 
 	export default {
+    inject: {
+      context: { default: {} }
+    },
 		components: {
 			HealthBar,
 		},
 		props: {
-			attributes: Array,
+			attributes: {
+        type: Array,
+        required: true
+       },
 		},
+    computed: {
+      multipliers() {
+        let damageMultipliers = this.context.creature.damageMultipliers;
+        let vulnerabilities = [];
+        let resistances = [];
+        let immunities = [];
+        for (let key in damageMultipliers){
+          switch(damageMultipliers[key]){
+            case 2: vulnerabilities.push(key); break;
+            case 0.5: resistances.push(key); break;
+            case 0: immunities.push(key); break;
+          }
+        }
+        return {vulnerabilities, resistances, immunities};
+      }
+    },
 	}
 </script>

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

@@ -11,12 +11,9 @@
       <v-spacer />
     </template>
     <v-card-text class="px-0">
-      <creature-properties-tree
+      <item-list
-        :root="{collection: 'creatureProperties', id: model._id}"
+        :items="items"
-        :filter="{type: {$in: ['container', 'item', 'folder']}}"
+        :parent-ref="{id: model._id, collection: 'creatureProperties'}"
-        :organize="organize"
-        group="inventory"
-        @selected="e => clickProperty(e)"
       />
     </v-card-text>
   </toolbar-card>
@@ -24,16 +21,19 @@
 
 <script>
 import ToolbarCard from '/imports/ui/components/ToolbarCard.vue';
-import CreaturePropertiesTree from '/imports/ui/creature/creatureProperties/CreaturePropertiesTree.vue';
+import ItemList from '/imports/ui/properties/components/inventory/ItemList.vue';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
 export default {
 	components: {
 		ToolbarCard,
-		CreaturePropertiesTree,
+    ItemList,
 	},
 	props: {
-		model: Object,
+		model: {
-		organize: Boolean,
+      type: Object,
+      required: true,
+    },
 	},
 	methods: {
 		clickContainer(_id){
@@ -50,7 +50,20 @@ export default {
 				data: {_id},
 			});
 		},
-	}
+	},
+  meteor: {
+    items(){
+      return getActiveProperties({
+        ancestorId: this.model._id,
+        includeUnequipped: true,
+        filter: {
+          type: {$in: ['item', 'container']},
+          'parent.id': this.model._id,
+          equipped: {$ne: true},
+        },
+      });
+    },
+  }
 };
 </script>
 

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

@@ -0,0 +1,113 @@
+<template lang="html">
+  <v-list
+    two-line
+    dense
+    class="item-list"
+  >
+    <draggable
+      v-model="dataItems"
+      style="min-height: 24px;"
+      :group="`item-list`"
+      ghost-class="ghost"
+      draggable=".item"
+      handle=".handle"
+      :animation="200"
+      @change="change"
+    >
+      <item-list-tile
+        v-for="item in dataItems"
+        :key="item._id"
+        class="item"
+        :data-id="`item-list-tile-${item._id}`"
+        :model="item"
+        @click="clickProperty(item._id)"
+      />
+    </draggable>
+  </v-list>
+</template>
+
+<script>
+import draggable from 'vuedraggable';
+import ItemListTile from '/imports/ui/properties/components/inventory/ItemListTile.vue';
+import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
+import { updateProperty } from '/imports/api/creature/CreatureProperties.js';
+
+export default {
+  components: {
+    draggable,
+    ItemListTile,
+  },
+  props: {
+    items: {
+      type: Array,
+      default: () => [],
+    },
+    parentRef: {
+      type: Object,
+      required: true,
+    },
+    preparingSpells: Boolean,
+    equipment: Boolean,
+  },
+  data(){ return {
+    dataItems: [],
+  }},
+  computed: {
+    levels(){
+      let levels = new Set();
+      this.items.forEach(item => levels.add(item.level));
+      return levels;
+    },
+  },
+  watch: {
+    items(value){
+      this.dataItems = value;
+    }
+  },
+  mounted(){
+    this.dataItems = this.items;
+  },
+  methods: {
+		clickProperty(_id){
+			this.$store.commit('pushDialogStack', {
+				component: 'creature-property-dialog',
+				elementId: `item-list-tile-${_id}`,
+				data: {_id},
+			});
+		},
+    change({added, moved}){
+      let event = added || moved;
+      if (event){
+        // If this item is now adjacent to another, set the order accordingly
+        let order;
+        let before = this.dataItems[event.newIndex - 1];
+        let after = this.dataItems[event.newIndex + 1];
+        if (before && before._id){
+          order = before.order + 0.5;
+        } else if (after && after._id) {
+          order = after.order - 0.5;
+        } else {
+          order = -0.5;
+        }
+        let doc = event.element;
+          organizeDoc.call({
+          docRef: {
+            id: doc._id,
+            collection: 'creatureProperties',
+          },
+          parentRef: this.parentRef,
+          order,
+        });
+        if (doc.type === 'item' && doc.equipped != this.equipment){
+          updateProperty.call({
+            _id: doc._id,
+            path: ['equipped'],
+            value: !!this.equipment,
+          });
+        }
+      }
+      setTimeout(() => this.dataItems = this.items, 0);
+    },
+	}
+}
+</script>

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

@@ -0,0 +1,102 @@
+<template lang="html">
+  <v-list-tile
+    class="item"
+    v-on="hasClickListener ? {click} : {}"
+  >
+    <v-list-tile-avatar class="item-avatar">
+      <property-icon
+        class="mr-2"
+        :model="model"
+        :color="model.color"
+      />
+    </v-list-tile-avatar>
+    <v-list-tile-content>
+      <v-list-tile-title>
+        {{ title }}
+      </v-list-tile-title>
+    </v-list-tile-content>
+    <v-list-tile-action>
+      <increment-button
+        v-if="context.creature && model.showIncrement"
+        icon
+        flat
+        color="primary"
+        :value="model.quantity"
+        @change="changeQuantity"
+      >
+        <v-icon>
+          $vuetify.icons.abacus
+        </v-icon>
+      </increment-button>
+    </v-list-tile-action>
+    <v-list-tile-action>
+      <v-icon
+        style="height: 100%; width: 40px; cursor: move;"
+        class="handle"
+      >
+        drag_indicator
+      </v-icon>
+    </v-list-tile-action>
+  </v-list-tile>
+</template>
+
+<script>
+import treeNodeViewMixin from '/imports/ui/properties/treeNodeViews/treeNodeViewMixin.js';
+import PROPERTIES from '/imports/constants/PROPERTIES.js';
+import { adjustQuantity } from '/imports/api/creature/CreatureProperties.js';
+import IncrementButton from '/imports/ui/components/IncrementButton.vue';
+
+export default {
+  components:{
+    IncrementButton,
+  },
+  mixins: [treeNodeViewMixin],
+  inject: {
+    context: { default: {} }
+  },
+  props: {
+    preparingSpells: Boolean,
+  },
+  computed: {
+    hasClickListener(){
+      return this.$listeners && !!this.$listeners.click;
+    },
+    title(){
+      let model = this.model;
+      if (!model) return;
+      if (model.quantity !== 1){
+        if (model.plural){
+          return `${model.quantity} ${model.plural}`;
+        } else if (model.name){
+          return `${model.quantity} ${model.name}`;
+        }
+      } else if (model.name) {
+        return model.name;
+      }
+      let prop = PROPERTIES[model.type]
+      return prop && prop.name;
+    }
+  },
+  methods: {
+    click(e){
+			this.$emit('click', e);
+		},
+    changeQuantity({type, value}) {
+      adjustQuantity.call({
+        _id: this.model._id,
+        operation: type,
+        value: value
+      });
+    }
+  },
+}
+</script>
+
+<style lang="css" scoped>
+.item-avatar {
+  min-width: 32px;
+}
+.item {
+  background-color: inherit;
+}
+</style>

app/imports/ui/properties/components/spells/SpellList.vue

@@ -0,0 +1,142 @@
+<template lang="html">
+  <v-list
+    two-line
+    dense
+    class="spell-list"
+  >
+    <draggable
+      v-model="computedSpells"
+      style="min-height: 24px;"
+      :group="`spell-list`"
+      ghost-class="ghost"
+      draggable=".item"
+      handle=".handle"
+      :animation="200"
+      @change="change"
+    >
+      <template v-for="spell in computedSpells">
+        <v-subheader
+          v-if="spell.isSubheader"
+          :key="`${spell.level}-header`"
+          class="item"
+        >
+          {{ spell.level === 0 ? 'Cantrips' : `Level ${spell.level}` }}
+        </v-subheader>
+        <spell-list-tile
+          v-else
+          :key="spell._id"
+          class="item"
+          :data-id="`spell-list-tile-${spell._id}`"
+          :model="spell"
+          :preparing-spells="preparingSpells"
+          @click="clickProperty(spell._id)"
+        />
+      </template>
+    </draggable>
+  </v-list>
+</template>
+
+<script>
+import draggable from 'vuedraggable';
+import SpellListTile from '/imports/ui/properties/components/spells/SpellListTile.vue';
+import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
+
+function spellsWithSubheaders(spells = []){
+  let result = [];
+  let lastSpell = undefined;
+  let sortedSpells = [...spells].sort((a, b) => a.level - b.level)
+  sortedSpells.forEach(spell => {
+    if (spell.isSubheader) return;
+    if (!lastSpell || spell.level > lastSpell.level){
+      result.push({
+        isSubheader: true,
+        level: spell.level,
+      });
+    }
+    result.push(spell);
+    lastSpell = spell;
+  });
+  return result;
+}
+
+export default {
+  components: {
+    draggable,
+    SpellListTile,
+  },
+  props: {
+    spells: {
+      type: Array,
+      default: () => [],
+    },
+    parentRef: {
+      type: Object,
+      required: true,
+    },
+    preparingSpells: Boolean,
+  },
+  data(){ return {
+    dataSpells: [],
+  }},
+  computed: {
+    levels(){
+      let levels = new Set();
+      this.spells.forEach(spell => levels.add(spell.level));
+      return levels;
+    },
+    computedSpells: {
+      get(){
+        return spellsWithSubheaders(this.dataSpells);
+      },
+      set(value){
+        this.dataSpells = value;
+      },
+    }
+  },
+  watch: {
+    spells(value){
+      this.dataSpells = spellsWithSubheaders(value);
+    }
+  },
+  mounted(){
+    this.dataSpells = spellsWithSubheaders(this.spells);
+  },
+  methods: {
+		clickProperty(_id){
+			this.$store.commit('pushDialogStack', {
+				component: 'creature-property-dialog',
+				elementId: `spell-list-tile-${_id}`,
+				data: {_id},
+			});
+		},
+    change({added, moved}){
+      let event = added || moved;
+      if (event){
+        // If this spell is now adjacent to another, set the order accordingly
+        let order;
+        let before = this.dataSpells[event.newIndex - 1];
+        let after = this.dataSpells[event.newIndex + 1];
+        if (before && before._id){
+          order = before.order + 0.5;
+        } else if (after && after._id) {
+          order = after.order - 0.5;
+        } else {
+          order = -0.5;
+        }
+        let doc = event.element;
+        organizeDoc.call({
+          docRef: {
+            id: doc._id,
+            collection: 'creatureProperties',
+          },
+          parentRef: this.parentRef,
+          order,
+        });
+      }
+    },
+	}
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/properties/components/spells/SpellListCard.vue

@@ -9,33 +9,104 @@
         {{ model.name }}
       </v-toolbar-title>
       <v-spacer />
+      <v-menu
+        bottom
+        left
+        transition="slide-y-transition"
+        style="margin-right: -12px;"
+      >
+        <template #activator="{ on }">
+          <v-btn
+            icon
+            v-on="on"
+            @click.stop
+          >
+            <v-icon>more_vert</v-icon>
+          </v-btn>
+        </template>
+        <v-list class="pa-2">
+          <v-switch
+            v-model="preparingSpells"
+            class="ma-2"
+            label="Change prepared spells"
+            hide-details
+          />
+        </v-list>
+      </v-menu>
     </template>
-    <v-card-text>
+    <v-expand-transition>
-      <creature-properties-tree
+      <v-card-text
-        :root="{collection: 'creatureProperties', id: model._id}"
+        v-if="preparedError || preparingSpells"
-        :filter="{type: {$in: ['spellList', 'spell', 'folder']}}"
+        :class="{'error--text' : preparedError}"
-        :organize="organize"
+        class="pb-0"
-        group="spells"
+      >
-        @selected="e => clickProperty(e)"
+        {{ numPrepared }}/{{ model.maxPreparedResult }} spells prepared
-      />
+        <v-switch
-    </v-card-text>
+          v-model="preparingSpells"
+          label="Change prepared spells"
+        />
+      </v-card-text>
+    </v-expand-transition>
+    <spell-list
+      :spells="spells"
+      :parent-ref="{id: model._id, collection: 'creatureProperties'}"
+      :preparing-spells="preparingSpells"
+    />
   </toolbar-card>
 </template>
 
 <script>
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
 import ToolbarCard from '/imports/ui/components/ToolbarCard.vue';
-import CreaturePropertiesTree from '/imports/ui/creature/creatureProperties/CreaturePropertiesTree.vue';
+import SpellList from '/imports/ui/properties/components/spells/SpellList.vue';
+import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
 
 export default {
 	components: {
 		ToolbarCard,
-		CreaturePropertiesTree,
+    SpellList,
 	},
 	props: {
-		model: Object,
+		model: {
+      type: Object,
+      required: true,
+    },
 		organize: Boolean,
 	},
+  data(){ return {
+    preparingSpells: false,
+  }},
+  meteor: {
+    spells(){
+      return getActiveProperties({
+        ancestorId: this.model._id,
+        filter: {
+          type: 'spell',
+        },
+        options: {
+          sort: {
+            level: 1,
+            order: 1,
+          },
+        },
+        includeUnprepared: this.preparingSpells,
+      });
+    },
+    numPrepared(){
+      return getActiveProperties({
+        ancestorId: this.model._id,
+        filter: {
+          type: 'spell',
+          prepared: true,
+          alwaysPrepared: {$ne: true},
+        },
+      }).length;
+    },
+    preparedError(){
+      let numPrepared = this.numPrepared;
+      let maxPrepared = this.model.maxPreparedResult;
+      return numPrepared !== maxPrepared
+    },
+  },
 	methods: {
 		clickSpellList(_id){
 			this.$store.commit('pushDialogStack', {
@@ -44,13 +115,6 @@ export default {
 				data: {_id},
 			});
 		},
-		clickProperty(_id){
-			this.$store.commit('pushDialogStack', {
-				component: 'creature-property-dialog',
-				elementId: `tree-node-${_id}`,
-				data: {_id},
-			});
-		},
 	}
 };
 </script>

app/imports/ui/properties/components/spells/SpellListTile.vue

@@ -0,0 +1,85 @@
+<template lang="html">
+  <v-list-tile
+    class="spell"
+    v-on="hasClickListener ? {click} : {}"
+  >
+    <v-list-tile-avatar class="spell-avatar">
+      <property-icon
+        class="mr-2"
+        :model="model"
+        :color="model.color"
+      />
+    </v-list-tile-avatar>
+    <v-list-tile-content>
+      <v-list-tile-title>
+        {{ title }}
+      </v-list-tile-title>
+      <v-list-tile-sub-title v-if="components">
+        {{ components }}
+      </v-list-tile-sub-title>
+    </v-list-tile-content>
+    <v-list-tile-action>
+      <smart-checkbox
+        v-if="preparingSpells"
+        :value="model.prepared || model.alwaysPrepared"
+        :disabled="model.alwaysPrepared"
+        @click.native.stop="() => {}"
+        @change="setPrepared"
+      />
+      <v-icon
+        v-else
+        style="height: 100%; width: 40px; cursor: move;"
+        class="handle"
+      >
+        drag_indicator
+      </v-icon>
+    </v-list-tile-action>
+  </v-list-tile>
+</template>
+
+<script>
+import treeNodeViewMixin from '/imports/ui/properties/treeNodeViews/treeNodeViewMixin.js';
+import {updateProperty} from '/imports/api/creature/CreatureProperties.js';
+
+export default {
+  mixins: [treeNodeViewMixin],
+  props: {
+    preparingSpells: Boolean,
+  },
+  computed: {
+    hasClickListener(){
+      return this.$listeners && !!this.$listeners.click;
+    },
+    components(){
+      let components = [];
+      if (this.model.ritual) components.push('R');
+      if (this.model.concentration) components.push('C');
+      if (this.model.verbal) components.push('V');
+      if (this.model.somatic) components.push('S');
+      if (this.model.material) components.push(`M (${this.model.material})`);
+      return components.join(', ');
+    },
+  },
+  methods: {
+    click(e){
+			this.$emit('click', e);
+		},
+    setPrepared(val, ack){
+      updateProperty.call({
+        _id: this.model._id,
+        path: ['prepared'],
+        value: val
+      }, ack);
+    }
+  },
+}
+</script>
+
+<style lang="css" scoped>
+.spell-avatar {
+  min-width: 32px;
+}
+.spell {
+  background-color: inherit;
+}
+</style>

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

@@ -1,5 +1,13 @@
 <template lang="html">
   <div :class="attackForm ? 'attack-form' : 'action-form'">
+    <div class="layout column align-center">
+      <icon-picker
+        label="Icon"
+        :value="model.icon"
+        :error-messages="errors.icon"
+        @change="change('icon', ...arguments)"
+      />
+    </div>
     <text-field
       ref="focusFirst"
       label="Name"
@@ -23,8 +31,16 @@
       :error-messages="errors.rollBonus"
       @change="change('rollBonus', ...arguments)"
     />
+    <text-area
+      label="Summary"
+      hint="This will appear in the action card in the character sheet"
+      :value="model.summary"
+      :error-messages="errors.summary"
+      @change="change('summary', ...arguments)"
+    />
     <text-area
       label="Description"
+      hint="The rest of the description that doesn't fit in the summary goes here"
       :value="model.description"
       :error-messages="errors.description"
       @change="change('description', ...arguments)"