Added search to library tree views

README.md

@@ -66,5 +66,24 @@ You should see this:
 => App running at: http://localhost:3000/
 ```
 
+Environmental Variables
+-----------------------
+
+```
+MAIL_URL=smtp://<your smtp mail url>
+METEOR_SETTINGS={ "public": { "environment": "production", "patreon": { "clientId": "<your patreon client ID>", "campaignId": "<your campaign id>" } }, "patreon": { "clientSecret": "<your client secret>", "creatorAccessToken": "<your creator access token>" } }
+MONGO_OPLOG_URL=mongodb+srv://<your url for the oplog account of your mongo database>
+MONGO_URL=mongodb+srv://<your url for the read/write account of your mongo database>
+NPM_CONFIG_PRODUCTION=true
+PROJECT_DIR=app
+ROOT_URL=https://<url of your DiceCloud instance>
+DEFAULT_LIBRARIES=<comma separated list of library ids that will be subscribed by default: "abc123,def456">
+```
+
+To disable Patreon features and unlock all paid restrictions for all users of your deployment, replace
+`"patreon": { "clientId": ... }"` with `"disablePatreon": true` in the public key of the METEOR_SETTINGS environment variable.
+
+Alternatively run `meteor run --settings exampleMeteorSettings.json` to start the app with the example settings that disable Patreon by default.
+
 Now, visiting [](http://localhost:3000/) should show you an empty instance of
 DiceCloud running.

app/.meteor/packages

@@ -3,42 +3,42 @@
 # 'meteor add' and 'meteor remove' will edit this file for you,
 # but you can also edit it by hand.
 
-accounts-password@1.7.0
-random@1.2.0
+accounts-password
+random
 dburles:collection-helpers
-reactive-var@1.0.11
-underscore@1.0.10
+reactive-var
+underscore
 momentjs:moment
 dburles:mongo-collection-instances
-accounts-google@1.3.3
-email@2.0.0
+accounts-google
+email
 meteorhacks:subs-manager
 chuangbo:marked
-meteor-base@1.4.0
-mobile-experience@1.1.0
-mongo@1.10.1
-session@1.2.0
-tracker@1.2.0
-logging@1.2.0
-reload@1.3.1
-ejson@1.1.1
-check@1.3.1
-standard-minifier-js@2.6.0
-shell-server@0.5.0
+meteor-base
+mobile-experience
+mongo
+session
+tracker
+logging
+reload
+ejson
+check
+standard-minifier-js
+shell-server
 templates:array
-ecmascript@0.15.0
-es5-shim@4.8.0
-reactive-dict@1.3.0
+ecmascript
+es5-shim
+reactive-dict
 percolate:synced-cron
 ongoworks:speakingurl
-service-configuration@1.0.11
-dynamic-import@0.6.0
-ddp-rate-limiter@1.0.9
-rate-limit@1.0.9
+service-configuration
+dynamic-import
+ddp-rate-limiter
+rate-limit
 mdg:validated-method
 akryum:vue-router2
 static-html
-aldeed:collection2@3.0.0
+aldeed:collection2
 aldeed:schema-index
 zer0th:meteor-vuetify-loader
 accounts-patreon

app/.meteor/release

@@ -1 +1 @@
-METEOR@2.1
+METEOR@2.2.1

app/.meteor/versions

@@ -1,7 +1,7 @@
-accounts-base@1.8.0
+accounts-base@1.9.0
 accounts-google@1.3.3
 accounts-oauth@1.2.0
-accounts-password@1.7.0
+accounts-password@1.7.1
 accounts-patreon@0.1.0
 akryum:npm-check@0.1.2
 akryum:vue-component@0.15.2
@@ -9,19 +9,19 @@ akryum:vue-component-dev-client@0.4.7
 akryum:vue-component-dev-server@0.1.4
 akryum:vue-router2@0.2.3
 akryum:vue-sass@0.1.2
-aldeed:collection2@3.2.1
+aldeed:collection2@3.4.1
 aldeed:schema-index@3.0.0
 allow-deny@1.1.0
 autoupdate@1.7.0
-babel-compiler@7.6.0
+babel-compiler@7.6.2
 babel-runtime@1.5.0
 base64@1.0.12
 binary-heap@1.0.11
-blaze-tools@1.0.10
+blaze-tools@1.1.2
 boilerplate-generator@1.7.1
-bozhao:link-accounts@2.3.2
+bozhao:link-accounts@2.4.0
 caching-compiler@1.2.2
-caching-html-compiler@1.1.3
+caching-html-compiler@1.2.1
 callback-hook@1.3.0
 check@1.3.1
 chuangbo:marked@0.3.5_1
@@ -30,17 +30,17 @@ coffeescript-compiler@2.4.1
 dburles:collection-helpers@1.1.0
 dburles:mongo-collection-instances@0.3.5
 ddp@1.4.0
-ddp-client@2.4.0
+ddp-client@2.4.1
 ddp-common@1.4.0
 ddp-rate-limiter@1.0.9
-ddp-server@2.3.2
+ddp-server@2.3.3
 deps@1.0.12
 diff-sequence@1.1.1
 dynamic-import@0.6.0
-ecmascript@0.15.0
+ecmascript@0.15.1
 ecmascript-runtime@0.7.0
-ecmascript-runtime-client@0.11.0
-ecmascript-runtime-server@0.10.0
+ecmascript-runtime-client@0.11.1
+ecmascript-runtime-server@0.10.1
 ejson@1.1.1
 email@2.0.0
 es5-shim@4.8.0
@@ -48,13 +48,13 @@ fetch@0.1.1
 geojson-utils@1.0.10
 google-oauth@1.3.0
 hot-code-push@1.0.4
-html-tools@1.0.11
-htmljs@1.0.11
-http@1.4.3
-id-map@1.1.0
+html-tools@1.1.2
+htmljs@1.1.1
+http@1.4.4
+id-map@1.1.1
 inter-process-messaging@0.1.1
 lai:collection-extensions@0.2.1_1
-launch-screen@1.2.0
+launch-screen@1.2.1
 livedata@1.0.18
 localstorage@1.2.0
 logging@1.2.0
@@ -63,21 +63,21 @@ meteor@1.9.3
 meteor-base@1.4.0
 meteorhacks:subs-manager@1.6.4
 mikowals:batch-insert@1.2.0
-minifier-css@1.5.3
-minifier-js@2.6.0
-minimongo@1.6.1
+minifier-css@1.5.4
+minifier-js@2.6.1
+minimongo@1.6.2
 mobile-experience@1.1.0
 mobile-status-bar@1.1.0
 modern-browsers@0.1.5
 modules@0.16.0
 modules-runtime@0.12.0
 momentjs:moment@2.29.1
-mongo@1.10.1
+mongo@1.11.1
 mongo-decimal@0.1.2
 mongo-dev-server@1.1.0
-mongo-id@1.0.7
-npm-bcrypt@0.9.3
-npm-mongo@3.8.1
+mongo-id@1.0.8
+npm-bcrypt@0.9.4
+npm-mongo@3.9.0
 oauth@1.3.2
 oauth2@1.3.0
 ongoworks:speakingurl@9.0.0
@@ -98,7 +98,7 @@ promise@0.11.2
 raix:eventemitter@1.0.0
 random@1.2.0
 rate-limit@1.0.9
-react-fast-refresh@0.1.0
+react-fast-refresh@0.1.1
 reactive-dict@1.3.0
 reactive-var@1.0.11
 reload@1.3.1
@@ -112,17 +112,18 @@ 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.1
-spacebars-compiler@1.1.3
+socket-stream-client@0.3.3
+spacebars-compiler@1.3.0
 srp@1.1.0
-standard-minifier-js@2.6.0
-static-html@1.2.2
+standard-minifier-js@2.6.1
+static-html@1.3.2
 templates:array@1.0.3
-templating-tools@1.1.2
-tmeasday:check-npm-versions@0.3.2
+templating-tools@1.2.1
+tmeasday:check-npm-versions@1.0.2
 tracker@1.2.0
+typescript@4.2.2
 underscore@1.0.10
-url@1.3.1
-webapp@1.10.0
+url@1.3.2
+webapp@1.10.1
 webapp-hashing@1.1.0
 zer0th:meteor-vuetify-loader@0.1.30

app/client/head.html

@@ -1,5 +1,6 @@
 <head>
-  <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900|Material+Icons" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900" rel="stylesheet">
+  <link href="https://cdn.jsdelivr.net/npm/@mdi/font@5.x/css/materialdesignicons.min.css" rel="stylesheet">
   <meta name="viewport" content="width=device-width initial-scale=1.0, user-scalable=no">
 	<meta name="mobile-web-app-capable" content="yes">
 	<meta name="apple-mobile-web-app-capable" content="yes">

app/client/main.js

@@ -1,3 +1,4 @@
 import '/imports/ui/vueSetup.js';
 import '/imports/ui/styles/stylesIndex.js';
 import '/imports/client/config.js';
+import '/imports/client/serviceWorker.js';

app/exampleMeteorSettings.json

@@ -0,0 +1,6 @@
+{
+  "public": {
+    "environment": "production",
+    "disablePatreon": true
+  }
+}

app/imports/api/creature/Parties.js

@@ -1,28 +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,
-	},
-	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/applyProperties.js

@@ -62,6 +62,7 @@ function applyPropertyAndWalkChildren({prop, children, targets, ...options}){
 export default function applyProperties({ forest, targets, ...options}){
   forest.forEach(node => {
     let prop = node.node;
+    options.actionContext[`#${prop.type}`] = prop;
     let children = node.children;
     if (shouldSplit(prop) && targets.length){
       targets.forEach(target => {

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

@@ -2,12 +2,13 @@ import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import { doActionWork } from '/imports/api/creature/actions/doAction.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
 
 const castSpellWithSlot = new ValidatedMethod({
   name: 'creatureProperties.castSpellWithSlot',
@@ -61,9 +62,11 @@ const castSpellWithSlot = new ValidatedMethod({
         value: 1,
       });
     }
+    let actionContext = getAncestorContext(spell);
+
 		doActionWork({
       action: spell,
-      context: {slotLevel},
+      actionContext: {slotLevel, ...actionContext},
       creature,
       targets: target ? [target] : [],
       method: this,

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

@@ -2,15 +2,16 @@ import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import { nodesToTree } from '/imports/api/parenting/parenting.js';
+import nodesToTree from '/imports/api/parenting/nodesToTree.js';
 import applyProperties from '/imports/api/creature/actions/applyProperties.js';
 import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
+import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
 
 const doAction = new ValidatedMethod({
   name: 'creatureProperties.doAction',
@@ -36,6 +37,10 @@ const doAction = new ValidatedMethod({
     let action = CreatureProperties.findOne(actionId);
 		// Check permissions
     let creature = getRootCreatureAncestor(action);
+
+    // Build ancestor context
+    let actionContext = getAncestorContext(action);
+
     assertEditPermission(creature, this.userId);
     let targets = [];
     targetIds.forEach(targetId => {
@@ -43,7 +48,7 @@ const doAction = new ValidatedMethod({
       assertEditPermission(target, this.userId);
       targets.push(target);
     });
-		doActionWork({action, creature, targets, method: this});
+		doActionWork({action, creature, targets, actionContext, method: this});
 
     // The acting creature might have used ammo
     recomputeInventory(creature._id);
@@ -64,7 +69,7 @@ export function doActionWork({
   action,
   creature,
   targets,
-  context = {},
+  actionContext = {},
   method
 }){
   // Create the log
@@ -83,7 +88,7 @@ export function doActionWork({
   }];
   applyProperties({
     forest: startingForest,
-    actionContext: context,
+    actionContext,
     creature,
     targets,
     log,

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

@@ -1,8 +1,8 @@
 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 { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import roll from '/imports/parser/roll.js';
 
 const doCheck = new ValidatedMethod({

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

@@ -0,0 +1,15 @@
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+
+export default function getAncestorContext(prop){
+  // Build ancestor context
+  const actionContext = {};
+  let ancestorIds = prop.ancestors.map(ref => ref.id);
+  CreatureProperties.find({
+    _id: {$in: ancestorIds}
+  }, {
+    sort: {order: 1},
+  }).forEach(ancestor => {
+    actionContext[`#${ancestor.type}`] = ancestor;
+  });
+  return actionContext;
+}

app/imports/api/creature/archive/ArchivedCreatures.js

@@ -0,0 +1,57 @@
+import SimpleSchema from 'simpl-schema';
+
+// Archived creatures is an immutable collection of creatures that are no longer
+// in use and can be safely archived by the mongoDB hosting service.
+// It keeps the working datasets like creatureProperties much smaller
+// than they would otherwise be.
+let ArchivedCreatures = new Mongo.Collection('archivedCreatures');
+
+// We use blackbox objects for everything:
+// - saves time checking every object against a schema
+// - doesn't accidentaly create indices defined in subschemas
+// - The objects we are archiving have already been checked against their
+//   own schemas
+let ArchivedCreatureSchema = new SimpleSchema({
+  owner: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+    // The primary index on this collection
+		index: 1,
+	},
+  archiveDate: {
+    type: Date,
+    // Indexed so the archiving system can archive documents when they
+    // get to a certain age
+    index: 1,
+  },
+	creature: {
+    type: Object,
+    blackbox: true,
+  },
+  properties: {
+    type: Array,
+  },
+  'properties.$': {
+    type: Object,
+    blackbox: true,
+  },
+  experiences: {
+    type: Array,
+  },
+  'experiences.$': {
+    type: Object,
+    blackbox: true,
+  },
+  logs: {
+    type: Array,
+  },
+  'logs.$': {
+    type: Object,
+    blackbox: true,
+  },
+});
+
+ArchivedCreatures.attachSchema(ArchivedCreatureSchema);
+
+import '/imports/api/creature/archive/methods/index.js';
+export default ArchivedCreatures;

app/imports/api/creature/archive/methods/archiveCreatures.js

@@ -0,0 +1,66 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
+import Experiences from '/imports/api/creature/experience/Experiences.js';
+import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
+import ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
+
+function archiveCreature(creatureId){
+  // Build the archive document
+  const creature = Creatures.findOne(creatureId);
+  const properties = CreatureProperties.find({'ancestors.id': creatureId}).fetch();
+  const experiences = Experiences.find({creatureId}).fetch();
+  const logs = CreatureLogs.find({creatureId}).fetch();
+  let archiveCreature = {
+    owner: creature.owner,
+    archiveDate: new Date(),
+    creature,
+    properties,
+    experiences,
+    logs,
+  };
+
+  // Insert it
+  let id = ArchivedCreatures.insert(archiveCreature);
+
+  // Remove the original creature
+  removeCreatureWork(creatureId);
+
+  return id;
+}
+
+const archiveCreatures = new ValidatedMethod({
+  name: 'Creatures.methods.archiveCreatures',
+  validate: new SimpleSchema({
+    creatureIds: {
+      type: Array,
+      max: 10,
+    },
+    'creatureIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 1,
+    timeInterval: 5000,
+  },
+  run({creatureIds}) {
+    for (let id of creatureIds){
+      assertOwnership(id, this.userId)
+    }
+    let archivedIds = [];
+    for (let id of creatureIds){
+      let archivedId = archiveCreature(id);
+      archivedIds.push(archivedId);
+    }
+    return archivedIds;
+  },
+});
+
+export default archiveCreatures;

app/imports/api/creature/archive/methods/index.js

@@ -0,0 +1,2 @@
+import '/imports/api/creature/archive/methods/archiveCreatures.js';
+import '/imports/api/creature/archive/methods/restoreCreatures.js';

app/imports/api/creature/archive/methods/restoreCreatures.js

@@ -0,0 +1,77 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertOwnership } from '/imports/api/sharing/sharingPermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
+import Experiences from '/imports/api/creature/experience/Experiences.js';
+import ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
+import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
+
+function restoreCreature(archiveId){
+  // Get the archive
+  const archivedCreature = ArchivedCreatures.findOne(archiveId);
+
+  // Insert the creature sub documents
+  // They still have their original _id's
+  Creatures.insert(archivedCreature.creature);
+  try {
+    // Add all the properties
+    if (archivedCreature.properties && archivedCreature.properties.length){
+      CreatureProperties.batchInsert(archivedCreature.properties);
+    }
+    if (archivedCreature.experiences && archivedCreature.experiences.length){
+      Experiences.batchInsert(archivedCreature.experiences);
+    }
+    if (archivedCreature.logs && archivedCreature.logs.length){
+      CreatureLogs.batchInsert(archivedCreature.logs);
+    }
+    // Remove the archived creature
+    ArchivedCreatures.remove(archiveId);
+  } catch (e) {
+    // If the above fails, delete the inserted creature
+    removeCreatureWork(archivedCreature.creature._id);
+    throw e;
+  }
+
+  // Do not recompute. The creature was in a computed and ordered state when
+  // we archived it, just restore everything as-is
+
+  return archivedCreature.creature._id;
+}
+
+const restoreCreatures = new ValidatedMethod({
+  name: 'Creatures.methods.restoreCreatures',
+  validate: new SimpleSchema({
+    archiveIds: {
+      type: Array,
+      max: 10,
+    },
+    'archiveIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 1,
+    timeInterval: 5000,
+  },
+  run({archiveIds}) {
+    for (let id of archiveIds){
+      let archivedCreature = ArchivedCreatures.findOne(id, {
+        fields: {owner: 1}
+      });
+      assertOwnership(archivedCreature, this.userId)
+    }
+    let creatureIds = [];
+    for (let id of archiveIds){
+      let creatureId = restoreCreature(id);
+      creatureIds.push(creatureId);
+    }
+    return creatureIds;
+  },
+});
+
+export default restoreCreatures;

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

@@ -104,31 +104,10 @@ export default class ComputationMemo {
     let variableName = prop.variableName;
     if (!variableName) return;
     let existingStat = this.statsByVariableName[variableName];
+    prop = this.registerProperty(prop);
     if (existingStat){
       existingStat.computationDetails.idsOfSameName.push(prop._id);
-      this.originalPropsById[prop._id] = cloneDeep(prop);
-      if (prop.baseValueCalculation){
-        existingStat.computationDetails.effects.push({
-          operation: 'base',
-          calculation: prop.baseValueCalculation,
-          stats: [variableName],
-          computationDetails: propDetailsByType.effect(),
-          statBase: true,
-          dependencies: [],
-        });
-      }
-      if (prop.baseProficiency){
-        existingStat.computationDetails.proficiencies.push({
-          value: prop.baseProficiency,
-          stats: [variableName],
-          computationDetails: propDetailsByType.proficiency(),
-          type: 'proficiency',
-          statBase: true,
-          dependencies: [],
-        });
-      }
     } else {
-      prop = this.registerProperty(prop);
       this.statsById[prop._id] = prop;
       this.statsByVariableName[variableName] = prop;
       if (
@@ -190,7 +169,9 @@ export default class ComputationMemo {
     prop = this.registerProperty(prop);
     let targets = this.getProficiencyTargets(prop);
     targets.forEach(target => {
-      target.computationDetails.proficiencies.push(prop);
+      if(target.computationDetails.proficiencies){
+        target.computationDetails.proficiencies.push(prop);
+      }
     });
   }
   getProficiencyTargets(prop){
@@ -267,6 +248,7 @@ const propDetailsByType = {
       computed: false,
       busyComputing: false,
       effects: [],
+      proficiencies: [],
       toggleAncestors: [],
       idsOfSameName: [],
     };

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

@@ -1,31 +1,6 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import { union } from 'lodash';
-
 export default class EffectAggregator{
-  constructor(stat, memo){
-    delete this.baseValueErrors;
-    if (stat.baseValueCalculation){
-      let {
-        result,
-        context,
-        dependencies
-      } = evaluateCalculation({
-        string: stat.baseValueCalculation,
-        prop: stat,
-        memo
-      });
-      this.statBaseValue = +result.value;
-      stat.dependencies = union(
-        stat.dependencies,
-        dependencies,
-      );
-      if (context.errors.length){
-        this.baseValueErrors = context.errors;
-      }
-      this.base = this.statBaseValue;
-    } else {
-      this.base = 0;
-    }
+  constructor(){
+    this.base = undefined;
     this.add = 0;
     this.mul = 1;
     this.min = Number.NEGATIVE_INFINITY;
@@ -45,10 +20,11 @@ export default class EffectAggregator{
     switch(effect.operation){
       case 'base':
         // Take the largest base value
-        this.base = result > this.base ? result : this.base;
-        if (effect.statBase){
-          if (this.statBaseValue === undefined || result > this.statBaseValue){
-            this.statBaseValue = result;
+        if (Number.isFinite(result)){
+          if(Number.isFinite(this.base)){
+            this.base = Math.max(this.base, result);
+          } else {
+            this.base = result;
           }
         }
         break;

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

@@ -1,6 +1,7 @@
 import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
+import computeProficiency from '/imports/api/creature/computation/engine/computeProficiency.js';
 import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
+import stripFloatingPointOddities from '/imports/ui/utility/stripFloatingPointOddities.js';
 import { union } from 'lodash';
 
 export default function combineStat(stat, aggregator, memo){
@@ -14,7 +15,15 @@ export default function combineStat(stat, aggregator, memo){
 }
 
 function getAggregatorResult(stat, aggregator){
-  let result = (aggregator.base + aggregator.add) * aggregator.mul;
+  let base;
+  if (!Number.isFinite(aggregator.base)){
+    base = stat.baseValue || 0;
+  } else if (!Number.isFinite(stat.baseValue)){
+    base = aggregator.base || 0;
+  } else {
+    base = Math.max(aggregator.base, stat.baseValue);
+  }
+  let result = (base + aggregator.add) * aggregator.mul;
   if (result < aggregator.min) {
     result = aggregator.min;
   }
@@ -26,14 +35,14 @@ function getAggregatorResult(stat, aggregator){
   }
   if (!stat.decimal && Number.isFinite(result)){
     result = Math.floor(result);
+  } else if (Number.isFinite(result)){
+    result = stripFloatingPointOddities(result);
   }
   return result;
 }
 
 function combineAttribute(stat, aggregator, memo){
   stat.value = getAggregatorResult(stat, aggregator);
-  stat.baseValue = aggregator.statBaseValue;
-  stat.baseValueErrors = aggregator.baseValueErrors;
   if (stat.attributeType === 'spellSlot'){
     let {
       result,
@@ -78,9 +87,7 @@ function combineSkill(stat, aggregator, memo){
   // Skills are based on some ability Modifier
   let ability = stat.ability && memo.statsByVariableName[stat.ability]
   if (stat.ability && ability){
-    if (!ability.computationDetails.computed){
-      computeStat(ability, memo);
-    }
+    computeStat(ability, memo);
     stat.abilityMod = ability.modifier;
     stat.dependencies = union(
       stat.dependencies,
@@ -91,10 +98,10 @@ function combineSkill(stat, aggregator, memo){
     stat.abilityMod = 0;
   }
   // Combine all the child proficiencies
-  stat.proficiency = stat.baseProficiency || 0;
+  stat.proficiency = 0;
   for (let i in stat.computationDetails.proficiencies){
     let prof = stat.computationDetails.proficiencies[i];
-    applyToggles(prof, memo);
+    computeProficiency(prof, memo);
     if (
       !prof.deactivatedByToggle &&
       prof.value > stat.proficiency
@@ -111,6 +118,14 @@ function combineSkill(stat, aggregator, memo){
   let profBonusStat = memo.statsByVariableName['proficiencyBonus'];
   let profBonus = profBonusStat && profBonusStat.value;
 
+  if (profBonusStat){
+    stat.dependencies = union(
+      stat.dependencies,
+      [profBonusStat._id],
+      profBonusStat.dependencies,
+    );
+  }
+
   if (typeof profBonus !== 'number' && memo.statsByVariableName['level']){
     let levelProp = memo.statsByVariableName['level'];
     let level = levelProp.value;
@@ -121,20 +136,19 @@ function combineSkill(stat, aggregator, memo){
     if (levelProp.dependencies){
       stat.dependencies = union(stat.dependencies, levelProp.dependencies);
     }
-  } else {
-    stat.dependencies = union(
-      stat.dependencies,
-      [profBonusStat._id],
-      profBonusStat.dependencies,
-    );
   }
+
   // Multiply the proficiency bonus by the actual proficiency
-  profBonus *= stat.proficiency;
-  // Base value
-  stat.baseValue = aggregator.statBaseValue;
-  stat.baseValueErrors = aggregator.baseValueErrors;
+  if(stat.proficiency === 0.49){
+    // Round down proficiency bonus in the special case
+    profBonus = Math.floor(profBonus * 0.5);
+  } else {
+    profBonus = Math.ceil(profBonus * stat.proficiency);
+  }
+
   // Combine everything to get the final result
-  let result = (aggregator.base + stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
+  let base = aggregator.base || 0;
+  let result = (base + stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
   if (result < aggregator.min) result = aggregator.min;
   if (result > aggregator.max) result = aggregator.max;
   if (aggregator.set !== undefined) {

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

@@ -0,0 +1,23 @@
+import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
+
+export default function computeEffect(proficiency, memo){
+  if (proficiency.computationDetails.computed) return;
+  if (proficiency.computationDetails.busyComputing){
+    // Trying to compute this proficiency again while it is already computing.
+    // We must be in a dependency loop.
+    proficiency.computationDetails.computed = true;
+    proficiency.result = NaN;
+    proficiency.computationDetails.busyComputing = false;
+    proficiency.computationDetails.error = 'dependencyLoop';
+    if (Meteor.isClient) console.warn('dependencyLoop', proficiency);
+    return;
+  }
+  // Before doing any work, mark this proficiency as busy
+  proficiency.computationDetails.busyComputing = true;
+
+  // Apply any toggles
+  applyToggles(proficiency, memo);
+
+  proficiency.computationDetails.computed = true;
+  proficiency.computationDetails.busyComputing = false;
+}

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

@@ -1,8 +1,9 @@
 import combineStat from '/imports/api/creature/computation/engine/combineStat.js';
 import computeEffect from '/imports/api/creature/computation/engine/computeEffect.js';
 import EffectAggregator from '/imports/api/creature/computation/engine/EffectAggregator.js';
+import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
 import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { each, union } from 'lodash';
+import { each, union, without } from 'lodash';
 
 export default function computeStat(stat, memo){
   // If the stat is already computed, skip it
@@ -19,29 +20,143 @@ export default function computeStat(stat, memo){
   }
   // Before doing any work, mark this stat as busy
   stat.computationDetails.busyComputing = true;
-  // Apply any toggles
-  applyToggles(stat, memo);
+
+  let effects = stat.computationDetails.effects || [];
+  let proficiencies = stat.computationDetails.proficiencies || [];
+
+  // Get references to all the stats that share the variable name
+  let sameNameStats
+
+  if (stat.computationDetails.idsOfSameName){
+    sameNameStats = stat.computationDetails.idsOfSameName.map(
+      id => memo.propsById[id]
+    );
+  } else {
+    sameNameStats = [];
+  }
+
+  let allStats = [stat, ...sameNameStats];
+
+  // Decide which stat is the last active stat
+  // The last active stat is considered the cannonical stat
+  let lastActiveStat;
+  allStats.forEach(candidateStat => {
+    applyToggles(candidateStat, memo);
+    if (!candidateStat.inactive) lastActiveStat = candidateStat;
+    candidateStat.overridden = undefined;
+  });
+  if (!lastActiveStat){
+    delete memo.statsByVariableName[stat.variableName];
+    return;
+  }
+  // Make sure the active stat has all the effects and proficiencies
+  lastActiveStat.computationDetails.effects = effects;
+  lastActiveStat.computationDetails.proficiencies = proficiencies;
+
+  // Update the memo's stat with the chosen stat
+  memo.statsByVariableName[stat.variableName] = lastActiveStat;
+
+  // Recreate list of the non-cannonical stats
+  sameNameStats = without(allStats, lastActiveStat);
+
+  sameNameStats.forEach(statInstance => {
+    // Mark the non-cannonical stats as overridden
+    statInstance.overridden = true;
+
+    // Apply the cannonical damage
+    statInstance.damage = lastActiveStat.damage;
+  });
+
+  let baseDependencies = [];
+  allStats.forEach(statInstance => {
+    // Add this stat and its deps to the dependencies
+    baseDependencies = union(
+      baseDependencies,
+      [statInstance._id],
+      statInstance.dependencies,
+    );
+
+    // Apply all the base proficiencies
+    if (statInstance.baseProficiency && !statInstance.inactive){
+      proficiencies.push({
+        value: statInstance.baseProficiency,
+        stats: [statInstance.variableName],
+        type: 'proficiency',
+        dependencies: statInstance.overridden ?
+          union(statInstance.dependencies, [statInstance._id]) :
+          [],
+        computationDetails: {
+          computed: true,
+        }
+      });
+    }
+
+    // Compute each active stat's baseValue calculation and apply it
+    if (!statInstance.inactive) {
+      delete statInstance.baseValueErrors;
+      let {
+        result,
+        context,
+        dependencies
+      } = evaluateCalculation({
+        string: statInstance.baseValueCalculation,
+        prop: statInstance,
+        memo
+      });
+      result.value = +result.value;
+      if (!isNaN(result.value)){
+        statInstance.baseValue = result.value;
+      } else {
+        statInstance.baseValue = undefined;
+      }
+      statInstance.dependencies = union(statInstance.dependencies, dependencies);
+      if (context.errors.length){
+        statInstance.baseValueErrors = context.errors;
+      }
+      // Apply all the base values
+      if (Number.isFinite(statInstance.baseValue)){
+        effects.push({
+          operation: 'base',
+          calculation: statInstance.baseValueCalculation,
+          result: statInstance.baseValue,
+          stats: [statInstance.variableName],
+          dependencies: statInstance.overridden ?
+          union(statInstance.dependencies, [statInstance._id]) :
+          [],
+          computationDetails: {
+            computed: true,
+          },
+        });
+      }
+    }
+  });
 
   // Compute and aggregate all the effects
-  let aggregator = new EffectAggregator(stat, memo)
-  each(stat.computationDetails.effects, (effect) => {
+  let aggregator = new EffectAggregator();
+  let effectDeps = [];
+  each(effects, (effect) => {
+    // Compute
     computeEffect(effect, memo);
     if (effect.deactivatedByToggle) return;
-    if (effect._id){
-      stat.dependencies = union(
-        stat.dependencies,
-        [effect._id]
-      );
-    }
-    stat.dependencies = union(
-      stat.dependencies,
-      effect.dependencies
-    )
+
+    // dependencies
+    if (effect._id) effectDeps = union(effectDeps, [effect._id]);
+    effectDeps = union(effectDeps, effect.dependencies);
+
+    // Add computed effect to aggregator
     aggregator.addEffect(effect);
   });
-  // Conglomerate all the effects to compute the final stat values
-  combineStat(stat, aggregator, memo);
-  // Mark the attribute as computed
-  stat.computationDetails.computed = true;
-  stat.computationDetails.busyComputing = false;
+
+  // Combine the effects into the stats
+  allStats.forEach(statInstance => {
+    // Conglomerate all the effects to compute the final stat values
+    combineStat(statInstance, aggregator, memo);
+    // Mark the stats as computed
+    statInstance.computationDetails.computed = true;
+    statInstance.computationDetails.busyComputing = false;
+    // Only the active stat instance depeneds on the effects
+    if (!statInstance.overridden){
+      statInstance.dependencies = union(statInstance.dependencies, effectDeps);
+    }
+  });
 }

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

@@ -12,29 +12,22 @@ export default function writeAlteredProperties(memo){
       console.warn('No schema for ' + changed.type);
       return;
     }
-    let extraIds = changed.computationDetails.idsOfSameName;
-    let ids;
-    if (extraIds && extraIds.length){
-      ids = [changed._id, ...extraIds];
-    } else {
-      ids = [changed._id];
+    let id = changed._id;
+    let op = undefined;
+    let original = memo.originalPropsById[id];
+    let keys = [
+      'dependencies',
+      'inactive',
+      'deactivatedBySelf',
+      'deactivatedByAncestor',
+      'deactivatedByToggle',
+      'damage',
+      ...schema.objectKeys(),
+    ];
+    op = addChangedKeysToOp(op, keys, original, changed);
+    if (op){
+      bulkWriteOperations.push(op);
     }
-    ids.forEach(id => {
-      let op = undefined;
-      let original = memo.originalPropsById[id];
-      let keys = [
-        'dependencies',
-        'inactive',
-        'deactivatedBySelf',
-        'deactivatedByAncestor',
-        'deactivatedByToggle',
-        ...schema.objectKeys(),
-      ];
-      op = addChangedKeysToOp(op, keys, original, changed);
-      if (op){
-        bulkWriteOperations.push(op);
-      }
-    });
   });
   writePropertiesSequentially(bulkWriteOperations);
 }

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

@@ -1,5 +1,5 @@
 import { pick, forOwn } from 'lodash';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import VERSION from '/imports/constants/VERSION.js';
 
 export default function writeCreatureVariables(memo, creatureId, fullRecompute = true) {

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

@@ -1,7 +1,7 @@
 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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import ComputationMemo from '/imports/api/creature/computation/engine/ComputationMemo.js';
 import getComputationProperties from '/imports/api/creature/computation/engine/getComputationProperties.js';
 import computeMemo from '/imports/api/creature/computation/engine/computeMemo.js';
@@ -11,7 +11,7 @@ import { recomputeDamageMultipliersById } from '/imports/api/creature/denormalis
 import recomputeSlotFullness from '/imports/api/creature/denormalise/recomputeSlotFullness.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import getDependentProperties from '/imports/api/creature/computation/engine/getDependentProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 
 export const recomputeCreature = new ValidatedMethod({

app/imports/api/creature/creatureFolders/CreatureFolders.js

@@ -0,0 +1,37 @@
+import SimpleSchema from 'simpl-schema';
+
+let CreatureFolders = new Mongo.Collection('creatureFolders');
+
+let creatureFolderSchema = new SimpleSchema({
+	name: {
+		type: String,
+		trim: false,
+		optional: true,
+	},
+	creatures: {
+		type: Array,
+		defaultValue: [],
+	},
+	'creatures.$': {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+	},
+	owner: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+    index: 1,
+	},
+  archived: {
+    type: Boolean,
+    optional: true,
+  },
+  order: {
+    type: Number,
+    defaultValue: 0,
+  },
+});
+
+CreatureFolders.attachSchema(creatureFolderSchema);
+
+import '/imports/api/creature/creatureFolders/methods.js/index.js';
+export default CreatureFolders;

app/imports/api/creature/creatureFolders/methods.js/index.js

@@ -0,0 +1,4 @@
+import '/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js';
+import '/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js';
+import '/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js';
+import '/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js';

app/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js

@@ -0,0 +1,46 @@
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+
+const insertCreatureFolder = new ValidatedMethod({
+  name: 'creatureFolders.methods.insert',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run() {
+    // Ensure logged in
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('creatureFolders.methods.insert.denied',
+      'You need to be logged in to insert a folder');
+    }
+    // Limit folders to 50 per user
+    let existingFolders = CreatureFolders.find({
+      owner: userId
+    }, {
+      fields: {order: 1},
+      sort: {order :-1}
+    });
+    if (existingFolders.count() >= 50){
+      throw new Meteor.Error('creatureFolders.methods.insert.denied',
+      'You can not have more than 50 folders');
+    }
+    // Make the new folder the last in the order
+    let order = 0;
+    let lastFolder = existingFolders.fetch()[0];
+    if (lastFolder){
+      order = (lastFolder.order || 0) + 1;
+    }
+    // Insert
+    return CreatureFolders.insert({
+      name: 'Folder',
+      owner: userId,
+      order,
+    });
+  },
+});
+
+export default insertCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js

@@ -0,0 +1,45 @@
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+
+const moveCreatureToFolder = new ValidatedMethod({
+  name: 'creatureFolders.methods.moveCreatureToFolder',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({creatureId, folderId}) {
+    // Ensure logged in
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+      'You need to be logged in to remove a folder');
+    }
+    // Check that this folder is owned by the user
+    if (folderId){
+      let existingFolder = CreatureFolders.findOne(folderId);
+      if (existingFolder.owner !== userId){
+        throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+        'This folder does not belong to you');
+      }
+    }
+    // Remove from other folders
+    CreatureFolders.update({
+      owner: userId
+    }, {
+      $pull: {creatures: creatureId},
+    }, {
+      multi: true,
+    });
+    if (folderId){
+      // Add to this folder
+      CreatureFolders.update(folderId, {
+        $addToSet: {creatures: creatureId},
+      });
+    }
+  },
+});
+
+export default moveCreatureToFolder;

app/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js

@@ -0,0 +1,31 @@
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+
+const removeCreatureFolder = new ValidatedMethod({
+  name: 'creatureFolders.methods.remove',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id}) {
+    // Ensure logged in
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+      'You need to be logged in to remove a folder');
+    }
+    // Check that this folder is owned by the user
+    let existingFolder = CreatureFolders.findOne(_id);
+    if (existingFolder.owner !== userId){
+      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+      'This folder does not belong to you');
+    }
+    // Remove
+    return CreatureFolders.remove(_id);
+  },
+});
+
+export default removeCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/reorderCreatureFolder.js

@@ -0,0 +1,43 @@
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+
+const reorderCreatureFolder = new ValidatedMethod({
+  name: 'creatureFolders.methods.reorder',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id, order}) {
+    // Ensure logged in
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
+      'You need to be logged in to reorder a folder');
+    }
+    // Check that this folder is owned by the user
+    let existingFolder = CreatureFolders.findOne(_id);
+    if (existingFolder.owner !== userId){
+      throw new Meteor.Error('creatureFolders.methods.reorder.denied',
+      'This folder does not belong to you');
+    }
+    // First give it the new order, it should end in 0.5 putting it between two other docs
+    CreatureFolders.update(_id, {$set: {order}});
+    this.unblock();
+    // Reorder all the folders with integer numbers in this new order
+    CreatureFolders.find({
+      owner: userId
+    }, {
+      fields: {order: 1,},
+      sort: {order: -1}
+    }).forEach((folder, index) => {
+      if (folder.order !== index){
+        CreatureFolders.update(_id, {$set: {order: index}})
+      }
+    });
+  },
+});
+
+export default reorderCreatureFolder;

app/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js

@@ -0,0 +1,31 @@
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+
+const updateCreatureFolderName = new ValidatedMethod({
+  name: 'creatureFolders.methods.updateName',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id, name}) {
+    // Ensure logged in
+    let userId = this.userId;
+    if (!userId) {
+      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+      'You need to be logged in to update a folder');
+    }
+    // Check that this folder is owned by the user
+    let existingFolder = CreatureFolders.findOne(_id);
+    if (existingFolder.owner !== userId){
+      throw new Meteor.Error('creatureFolders.methods.updateName.denied',
+      'This folder does not belong to you');
+    }
+    // Update
+    return CreatureFolders.update(_id, {$set: {name}});
+  },
+});
+
+export default updateCreatureFolderName;

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

@@ -1,4 +1,4 @@
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 
 export default function getRootCreatureAncestor(property){
   return Creatures.findOne(property.ancestors[0].id);

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

@@ -2,7 +2,7 @@ import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
 import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';

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

@@ -2,7 +2,7 @@ import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
 import { recomputeCreatureByDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';

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

@@ -16,11 +16,16 @@ import {
 import { reorderDocs } from '/imports/api/parenting/order.js';
 import { setDocToLastOrder } from '/imports/api/parenting/order.js';
 import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
 	name: 'creatureProperties.insertPropertyFromLibraryNode',
 	validate: new SimpleSchema({
-		nodeId: {
+    nodeIds: {
+      type: Array,
+      max: 20,
+    },
+		'nodeIds.$': {
 			type: String,
 			regEx: SimpleSchema.RegEx.Id,
 		},
@@ -37,7 +42,7 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({nodeId, parentRef, order}) {
+	run({nodeIds, parentRef, order}) {
 		// get the new ancestry for the properties
 		let {parentDoc, ancestors} = getAncestry({parentRef});
 
@@ -52,50 +57,15 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 		}
     assertEditPermission(rootCreature, this.userId);
 
-		// Fetch the library node and its decendents, provided they have not been
-		// removed
-		let node = LibraryNodes.findOne({
-			_id: nodeId,
-			removed: {$ne: true},
-		});
-		if (!node) throw `Node not found for nodeId: ${nodeId}`;
-		let oldParent = node.parent;
-		let nodes = LibraryNodes.find({
-			'ancestors.id': nodeId,
-			removed: {$ne: true},
-		}).fetch();
+    // {libraryId: hasViewPermission}
+    //let libraryPermissionMemoir = {};
+    let node;
+		nodeIds.forEach(nodeId => {
+      // TODO: Check library view permission for each node before starting
+      node = insertPropertyFromNode(nodeId, ancestors, order);
+    });
 
-    // The root node is first in the array of nodes
-    // It must get the first generated ID to prevent flickering
-		nodes = [node, ...nodes];
-
-		// re-map all the ancestors
-		setLineageOfDocs({
-			docArray: nodes,
-			newAncestry: ancestors,
-			oldParent,
-		});
-
-		// Give the docs new IDs without breaking internal references
-		renewDocIds({
-			docArray: nodes,
-			collectionMap: {'libraryNodes': 'creatureProperties'}
-		});
-
-		// Order the root node
-    if (order === undefined){
-      setDocToLastOrder({
-        collection: CreatureProperties,
-        doc: node,
-      });
-    } else {
-      node.order = order;
-    }
-
-		// Insert the creature properties
-    CreatureProperties.batchInsert(nodes);
-
-    // get the root inserted doc
+    // get one of the root inserted docs
     let rootId = node._id;
 
     // Tree structure changed by inserts, reorder the tree
@@ -105,7 +75,7 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
     });
 
     // The library properties need to denormalise which of them are inactive
-    recomputeInactiveProperties(rootId);
+    recomputeInactiveProperties(rootCreature._id);
     // Some of the library properties may be items or containers
     recomputeInventory(rootCreature._id);
 		// Inserting a creature property invalidates dependencies: full recompute
@@ -115,4 +85,148 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 	},
 });
 
+function insertPropertyFromNode(nodeId, ancestors, order){
+  // Fetch the library node and its decendents, provided they have not been
+  // removed
+  // TODO: Check permission to read the library this node is in
+  let node = LibraryNodes.findOne({
+    _id: nodeId,
+    removed: {$ne: true},
+  });
+  if (!node) throw `Node not found for nodeId: ${nodeId}`;
+  let oldParent = node.parent;
+  let nodes = LibraryNodes.find({
+    'ancestors.id': nodeId,
+    removed: {$ne: true},
+  }).fetch();
+
+  // Convert all references into actual nodes
+  nodes = reifyNodeReferences(nodes);
+
+  // The root node is first in the array of nodes
+  // It must get the first generated ID to prevent flickering
+  nodes = [node, ...nodes];
+
+  // re-map all the ancestors
+  setLineageOfDocs({
+    docArray: nodes,
+    newAncestry: ancestors,
+    oldParent,
+  });
+
+  // Give the docs new IDs without breaking internal references
+  renewDocIds({
+    docArray: nodes,
+    collectionMap: {'libraryNodes': 'creatureProperties'}
+  });
+
+  // Order the root node
+  if (order === undefined){
+    setDocToLastOrder({
+      collection: CreatureProperties,
+      doc: node,
+    });
+  } else {
+    node.order = order;
+  }
+
+  // Insert the creature properties
+  CreatureProperties.batchInsert(nodes);
+  return node;
+}
+
+// Covert node references into actual nodes
+// TODO: check permissions for each library a reference node references
+function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
+  depth += 1;
+  // New nodes added this function
+  let newNodes = [];
+
+  // Filter out the reference nodes we replace
+  let resultingNodes = nodes.filter(node => {
+
+    // We have already visited this ref and replaced it
+    if (visitedRefs.has(node._id)) return false;
+
+    // Already replaced an ancestor node
+    for (let i; i < node.ancestors.length; i++){
+      if (visitedRefs.has(node.ancestors[i].id)) return false;
+    }
+
+    // This isn't a reference node, continue as normal
+    if (node.type !== 'reference') return true;
+
+    // We have gone too deep, keep the reference node as an error
+    if (depth > 10){
+      if (Meteor.isClient) console.warn('Reference depth limit exceeded');
+      node.cache = {error: 'Reference depth limit exceeded'};
+      return true;
+    }
+
+    let referencedNode
+    try {
+      referencedNode = fetchDocByRef(node.ref);
+      referencedNode.order = node.order;
+      // We are definitely replacing this node, so add it to the list
+      visitedRefs.add(node._id);
+    } catch (e){
+      node.cache = {error: e.reason || e.message || e.toString()};
+      return true;
+    }
+
+    // Get all the descendants of the referenced node
+    let descendents = LibraryNodes.find({
+      'ancestors.id': referencedNode._id,
+      removed: {$ne: true},
+    }, {
+      sort: {order: 1},
+    }).fetch();
+
+    // We are adding the referenced node and its descendants
+    let addedNodes = [referencedNode, ...descendents];
+
+    // re-map all the ancestors to parent the new sub-tree into our existing
+    // node tree
+		setLineageOfDocs({
+			docArray: addedNodes,
+			newAncestry: node.ancestors,
+			oldParent: referencedNode.parent,
+		});
+
+    // Remove all the looped references and descendents from the new nodes
+    // We can't rely on the reify recursion to do this, since the IDs are
+    // getting renewed before it is called
+    addedNodes = addedNodes.filter(node => {
+      // Exclude removed referenced
+      if (visitedRefs.has(node._id)) return false;
+
+      // Exclude descendants of removed references
+      for (let i; i < node.ancestors.length; i++){
+        if (visitedRefs.has(node.ancestors[i].id)) return false;
+      }
+      return true;
+    });
+
+    // TODO: Force the referencedNode to take the old id of the reference
+    // such that the reference's children can be kept
+
+    // Give the new referenced sub-tree new ids
+    renewDocIds({
+      docArray: addedNodes,
+    });
+
+    // Reify the subtree as well with recursion
+    addedNodes = reifyNodeReferences(addedNodes, visitedRefs, depth);
+
+    // Store the new nodes from this inner loop without altering the array
+    // we are looping over
+    newNodes.push(...addedNodes);
+  });
+
+  // We are done filtering the array, we can add the new nodes to it
+  resultingNodes.push(...newNodes);
+
+  return resultingNodes;
+}
+
 export default insertPropertyFromLibraryNode;

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

@@ -1,16 +1,7 @@
-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 CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
-import { assertUserHasPaidBenefits } from '/imports/api/users/patreon/tiers.js';
-import defaultCharacterProperties from '/imports/api/creature/defaultCharacterProperties.js';
-import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import '/imports/api/creature/removeCreature.js';
-import '/imports/api/creature/restCreature.js';
 
 //set up the collection for creatures
 let Creatures = new Mongo.Collection('creatures');
@@ -176,92 +167,8 @@ CreatureSchema.extend(SharingSchema);
 
 Creatures.attachSchema(CreatureSchema);
 
-const insertCreature = new ValidatedMethod({
 
-  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');
-    }
-    assertUserHasPaidBenefits(this.userId);
-
-		// Create the creature document
-    let creatureId = Creatures.insert({
-			owner: this.userId,
-		});
-
-    // Insert the default properties
-    // Not batchInsert because we want the properties cleaned by the schema
-    let baseId;
-    defaultCharacterProperties(creatureId).forEach(prop => {
-      let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset'){
-        baseId = id;
-      }
-    });
-
-    if (Meteor.isServer){
-      // Insert the 5e ruleset as the default base
-      insertPropertyFromLibraryNode.call({
-        nodeId: 'iHbhfcg3AL5isSWbw',
-        parentRef: {id: baseId, collection: 'creatureProperties'},
-        order: 0.5,
-      });
-    }
-
-		this.unblock();
-		return creatureId;
-  },
-});
-
-const updateCreature = new ValidatedMethod({
-  name: 'creatures.update',
-  validate({_id, path}){
-		if (!_id) return false;
-		// Allowed fields
-		let allowedFields = [
-      'name',
-      'alignment',
-      'gender',
-      'picture',
-      'avatarPicture',
-      'color',
-      'settings',
-    ];
-		if (!allowedFields.includes(path[0])){
-			throw new Meteor.Error('Creatures.methods.update.denied',
-      'This field can\'t be updated using this method');
-		}
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, path, value}) {
-		let creature = Creatures.findOne(_id);
-    assertEditPermission(creature, this.userId);
-    if (value === undefined || value === null){
-      Creatures.update(_id, {
-        $unset: {[path.join('.')]: 1},
-      });
-    } else {
-      Creatures.update(_id, {
-        $set: {[path.join('.')]: value},
-      });
-    }
-  },
-});
+import '/imports/api/creature/creatures/methods/index.js';
 
 export default Creatures;
-export { CreatureSchema, insertCreature, updateCreature };
+export { CreatureSchema };

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

@@ -1,4 +1,4 @@
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import {
   assertEditPermission as editPermission,
   assertViewPermission as viewPermission,

app/imports/api/creature/creatures/methods/index.js

@@ -0,0 +1,5 @@
+import '/imports/api/creature/creatures/methods/insertCreature.js';
+import '/imports/api/creature/creatures/methods/removeCreature.js';
+import '/imports/api/creature/creatures/methods/restCreature.js';
+import '/imports/api/creature/creatures/methods/transferCreatureOwnership.js';
+import '/imports/api/creature/creatures/methods/updateCreature.js';

app/imports/api/creature/creatures/methods/insertCreature.js

@@ -0,0 +1,70 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
+import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
+
+const insertCreature = new ValidatedMethod({
+
+  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);
+
+    let currentCharacterCount = Creatures.find({
+      owner: this.userId,
+    }, {
+      fields: {_id: 1},
+    }).count();
+
+    if (
+      tier.characterSlots !== -1 &&
+      currentCharacterCount >= tier.characterSlots
+    ){
+      throw new Meteor.Error('Creatures.methods.insert.denied',
+      `You are already at your limit of ${tier.characterSlots} characters`)
+    }
+
+		// Create the creature document
+    let creatureId = Creatures.insert({
+			owner: this.userId,
+		});
+
+    // Insert the default properties
+    // Not batchInsert because we want the properties cleaned by the schema
+    let baseId;
+    defaultCharacterProperties(creatureId).forEach(prop => {
+      let id = CreatureProperties.insert(prop);
+      if (prop.name === 'Ruleset'){
+        baseId = id;
+      }
+    });
+
+    if (Meteor.isServer){
+      // Insert the 5e ruleset as the default base
+      insertPropertyFromLibraryNode.call({
+        nodeIds: ['iHbhfcg3AL5isSWbw'],
+        parentRef: {id: baseId, collection: 'creatureProperties'},
+        order: 0.5,
+      });
+    }
+
+		return creatureId;
+  },
+});
+
+export default insertCreature;

app/imports/api/creature/creatures/methods/removeCreature.js

@@ -1,8 +1,8 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creaturePermissions.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
 import Experiences from '/imports/api/creature/experience/Experiences.js';

app/imports/api/creature/creatures/methods/restCreature.js

@@ -1,9 +1,9 @@
 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 Creatures from '/imports/api/creature/creatures/Creatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 
 const restCreature = new ValidatedMethod({

app/imports/api/creature/creatures/methods/transferCreatureOwnership.js

@@ -0,0 +1,55 @@
+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/Creatures.js';
+import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
+import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+
+const transferCreatureOwnership = new ValidatedMethod({
+
+  name: 'creatures.methods.transferOwnership',
+
+  validate: new SimpleSchema({
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    userId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
+  run({creatureId, userId}) {
+    assertOwnership(creatureId, this.userId);
+
+    let tier = getUserTier(userId);
+    let currentCharacterCount = Creatures.find({
+      owner: userId,
+    }, {
+      fields: {_id: 1},
+    }).count();
+
+    if (
+      tier.characterSlots !== -1 &&
+      currentCharacterCount >= tier.characterSlots
+    ){
+      throw new Meteor.Error('Creatures.methods.transferOwnership.denied',
+      'The new owner is already at their character limit')
+    }
+
+    Creatures.update(creatureId, {
+      $set: {owner: userId},
+    });
+
+		return creatureId;
+  },
+});
+
+export default transferCreatureOwnership;

app/imports/api/creature/creatures/methods/updateCreature.js

@@ -0,0 +1,45 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
+
+const updateCreature = new ValidatedMethod({
+  name: 'creatures.update',
+  validate({_id, path}){
+		if (!_id) return false;
+		// Allowed fields
+		let allowedFields = [
+      'name',
+      'alignment',
+      'gender',
+      'picture',
+      'avatarPicture',
+      'color',
+      'settings',
+    ];
+		if (!allowedFields.includes(path[0])){
+			throw new Meteor.Error('Creatures.methods.update.denied',
+      'This field can\'t be updated using this method');
+		}
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id, path, value}) {
+		let creature = Creatures.findOne(_id);
+    assertEditPermission(creature, this.userId);
+    if (value === undefined || value === null){
+      Creatures.update(_id, {
+        $unset: {[path.join('.')]: 1},
+      });
+    } else {
+      Creatures.update(_id, {
+        $set: {[path.join('.')]: value},
+      });
+    }
+  },
+});
+
+export default updateCreature;

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

@@ -1,8 +1,8 @@
 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';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 
 export const recomputeDamageMultipliers = new ValidatedMethod({

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

@@ -1,6 +1,6 @@
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/Creatures.js';
-import { nodesToTree } from '/imports/api/parenting/parenting.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import nodesToTree from '/imports/api/parenting/nodesToTree.js';
 
 export default function recomputeInventory(creatureId){
   let inventoryForest = nodesToTree({

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

@@ -2,8 +2,8 @@ import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { getUserTier } from '/imports/api/users/patreon/tiers.js';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 
 let Experiences = new Mongo.Collection('experiences');

app/imports/api/creature/log/CreatureLogs.js

@@ -1,9 +1,9 @@
 import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import LogContentSchema from '/imports/api/creature/log/LogContentSchema.js';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import {assertEditPermission} from '/imports/api/creature/creaturePermissions.js';
+import {assertEditPermission} from '/imports/api/creature/creatures/creaturePermissions.js';
 import {
   parse,
   CompilationContext,

app/imports/api/creature/mixins/creaturePermissionMixin.js

@@ -2,7 +2,7 @@ import {
   assertEditPermission,
   assertViewPermission,
   assertOwnership,
-} from '/imports/api/creature/creaturePermissions.js';
+} from '/imports/api/creature/creatures/creaturePermissions.js';
 
 // Checks if the method has permission to run on the document. If the document
 // has a charId, that creature is checked, otherwise if it has an _id and the

app/imports/api/library/LibraryNodes.js

@@ -12,6 +12,7 @@ import { softRemove } from '/imports/api/parenting/softRemove.js';
 import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
 import { storedIconsSchema } from '/imports/api/icons/Icons.js';
 import '/imports/api/library/methods/index.js';
+import { updateReferenceNodeWork } from '/imports/api/library/methods/updateReferenceNode.js';
 
 let LibraryNodes = new Mongo.Collection('libraryNodes');
 
@@ -76,7 +77,12 @@ const insertNode = new ValidatedMethod({
   run(libraryNode) {
     delete libraryNode._id;
     assertNodeEditPermission(libraryNode, this.userId);
-		return LibraryNodes.insert(libraryNode);
+		let nodeId = LibraryNodes.insert(libraryNode);
+    if (libraryNode.type == 'reference'){
+      libraryNode._id = nodeId;
+      updateReferenceNodeWork(libraryNode, this.userId);
+    }
+    return nodeId;
   },
 });
 
@@ -109,9 +115,14 @@ const updateLibraryNode = new ValidatedMethod({
     } else {
       modifier = {$set: {[pathString]: value}};
     }
-		return LibraryNodes.update(_id, modifier, {
+		let numUpdated = LibraryNodes.update(_id, modifier, {
 			selector: {type: node.type},
 		});
+    if (node.type == 'reference'){
+      node = LibraryNodes.findOne(_id);
+      updateReferenceNodeWork(node, this.userId);
+    }
+    return numUpdated;
   },
 });
 

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

@@ -1 +1,2 @@
 import '/imports/api/library/methods/duplicateLibraryNode.js';
+import '/imports/api/library/methods/updateReferenceNode.js';

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

@@ -0,0 +1,67 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import SimpleSchema from 'simpl-schema';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import LibraryNodes from '/imports/api/library/LibraryNodes.js';
+import {
+  assertDocEditPermission,
+  assertViewPermission,
+} from '/imports/api/sharing/sharingPermissions.js';
+import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
+
+const updateReferenceNode = new ValidatedMethod({
+  name: 'libraryNodes.updateReferenceNode',
+  validate: new SimpleSchema({
+    _id: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    }
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id}) {
+    let userId = this.userId;
+    let node = LibraryNodes.findOne(_id);
+    assertDocEditPermission(node, userId);
+    updateReferenceNodeWork(node, userId);
+  },
+});
+
+function writeCache(_id, cache){
+  LibraryNodes.update(_id, {$set: {cache}}, {
+    selector: {type: 'reference'},
+  });
+}
+
+function updateReferenceNodeWork(node, userId){
+  let cache = {}
+  if (!node.ref){
+    writeCache(node._id, cache);
+    return;
+  }
+  let doc, library;
+  try {
+    doc = fetchDocByRef(node.ref);
+    if (doc.removed) throw 'Property has been deleted';
+    if (doc.ancestors[0].id !== node.ancestors[0].id){
+      library = fetchDocByRef(doc.ancestors[0]);
+      assertViewPermission(library, userId)
+    }
+  } catch(e){
+    cache = {error: e.reason || e.message || e.toString()}
+    writeCache(node._id, cache);
+    return;
+  }
+  cache = {
+    node: doc,
+  };
+  if (library){
+    cache.library = {name: library.name};
+  }
+  writeCache(node._id, cache);
+}
+
+export default updateReferenceNode;
+export { updateReferenceNodeWork }

app/imports/api/parenting/ChildSchema.js

@@ -4,6 +4,11 @@ const RefSchema = new SimpleSchema({
   id: {
     type: String,
     regEx: SimpleSchema.RegEx.Id,
+    // TODO: Rather than indexing this field, index `ancestors.0.id` to only
+    // index the root of the ancestor heirarchy to significantly reduce
+    // index size and improve performance
+    // All queries on an ancestor document need to target `ancestors.0.id` first
+    // before targeting a younger ancestor
     index: 1
   },
   collection: {

app/imports/api/parenting/getDescendantsInDepthFirstOrder.js

@@ -1,4 +1,4 @@
-import { nodesToTree } from '/imports/api/parenting/parenting.js';
+import nodesToTree from '/imports/api/parenting/nodesToTree.js';
 
 export default function getDescendantsInDepthFirstOrder({
   collection,

app/imports/api/parenting/nodesToTree.js

@@ -0,0 +1,115 @@
+import { union, difference, sortBy, findLast } from 'lodash';
+
+export function nodeArrayToTree(nodes){
+  // Store a dict and list of all the nodes
+  let nodeIndex = {};
+  let nodeList = [];
+  nodes.forEach( node => {
+    let treeNode = {
+      node: node,
+      children: [],
+    };
+    nodeIndex[node._id] = treeNode;
+    nodeList.push(treeNode);
+  });
+  // Create a forest of trees
+  let forest = [];
+  // Either the node is a child of its nearest found ancestor, or in the forest as a root
+  nodeList.forEach(treeNode => {
+    let ancestorInForest = findLast(
+      treeNode.node.ancestors,
+      ancestor => !!nodeIndex[ancestor.id]
+    );
+    if (ancestorInForest){
+      nodeIndex[ancestorInForest.id].children.push(treeNode);
+    } else {
+      forest.push(treeNode);
+    }
+  });
+  return forest;
+}
+
+// Fetch the documents from a collection, and return the tree of those documents
+export default function nodesToTree({
+  collection, ancestorId, filter, options = {},
+  includeFilteredDocAncestors = false, includeFilteredDocDescendants = false
+}){
+  // Setup the filter
+  let collectionFilter = {
+    'ancestors.id': ancestorId,
+    'removed': {$ne: true},
+  };
+  if (filter){
+    collectionFilter = {
+      ...collectionFilter,
+      ...filter,
+    }
+  }
+  // Set up the options
+  let collectionSort = {
+    order: 1
+  };
+  if (options && options.sort){
+    collectionSort = {
+      ...collectionSort,
+      ...options.sort,
+    }
+  }
+  let collectionOptions = {
+    sort: collectionSort,
+  }
+  if (options){
+    collectionOptions = {
+      ...collectionOptions,
+      ...options,
+    }
+  }
+  // Find all the nodes that match the filter
+  let docs = collection.find(collectionFilter, collectionOptions).map(doc => {
+    if (!filter) return doc;
+    // Mark the nodes that were found by the custom filter
+    doc._matchedDocumentFilter = true;
+    return doc;
+  });
+  let ancestors = [];
+  let ancestorIds = [];
+  let docIds = [];
+  if (filter && (includeFilteredDocAncestors || includeFilteredDocDescendants)){
+    docIds = docs.map(doc => doc._id)
+  }
+  if (filter && includeFilteredDocAncestors){
+    // Add all ancestor ids to an array
+    docs.forEach(doc => {
+      ancestorIds = union(ancestorIds, doc.ancestors.map(ref => ref.id));
+    });
+    // Remove the IDs of docs we have already found
+    ancestorIds = difference(ancestorIds, docIds);
+    // Get the docs from the collection, don't worry about `removed` docs,
+    // if their descendant was not removed, neither are they
+    ancestors = collection.find({_id: {$in: ancestorIds}}).map(doc => {
+      // Mark that the nodes are ancestors of the found nodes
+      doc._ancestorOfMatchedDocument = true;
+      return doc;
+    });
+  }
+  let descendants = [];
+  if (filter && includeFilteredDocDescendants){
+    let exludeIds = union(ancestorIds, docIds);
+    descendants = collection.find({
+      '_id': {$nin: exludeIds},
+      'ancestors.id': {$in: docIds},
+      'removed': {$ne: true},
+    }).map(doc => {
+      // Mark that the nodes are descendants of the found nodes
+      doc._descendantOfMatchedDocument = true;
+      return doc;
+    });
+  }
+  let nodes = sortBy([
+    ...ancestors,
+    ...docs,
+    ...descendants
+  ], 'order');
+  // Find all the nodes
+  return nodeArrayToTree(nodes);
+}

app/imports/api/parenting/parenting.js

@@ -1,6 +1,6 @@
 import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
 import getCollectionByName from '/imports/api/parenting/getCollectionByName.js';
-import { flatten, findLast } from 'lodash';
+import { flatten } from 'lodash';
 
 const generalParents = [
   'attribute',
@@ -217,41 +217,3 @@ export function getName(doc){
     if (doc.ancestors[i].name) return doc.ancestors[i].name;
   }
 }
-
-export function nodeArrayToTree(nodes){
-  // Store a dict and list of all the nodes
-  let nodeIndex = {};
-  let nodeList = [];
-  nodes.forEach( node => {
-    let treeNode = {
-      node: node,
-      children: [],
-    };
-    nodeIndex[node._id] = treeNode;
-    nodeList.push(treeNode);
-  });
-  // Create a forest of trees
-  let forest = [];
-  // Either the node is a child of its nearest found ancestor, or in the forest as a root
-  nodeList.forEach(treeNode => {
-    let ancestorInForest = findLast(
-      treeNode.node.ancestors,
-      ancestor => !!nodeIndex[ancestor.id]
-    );
-    if (ancestorInForest){
-      nodeIndex[ancestorInForest.id].children.push(treeNode);
-    } else {
-      forest.push(treeNode);
-    }
-  });
-  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/Attributes.js

@@ -133,6 +133,11 @@ let ComputedOnlyAttributeSchema = new SimpleSchema({
     type: Boolean,
     optional: true,
   },
+  // Denormalised tag if stat is overridden by one with the same variable name
+  overridden: {
+    type: Boolean,
+    optional: true,
+  },
 });
 
 const ComputedAttributeSchema = new SimpleSchema()

app/imports/api/properties/Proficiencies.js

@@ -14,9 +14,10 @@ let ProficiencySchema = new SimpleSchema({
 		type: String,
 	},
 	// A number representing how proficient the character is
+  // where 0.49 is half rounded down and 0.5 is half rounded up
 	value: {
 		type: Number,
-		allowedValues: [0.5, 1, 2],
+		allowedValues: [0.49, 0.5, 1, 2],
 		defaultValue: 1,
 	},
 });

app/imports/api/properties/References.js

@@ -0,0 +1,55 @@
+import SimpleSchema from 'simpl-schema';
+
+let ReferenceSchema = new SimpleSchema({
+  ref: {
+    type: Object,
+    defaultValue: {},
+  },
+  'ref.id': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    optional: true,
+  },
+  'ref.collection': {
+    type: String,
+    optional: true,
+  },
+  // Denormalised store of referenced property's details
+  cache: {
+    type: Object,
+    defaultValue: {},
+  },
+  'cache.error': {
+    type: String,
+    optional: true,
+  },
+  'cache.node': {
+    type: Object,
+    optional: true,
+  },
+  'cache.node.name': {
+    type: String,
+    optional: true,
+  },
+  'cache.node.type': {
+    type: String,
+  },
+  'cache.node.level': {
+    type: Number,
+    optional: true,
+  },
+  'cache.node.value': {
+    type: Number,
+    optional: true,
+  },
+  'cache.library': {
+    type: Object,
+    optional: true,
+  },
+  'cache.library.name': {
+    type: String,
+    optional: true,
+  },
+});
+
+export { ReferenceSchema };

app/imports/api/properties/Skills.js

@@ -121,6 +121,11 @@ let ComputedOnlySkillSchema = new SimpleSchema({
     type: Boolean,
     optional: true,
   },
+  // Denormalised tag if stat is overridden by one with the same variable name
+  overridden: {
+    type: Boolean,
+    optional: true,
+  },
 })
 
 const ComputedSkillSchema = new SimpleSchema()

app/imports/api/properties/SpellLists.js

@@ -1,6 +1,5 @@
 import SimpleSchema from 'simpl-schema';
 import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
-import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 import InlineComputationSchema from '/imports/api/properties/subSchemas/InlineComputationSchema.js';
 
 let SpellListSchema = new SimpleSchema({
@@ -12,12 +11,6 @@ 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,

app/imports/api/properties/computedOnlyPropertySchemasIndex.js

@@ -15,6 +15,7 @@ import { FolderSchema } from '/imports/api/properties/Folders.js';
 import { ComputedOnlyItemSchema } from '/imports/api/properties/Items.js';
 import { ComputedOnlyNoteSchema } from '/imports/api/properties/Notes.js';
 import { ProficiencySchema } from '/imports/api/properties/Proficiencies.js';
+import { ReferenceSchema } from '/imports/api/properties/References.js';
 import { ComputedOnlyRollSchema } from '/imports/api/properties/Rolls.js';
 import { ComputedOnlySavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
 import { ComputedOnlySkillSchema } from '/imports/api/properties/Skills.js';
@@ -42,6 +43,7 @@ const propertySchemasIndex = {
   note: ComputedOnlyNoteSchema,
   proficiency: ProficiencySchema,
   propertySlot: ComputedOnlySlotSchema,
+  reference: ReferenceSchema,
   roll: ComputedOnlyRollSchema,
   savingThrow: ComputedOnlySavingThrowSchema,
   skill: ComputedOnlySkillSchema,

app/imports/api/properties/computedPropertySchemasIndex.js

@@ -15,6 +15,7 @@ import { FolderSchema } from '/imports/api/properties/Folders.js';
 import { ComputedItemSchema } from '/imports/api/properties/Items.js';
 import { ComputedNoteSchema } from '/imports/api/properties/Notes.js';
 import { ProficiencySchema } from '/imports/api/properties/Proficiencies.js';
+import { ReferenceSchema } from '/imports/api/properties/References.js';
 import { ComputedRollSchema } from '/imports/api/properties/Rolls.js';
 import { ComputedSavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
 import { ComputedSkillSchema } from '/imports/api/properties/Skills.js';
@@ -40,6 +41,7 @@ const propertySchemasIndex = {
   note: ComputedNoteSchema,
   proficiency: ProficiencySchema,
   propertySlot: ComputedSlotSchema,
+  reference: ReferenceSchema,
   roll: ComputedRollSchema,
   savingThrow: ComputedSavingThrowSchema,
   skill: ComputedSkillSchema,

app/imports/api/properties/propertySchemasIndex.js

@@ -13,6 +13,7 @@ import { FeatureSchema } from '/imports/api/properties/Features.js';
 import { FolderSchema } from '/imports/api/properties/Folders.js';
 import { NoteSchema } from '/imports/api/properties/Notes.js';
 import { ProficiencySchema } from '/imports/api/properties/Proficiencies.js';
+import { ReferenceSchema } from '/imports/api/properties/References.js';
 import { RollSchema } from '/imports/api/properties/Rolls.js';
 import { SavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
 import { SkillSchema } from '/imports/api/properties/Skills.js';
@@ -40,6 +41,7 @@ const propertySchemasIndex = {
   note: NoteSchema,
   proficiency: ProficiencySchema,
   propertySlot: SlotSchema,
+  reference: ReferenceSchema,
   roll: RollSchema,
   savingThrow: SavingThrowSchema,
   skill: SkillSchema,

app/imports/api/sharing/sharingPermissions.js

@@ -1,6 +1,5 @@
 import { _ } from 'meteor/underscore';
 import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
 
 function assertIdValid(userId){
   if (!userId || typeof userId !== 'string'){
@@ -12,7 +11,7 @@ function assertIdValid(userId){
 function assertdocExists(doc){
   if (!doc){
     throw new Meteor.Error('Permission denied',
-      'No such document exists');
+      'Permission denied: No such document exists');
   }
 }
 
@@ -48,13 +47,6 @@ export function assertEditPermission(doc, userId) {
     return true;
   }
 
-  // Ensure the user is of a tier with paid benefits
-  let tier = getUserTier(user);
-  if (!tier.paidBenefits){
-    throw new Meteor.Error('Edit permission denied',
-      `The ${tier.name} tier does not allow you to edit this document`);
-  }
-
   // Ensure the user is authorized for this specific document
   if (
     doc.owner === userId ||

app/imports/api/tabletop/Messages.js

@@ -1,7 +1,7 @@
 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 Creatures from '/imports/api/creature/creatures/Creatures.js';
 import Tabletops, { assertUserInTabletop } from '/imports/api/tabletop/Tabletops.js';
 
 let Messages = new Mongo.Collection('messages');

app/imports/api/tabletop/Tabletops.js

@@ -2,7 +2,7 @@ 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';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 
 let Tabletops = new Mongo.Collection('tabletops');
 

app/imports/api/users/Users.js

@@ -2,6 +2,8 @@ import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import '/imports/api/users/deleteMyAccount.js';
+import { some } from 'lodash';
+const defaultLibraries = process.env.DEFAULT_LIBRARIES && process.env.DEFAULT_LIBRARIES.split(',') || [];
 
 const userSchema = new SimpleSchema({
 	username: {
@@ -63,7 +65,7 @@ const userSchema = new SimpleSchema({
 	},
 	subscribedLibraries: {
 		type: Array,
-		defaultValue: [],
+		defaultValue: defaultLibraries,
 		max: 100,
 	},
 	'subscribedLibraries.$': {
@@ -93,6 +95,10 @@ const userSchema = new SimpleSchema({
     type: Boolean,
     optional: true,
   },
+  'preferences.hidePropertySelectDialogHelp': {
+    type: Boolean,
+    optional: true,
+  },
 });
 
 Meteor.users.attachSchema(userSchema);
@@ -154,7 +160,7 @@ Meteor.users.sendVerificationEmail = new ValidatedMethod({
 			throw new Meteor.Error('User not found',
 				'Can\'t send a validation email to a user that does not exist');
 		}
-		if (!_.some(user.emails, email => email.address === address)) {
+		if (!some(user.emails, email => email.address === address)) {
 			throw new Meteor.Error('Email address not found',
 				'The specified email address wasn\'t found on this user account');
 		}

app/imports/api/users/deleteMyAccount.js

@@ -1,8 +1,8 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import Libraries, {removeLibaryWork} from '/imports/api/library/Libraries.js';
-import Creatures from '/imports/api/creature/Creatures.js';
-import {removeCreatureWork} from '/imports/api/creature/removeCreature.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import {removeCreatureWork} from '/imports/api/creature/creatures/methods/removeCreature.js';
 
 Meteor.users.deleteMyAccount = new ValidatedMethod({
 	name: 'users.deleteMyAccount',

app/imports/api/users/patreon/tiers.js

@@ -1,58 +1,78 @@
 import { findLast } from 'lodash';
 import getEntitledCents from '/imports/api/users/patreon/getEntitledCents.js';
 import Invites from '/imports/api/users/Invites.js';
+const patreonDisabled = !!Meteor.settings?.public?.disablePatreon;
 
-const TIERS = [
+const TIERS = Object.freeze([
   {
     name: 'Commoner',
     minimumEntitledCents: 0,
     invites: 0,
+    characterSlots: 5,
     paidBenefits: false,
   }, {
     name: 'Dreamer',
     minimumEntitledCents: 100,
     invites: 0,
+    characterSlots: 5,
     paidBenefits: false,
   }, {
     name: 'Wanderer',
     minimumEntitledCents: 300,
     invites: 0,
+    characterSlots: 5,
     paidBenefits: false,
   }, {
     //cost per user $5
     name: 'Adventurer',
     minimumEntitledCents: 500,
     invites: 0,
+    characterSlots: 20,
     paidBenefits: true,
   }, {
     //cost per user $3.33
     name: 'Hero',
     minimumEntitledCents: 1000,
     invites: 2,
+    characterSlots: 50,
     paidBenefits: true,
   }, {
     //cost per user $3.333
     name: 'Legend',
     minimumEntitledCents: 2000,
     invites: 5,
+    characterSlots: 120,
     paidBenefits: true,
   }, {
     //cost per user $3.125
     name: 'Paragon',
     minimumEntitledCents: 5000,
     invites: 15,
+    characterSlots: -1, // Unlimited characters
     paidBenefits: true,
   },
-];
+]);
 
-const GUEST_TIER = {
+// Companion tier should be equivalent to the Adventurer tier
+const GUEST_TIER = Object.freeze({
   name: 'Companion',
   guest: true,
   invites: 0,
+  characterSlots: 20,
   paidBenefits: true,
-}
+});
+
+// When patreon features are disabled, give all the users the same tier
+// with no limitations
+const PATREON_DISABLED_TIER = Object.freeze({
+  name: 'Outlander',
+  invites: 0,
+  characterSlots: -1, // Can have infinitely many characters
+  paidBenefits: true,
+});
 
 export function getTierByEntitledCents(entitledCents = 0){
+  if (patreonDisabled) return PATREON_DISABLED_TIER;
   return findLast(TIERS, tier => entitledCents >= tier.minimumEntitledCents);
 }
 
@@ -66,6 +86,7 @@ export function getUserTier(user){
     });
     if (!user) throw 'User not found';
   }
+  if (patreonDisabled) return PATREON_DISABLED_TIER;
   const entitledCents = getEntitledCents(user);
   const tier = getTierByEntitledCents(entitledCents);
   if (tier.paidBenefits) return tier;

app/imports/client/serviceWorker.js

@@ -0,0 +1,5 @@
+Meteor.startup(() => {
+  navigator.serviceWorker.register('/sw.js')
+  .then()
+  .catch(error => console.log('ServiceWorker registration failed: ', error));
+});

app/imports/constants/PROPERTIES.js

@@ -1,99 +1,157 @@
 const PROPERTIES = Object.freeze({
   action: {
     icon: '$vuetify.icons.action',
-    name: 'Action'
+    name: 'Action',
+    helpText: 'Actions are things your character can do. When an action is taken, all the properties under it are activated.',
+    suggestedParents: ['classLevel', 'feature', 'item'],
   },
   attack: {
     icon: '$vuetify.icons.attack',
-    name: 'Attack'
+    name: 'Attack',
+    helpText: 'Attacks are a special form of action that includes an attack roll. Attacks can critical hit, which doubles the number of damage dice in properties under the attack.',
+    suggestedParents: ['classLevel', 'feature', 'item'],
   },
   attribute: {
     icon: '$vuetify.icons.attribute',
-    name: 'Attribute'
+    name: 'Attribute',
+    helpText: 'Attributes are the numbered statistics of your character, excluding rolls you might add proficiency bonus to, those are skills.',
+    examples: 'Ability scores, speed, hit points, ki',
+    suggestedParents: ['classLevel', 'buff'],
   },
   adjustment: {
     icon: '$vuetify.icons.attribute_damage',
-    name: 'Attribute damage'
+    name: 'Attribute damage',
+    helpText: 'Attribute damage reduces the current value of an attribute when it is applied by an action. A negative value causes the attribute to increase instead, up to its normal maximum.',
+    suggestedParents: ['action', 'attack', 'savingThrow', 'spell'],
   },
   buff: {
     icon: '$vuetify.icons.buff',
-    name: 'Buff'
+    name: 'Buff',
+    helpText: 'When a buff is activated as a child of an action, it will copy the properties under itself onto a target character.',
+    suggestedParents: ['action', 'attack', 'savingThrow', 'spell'],
   },
   classLevel: {
     icon: '$vuetify.icons.class_level',
-    name: 'Class level'
+    name: 'Class level',
+    helpText: 'Class levels represent a single level gained in a class',
+    suggestedParents: ['class'],
   },
   constant: {
-    icon: 'anchor',
-    name: 'Constant'
+    icon: 'mdi-anchor',
+    name: 'Constant',
+    helpText: 'A constant can define a static value that can be used in calculations elsewhere in the sheet',
+    suggestedParents: [],
   },
   container: {
-    icon: 'work',
-    name: 'Container'
+    icon: 'mdi-bag-personal-outline',
+    name: 'Container',
+    helpText: 'A container holds items in the inventory',
+    examples: 'Coin pouch, backpack',
+    suggestedParents: ['folder'],
   },
   damage: {
     icon: '$vuetify.icons.damage',
-    name: 'Damage'
+    name: 'Damage',
+    helpText: 'When damage is activated by an action it reduces the hit points of the target creature by the calculated amount.',
+    suggestedParents: ['action', 'attack', 'savingThrow', 'spell'],
   },
   damageMultiplier: {
     icon: '$vuetify.icons.damage_multiplier',
-    name: 'Damage multiplier'
+    name: 'Damage multiplier',
+    helpText: 'Resistance, vulnerability, and immunity.',
+    suggestedParents: ['classLevel', 'feature', 'item'],
   },
   effect: {
     icon: '$vuetify.icons.effect',
-    name: 'Effect'
+    name: 'Effect',
+    helpText: 'Effects change the value or state of attributes and skills.',
+    examples: '+2 Strength, Advantage on dexterity saving throws',
+    suggestedParents: ['buff', 'classLevel', 'feature', 'folder', 'item'],
   },
   feature: {
-    icon: 'subject',
-    name: 'Feature'
+    icon: 'mdi-text-subject',
+    name: 'Feature',
+    helpText: 'Descriptive or narrative features your character has access to',
+    suggestedParents: ['classLevel', 'folder'],
   },
   folder: {
-    icon: 'folder',
-    name: 'Folder'
+    icon: 'mdi-folder-outline',
+    name: 'Folder',
+    helpText: 'A way to organise other properties on the character',
+    suggestedParents: ['folder'],
   },
   item: {
-    icon: '$vuetify.icons.item',
-    name: 'Item'
+    icon: 'mdi-cube-outline',
+    name: 'Item',
+    helpText: 'Objects and equipment your charcter finds on their adventures',
+    suggestedParents: ['container'],
   },
   note: {
-    icon: 'note',
-    name: 'Note'
+    icon: 'mdi-note-outline',
+    name: 'Note',
+    helpText: 'Notes about your character and their adventures',
+    suggestedParents: ['folder'],
   },
   proficiency: {
-    icon: 'radio_button_checked',
-    name: 'Proficiency'
+    icon: 'mdi-brightness-1',
+    name: 'Proficiency',
+    helpText: 'Proficiencies apply your proficiency bonus to skills already on your character sheet.',
+    suggestedParents: ['buff', 'classLevel', 'feature', 'folder'],
   },
   roll: {
     icon: '$vuetify.icons.roll',
-    name: 'Roll'
+    name: 'Roll',
+    helpText: 'When activated by an action, rolls perform a calculation and temporarily store the result for other properties under the same action to use',
+    suggestedParents: ['action', 'attack', 'savingThrow', 'spell'],
+  },
+  reference: {
+    icon: 'mdi-vector-link',
+    name: 'Reference',
+    libraryOnly: true,
+    helpText: 'A reference is a link to a different property in a library. When a reference gets copied to a character sheet, it is replaced with the referenced property and all its children.',
+    suggestedParents: [],
   },
   savingThrow: {
     icon: '$vuetify.icons.saving_throw',
-    name: 'Saving throw'
+    name: 'Saving throw',
+    helpText: 'When a saving throw is activated by an action, it causes the target to make a saving throw, if the saving throw fails, the children properties of the saving throw are activated.',
+    suggestedParents: ['action', 'attack', 'spell'],
   },
   skill: {
     icon: '$vuetify.icons.skill',
-    name: 'Skill'
+    name: 'Skill',
+    helpText: 'Skills, saves, languages, and weapon and tool proficiencies are all skills. Skills can have a default proficiency set. Proficiencies and effects can change the value and state of skills.',
+    suggestedParents: ['classLevel', 'folder'],
   },
   propertySlot: {
-    icon: 'tab_unselected',
-    name: 'Slot'
+    icon: 'mdi-power-socket-eu',
+    name: 'Slot',
+    helpText: 'A slot in the character sheet is used to specify that a property needs to be selected from a library to fill the slot. The slot can determine what tags it is looking for, and any subscribed library property with matching tags can fill the slot',
+    suggestedParents: [],
   },
   slotFiller: {
-    icon: 'picture_in_picture',
-    name: 'Slot filler'
+    icon: 'mdi-power-plug-outline',
+    name: 'Slot filler',
+    helpText: 'A slot filler allows for more advanced logic when it attemptst to fill a slot. It can masquarade as any property type, and calculate whether it should fill a slot or not.',
+    suggestedParents: ['propertySlot'],
   },
   spellList: {
     icon: '$vuetify.icons.spell_list',
-    name: 'Spell list'
+    name: 'Spell list',
+    helpText: 'A list of spells on your character sheet. It can provide a DC and spell attack bonus to the spells within',
+    suggestedParents: [],
   },
   spell: {
     icon: '$vuetify.icons.spell',
-    name: 'Spell'
+    name: 'Spell',
+    helpText: 'A spell your character can potentially cast',
+    suggestedParents: ['spellList'],
   },
   toggle: {
     icon: '$vuetify.icons.toggle',
-    name: 'Toggle'
+    name: 'Toggle',
+    helpText: 'Togggles allow parts of the character sheet to be turned on and off, either manually or as the result of a calculation.',
+    suggestedParents: [],
   },
 });
 

app/imports/parser/parseTree/CallNode.js

@@ -20,7 +20,6 @@ export default class CallNode extends ParseNode {
 
     // Resolve the arguments
     let resolvedArgs = this.args.map(node => node[fn](scope, context));
-
     // Check that the arguments match what is expected
     let checkFailed = this.checkArugments({
       fn,
@@ -30,7 +29,7 @@ export default class CallNode extends ParseNode {
     });
 
     if (checkFailed){
-      if (fn !== 'reduce'){
+      if (fn === 'reduce'){
         return new ErrorNode({
           node: this,
           error: `Invalid arguments to ${this.functionName} function`,

app/imports/server/config/accountsEmailConfig.js

@@ -0,0 +1,4 @@
+import { Accounts } from 'meteor/accounts-base'
+
+Accounts.emailTemplates.from = 'no-reply@dicecloud.com';
+Accounts.emailTemplates.siteName = 'DiceCloud';

app/imports/server/publications/archivedCreatures.js

@@ -0,0 +1,19 @@
+import ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
+
+Meteor.publish('archivedCreatures', function(){
+  this.autorun(function (){
+    var userId = this.userId;
+    if (!userId) {
+      return [];
+    }
+    return ArchivedCreatures.find({
+        owner: userId,
+      }, {
+        fields: {
+          creature: 1,
+          owner: 1,
+        }
+      }
+    );
+  });
+});

app/imports/server/publications/characterList.js

@@ -1,5 +1,5 @@
-import Creatures from '/imports/api/creature/Creatures.js';
-import Parties from '/imports/api/creature/Parties.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
 
 Meteor.publish('characterList', function(){
   this.autorun(function (){
@@ -36,7 +36,7 @@ Meteor.publish('characterList', function(){
           }
         }
       ),
-      Parties.find({owner: userId}),
+      CreatureFolders.find({owner: userId}),
     ];
   });
 });

app/imports/server/publications/experiences.js

@@ -1,7 +1,7 @@
 import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { assertViewPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertViewPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 
 let schema = new SimpleSchema({
   creatureId: {

app/imports/server/publications/index.js

@@ -6,5 +6,7 @@ import '/imports/server/publications/experiences.js';
 import '/imports/server/publications/users.js';
 import '/imports/server/publications/icons.js';
 import '/imports/server/publications/tabletops.js';
-import '/imports/server/publications/slotFillers.js'
-import '/imports/server/publications/ownedDocuments.js'
+import '/imports/server/publications/slotFillers.js';
+import '/imports/server/publications/ownedDocuments.js';
+import '/imports/server/publications/archivedCreatures.js';
+import '/imports/server/publications/searchLibraryNodes.js';

app/imports/server/publications/library.js

@@ -2,13 +2,6 @@ import SimpleSchema from 'simpl-schema';
 import Libraries from '/imports/api/library/Libraries.js';
 import LibraryNodes from '/imports/api/library/LibraryNodes.js';
 import { assertViewPermission } from '/imports/api/sharing/sharingPermissions.js';
-const standardLibraryIds = [
-  'SRDLibraryGA3XWsd',
-];
-
-Meteor.publish('standardLibraries', function(){
-  return Libraries.find({_id: {$in: standardLibraryIds}});
-});
 
 Meteor.publish('libraries', function(){
   this.autorun(function (){
@@ -75,3 +68,24 @@ Meteor.publish('libraryNodes', function(libraryId){
     ];
   });
 });
+
+Meteor.publish('descendantLibraryNodes', function(nodeId){
+  let node = LibraryNodes.findOne(nodeId);
+  let libraryId = node?.ancestors[0]?.id;
+  if (!libraryId) return [];
+  this.autorun(function (){
+    let userId = this.userId;
+    let library = Libraries.findOne(libraryId);
+    try { assertViewPermission(library, userId) }
+    catch(e){
+      return this.error(e);
+    }
+    return [
+      LibraryNodes.find({
+        'ancestors.id': nodeId,
+      }, {
+        sort: {order: 1},
+      }),
+    ];
+  });
+});

app/imports/server/publications/ownedDocuments.js

@@ -1,4 +1,4 @@
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import Libraries from '/imports/api/library/Libraries.js';
 
 Meteor.publish('ownedDocuments', function(){

app/imports/server/publications/searchLibraryNodes.js

@@ -0,0 +1,116 @@
+import { check } from 'meteor/check';
+import Libraries from '/imports/api/library/Libraries.js';
+import LibraryNodes from '/imports/api/library/LibraryNodes.js';
+
+Meteor.publish('searchLibraryNodes', function(){
+  let self = this;
+  this.autorun(function (){
+    let type = self.data('type');
+    if (!type) return [];
+
+    let userId = this.userId;
+    if (!userId) {
+      return [];
+    }
+
+    // Get all the ids of libraries the user can access
+    const user = Meteor.users.findOne(userId, {
+      fields: {subscribedLibraries: 1}
+    });
+    if (!user) return [];
+
+    const subs = user.subscribedLibraries || [];
+    let libraries = Libraries.find({
+      $or: [
+        {owner: this.userId},
+        {writers: this.userId},
+        {readers: this.userId},
+        {_id: {$in: subs}},
+      ]
+    }, {
+      fields: {_id: 1, name: 1},
+    });
+    let libraryIds = libraries.map(lib => lib._id);
+
+    // Build a filter for nodes in those libraries that match the type
+    let filter = {
+      'ancestors.id': {$in: libraryIds},
+      removed: {$ne: true},
+      tags: {$ne: []}, // Only tagged library nodes are considered
+    };
+    if (type){
+      filter.$or = [{
+          type,
+        },{
+          type: 'slotFiller',
+          slotFillerType: type,
+      }];
+    }
+
+    this.autorun(function(){
+      // Get the limit of the documents the user can fetch
+      var limit = self.data('limit') || 32;
+      check(limit, Number);
+
+      // Get the search term
+      let searchTerm = self.data('searchTerm') || '';
+      check(searchTerm, String);
+
+      let options = undefined;
+      if (searchTerm){
+        filter.$text = {$search: searchTerm};
+        options = {
+          // relevant documents have a higher score.
+          fields: {
+            score: { $meta: 'textScore' }
+          },
+          sort: {
+            // `score` property specified in the projection fields above.
+            score: { $meta: 'textScore' },
+            'ancestors.0.id': 1,
+            name: 1,
+            order: 1,
+          }
+        }
+      } else {
+        delete filter.$text
+        options = {sort: {
+          'ancestors.0.id': 1,
+          name: 1,
+          order: 1,
+        }};
+      }
+      options.limit = limit;
+
+      this.autorun(function () {
+        self.setData('countAll', LibraryNodes.find(filter).count());
+      });
+
+      let cursor = LibraryNodes.find(filter, options);
+
+      Mongo.Collection._publishCursor(libraries, self, 'libraries');
+
+      let observeHandle = cursor.observeChanges({
+          added: function (id, fields) {
+            fields._searchResult = true;
+            self.added('libraryNodes', id, fields);
+          },
+          changed: function (id, fields) {
+            self.changed('libraryNodes', id, fields);
+          },
+          removed: function (id) {
+            self.removed('libraryNodes', id);
+          }
+        },
+        // Publications don't mutate the documents
+        { nonMutatingCallbacks: true }
+      );
+
+      // register stop callback (expects lambda w/ no args).
+      this.onStop(function () {
+        observeHandle.stop();
+      });
+      // this.ready();
+    });
+  });
+});

app/imports/server/publications/singleCharacter.js

@@ -1,8 +1,8 @@
 import SimpleSchema from 'simpl-schema';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import { assertViewPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertViewPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import recomputeInvetory from '/imports/api/creature/denormalise/recomputeInventory.js';
 import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import VERSION from '/imports/constants/VERSION.js';

app/imports/server/publications/tabletops.js

@@ -1,5 +1,5 @@
 import Tabletops from '/imports/api/tabletop/Tabletops.js';
-import Creatures from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
 import Messages from '/imports/api/tabletop/Messages.js';
 
 Meteor.publish('tabletops', function(){

app/imports/ui/components/ColorPicker.vue

@@ -10,7 +10,7 @@
         icon
         v-on="on"
       >
-        <v-icon>format_paint</v-icon>
+        <v-icon>mdi-format-paint</v-icon>
       </v-btn>
     </template>
     <v-card class="overflow-hidden">
@@ -30,7 +30,7 @@
                 v-if="kebabColor === colorOption"
                 :class="{dark: isDark(colorOption, shade)}"
               >
-                check
+                mdi-check
               </v-icon>
             </v-scroll-y-transition>
           </div>
@@ -58,7 +58,7 @@
                   v-if="kebabShade === shadeOption"
                   :class="isDark(color, shade) ? 'dark' : 'light'"
                 >
-                  check
+                  mdi-check
                 </v-icon>
               </v-scroll-y-transition>
             </div>

app/imports/ui/components/IncrementButton.vue

@@ -14,7 +14,7 @@
         @click.stop
       >
         <slot>
-          <v-icon>add</v-icon>
+          <v-icon>mdi-plus</v-icon>
         </slot>
       </v-btn>
     </template>

app/imports/ui/components/IncrementMenu.vue

@@ -15,14 +15,14 @@
         class="filled"
         @click="toggleAdd(); $nextTick(() => $refs.editInput.focus())"
       >
-        <v-icon>add</v-icon>
+        <v-icon>mdi-plus</v-icon>
       </v-btn>
       <v-btn
         :disabled="context.editPermission === false"
         class="filled"
         @click="toggleSubtract(); $nextTick(() => $refs.editInput.focus())"
       >
-        <v-icon>remove</v-icon>
+        <v-icon>mdi-minus</v-icon>
       </v-btn>
     </v-btn-toggle>
     <v-text-field
@@ -48,7 +48,7 @@
       class="mx-2 filled"
       @click="commitEdit"
     >
-      <v-icon>done</v-icon>
+      <v-icon>mdi-check</v-icon>
     </v-btn>
     <v-btn
       :small="!flat"
@@ -58,7 +58,7 @@
       class="filled"
       @click="cancelEdit"
     >
-      <v-icon>close</v-icon>
+      <v-icon>mdi-close</v-icon>
     </v-btn>
     <v-spacer />
   </v-layout>
@@ -117,11 +117,11 @@
 			operationIcon(operation) {
 				switch (operation) {
 					case 'set':
-						return 'forward';
+						return 'mdi-forward';
 					case 'add':
-            return 'add';
+            return 'mdi-plus';
 					case 'subtract':
-						return 'remove';
+						return 'mdi-minus';
 				}
 			},
 			toggleAdd(){

app/imports/ui/components/SharedIcon.vue

@@ -0,0 +1,47 @@
+<template lang="html">
+  <v-tooltip
+    v-if="accessRights === 'reader' || accessRights === 'writer'"
+    bottom
+  >
+    <template #activator="{ on }">
+      <v-icon
+        style="opacity: 0.4"
+        v-on="on"
+      >
+        {{ accessRights === 'reader' ? 'mdi-file-eye' : 'mdi-file-edit' }}
+      </v-icon>
+    </template>
+    <span>{{ accessText }}</span>
+  </v-tooltip>
+</template>
+
+<script lang="js">
+export default {
+  props:{
+    model: {
+      type: Object,
+      required: true,
+    },
+  },
+  meteor:{
+    accessRights(){
+      let userId = Meteor.userId();
+      if (this.model.owner === userId) return 'owner'
+      else if (this.model.writers.includes(userId)) return 'writer';
+      else if (this.model.readers.includes(userId)) return 'reader';
+      else if (this.model.public) return 'public';
+      else return 'denied'
+    },
+    accessText(){
+      switch (this.accessRights){
+        case 'writer': return 'Shared with edit permission';
+        case 'reader': return 'Shared as view-only';
+        case 'public': return 'Shared as publicly viewable';
+      }
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

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

@@ -11,7 +11,7 @@
       <v-text-field
         :value="formattedSafeValue"
         v-bind="$attrs"
-        prepend-icon="event"
+        prepend-icon="mdi-calendar"
         readonly
         :loading="loading"
         :error-messages="errors"

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

@@ -24,29 +24,29 @@
             v-else
             large
           >
-            highlight_alt
+            mdi-select-search
           </v-icon>
         </v-btn>
       </div>
     </template>
     <v-card>
       <v-card-text>
-        <div class="layout">
+        <div class="layout row align-center">
           <text-field
             ref="iconSearchField"
             label="Search icons"
-            append-icon="search"
+            append-icon="mdi-magnify"
             clearable
+            hide-details
+            class="ma-2"
             :value="searchString"
             @change="search"
           />
           <v-btn
-            icon
+            text
             @click="select()"
           >
-            <v-icon>
-              cancel
-            </v-icon>
+            clear
           </v-btn>
         </div>
         <v-layout

app/imports/ui/components/propertyToolbar.vue

@@ -6,10 +6,11 @@
     :flat="flat"
   >
     <v-btn
+      v-if="!embedded"
       icon
       @click="back"
     >
-      <v-icon>arrow_back</v-icon>
+      <v-icon>mdi-arrow-left</v-icon>
     </v-btn>
     <property-icon
       :model="model"
@@ -49,7 +50,7 @@
               data-id="property-toolbar-menu-button"
               v-on="on"
             >
-              <v-icon>more_vert</v-icon>
+              <v-icon>mdi-dots-vertical</v-icon>
             </v-btn>
           </template>
           <v-list>
@@ -63,7 +64,7 @@
                 </v-list-item-title>
               </v-list-item-content>
               <v-list-item-action>
-                <v-icon>file_copy</v-icon>
+                <v-icon>mdi-content-copy</v-icon>
               </v-list-item-action>
             </v-list-item>
             <v-list-item
@@ -76,7 +77,7 @@
                 </v-list-item-title>
               </v-list-item-content>
               <v-list-item-action>
-                <v-icon>send</v-icon>
+                <v-icon>mdi-send</v-icon>
               </v-list-item-action>
             </v-list-item>
             <v-list-item
@@ -89,7 +90,7 @@
                 </v-list-item-title>
               </v-list-item-content>
               <v-list-item-action>
-                <v-icon>delete</v-icon>
+                <v-icon>mdi-delete</v-icon>
               </v-list-item-action>
             </v-list-item>
           </v-list>
@@ -111,13 +112,13 @@
           v-if="editing"
           key="doneIcon"
         >
-          done
+          mdi-check
         </v-icon>
         <v-icon
           v-else
           key="createIcon"
         >
-          create
+          mdi-pencil
         </v-icon>
       </v-slide-y-transition>
     </v-btn>
@@ -143,6 +144,7 @@ export default {
     },
     flat: Boolean,
     editing: Boolean,
+    embedded: Boolean,
   },
   computed: {
     isDark(){

app/imports/ui/components/snackbars/SnackbarQueue.vue

@@ -32,7 +32,7 @@
         v-bind="attrs"
         @click="closeSnackbar"
       >
-        <v-icon>close</v-icon>
+        <v-icon>mdi-close</v-icon>
       </v-btn>
     </template>
   </v-snackbar>

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

@@ -1,7 +1,10 @@
 <template lang="html">
   <v-sheet
     class="tree-node"
-    :class="!hasChildren ? 'empty' : null"
+    :class="{
+      'empty': !hasChildren,
+      'found': node._matchedDocumentFilter,
+    }"
     :data-id="`tree-node-${node._id}`"
   >
     <div
@@ -18,7 +21,7 @@
         @click.stop="expanded = !expanded"
       >
         <v-icon v-if="canExpand && (hasChildren || organize)">
-          chevron_right
+          mdi-chevron-right
         </v-icon>
       </v-btn>
       <div
@@ -31,7 +34,7 @@
           :class="selected && 'primary--text'"
           :disabled="expanded"
         >
-          drag_handle
+          mdi-drag
         </v-icon>
         <!--{{node && node.order}}-->
         <tree-node-view
@@ -52,7 +55,7 @@
             :children="computedChildren"
             :group="group"
             :organize="organize"
-            :selected-node-id="selectedNodeId"
+            :selected-node="selectedNode"
             @reordered="e => $emit('reordered', e)"
             @reorganized="e => $emit('reorganized', e)"
             @selected="e => $emit('selected', e)"
@@ -80,6 +83,7 @@
 	import { canBeParent } from '/imports/api/parenting/parenting.js';
 	import { getPropertyIcon } from '/imports/constants/PROPERTIES.js';
   import TreeNodeView from '/imports/ui/properties/treeNodeViews/TreeNodeView.vue';
+  import { some } from 'lodash';
 
 	export default {
 		name: 'TreeNode',
@@ -87,16 +91,33 @@
       TreeNodeView,
     },
 		props: {
-			node: Object,
-			group: String,
+			node: {
+        type: Object,
+        required: true,
+      },
+			group: {
+        type: String,
+        required: true,
+      },
 			organize: Boolean,
-			children: Array,
-			getChildren: Function,
-			selectedNodeId: String,
+			children: {
+        type: Array,
+        default: () => [],
+      },
+			getChildren: {
+        type: Function,
+        default: undefined,
+      },
+      selectedNode: {
+        type: Object,
+        default: undefined,
+      },
 			selected: Boolean,
 		},
-		data(){ return {
-			expanded: false,
+		data(){return {
+			expanded: this.node._ancestorOfMatchedDocument ||
+        some(this.selectedNode?.ancestors, ref => ref.id === this.node._id) ||
+        false,
 		}},
 		computed: {
 			hasChildren(){
@@ -119,6 +140,15 @@
 				return canBeParent(this.node.type);
 			},
 		},
+    watch: {
+      'node._ancestorOfMatchedDocument'(value){
+        this.expanded = !!value ||
+          some(this.selectedNode?.ancestors, ref => ref.id === this.node._id);
+      },
+      'selectedNode.ancestors'(value){
+        this.expanded = !!some(value, ref => ref.id === this.node._id) || this.expanded;
+      },
+    },
 		beforeCreate() {
       this.$options.components.TreeNodeList = require('./TreeNodeList.vue').default
 		},
@@ -148,9 +178,12 @@
 	.empty .v-btn {
 		opacity: 0.4;
 	}
+  .found {
+    background: rgba(200, 0, 0, 0.1);
+  }
 	.ghost {
     opacity: 0.5;
-    background: #fbc8c8;
+    background: rgba(251, 0, 0, 0.3);
 	}
 	.v-icon.v-icon--disabled {
 		opacity: 0;

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

@@ -18,8 +18,9 @@
       :node="child.node"
       :children="child.children"
       :group="group"
-      :selected-node-id="selectedNodeId"
-      :selected="selectedNodeId === child.node._id"
+      :selected-node="selectedNode"
+      :selected="selectedNode && selectedNode._id === child.node._id"
+      :ancestors-of-selected-node="ancestorsOfSelectedNode"
       :organize="organize"
       :lazy="lazy"
       @selected="e => $emit('selected', e)"
@@ -49,7 +50,14 @@
 				type: Array,
 				default: () => [],
 			},
-			selectedNodeId: String,
+			selectedNode: {
+        type: Object,
+        default: undefined,
+      },
+      ancestorsOfSelectedNode: {
+        type: Array,
+        default: () => [],
+      },
 		},
 		data(){ return {
 			expanded: false,

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

@@ -0,0 +1,81 @@
+<template lang="html">
+  <v-combobox
+    v-model="filterTerms"
+    :items="filterOptions"
+    prepend-inner-icon="mdi-magnify"
+    hide-no-data
+    hide-selected
+    multiple
+    clearable
+    small-chips
+    deletable-chips
+  />
+</template>
+
+<script lang="js">
+export default {
+  props: {
+    value: {
+      type: Object,
+      default: undefined,
+    },
+  },
+  data(){return {
+    filterTerms: [],
+    filterOptions: [
+      {text: 'Actions', value: 'action'},
+      {text: 'Attacks', value: 'attack'},
+      {text: 'Attributes', value: 'attribute'},
+      {text: 'Buffs', value: 'buff'},
+      {text: 'Class Levels', value: 'classLevel'},
+      {text: 'Damage Multipliers', value: 'damageMultiplier'},
+      {text: 'Effects', value: 'effect'},
+      {text: 'Experiences', value: 'experience'},
+      {text: 'Features', value: 'feature'},
+      {text: 'Folders', value: 'folder'},
+      {text: 'Notes', value: 'note'},
+      {text: 'Proficiencies', value: 'proficiency'},
+      {text: 'Rolls', value: 'roll'},
+      {text: 'Saving Throws', value: 'savingThrow'},
+      {text: 'Skills', value: 'skill'},
+      {text: 'Spell Lists', value: 'spellList'},
+      {text: 'Spells', value: 'spell'},
+      {text: 'Containers', value: 'container'},
+      {text: 'Items', value: 'item'},
+    ],
+  }},
+  computed: {
+    filter(){
+      if (!this.filterTerms.length) return;
+      let typeFilters = [];
+      let nameFilters = [];
+      this.filterTerms.forEach(filter => {
+        if (filter.value){
+          typeFilters.push(filter.value);
+        } else {
+          // escape string
+          let term = filter.replace( /[-/\\^$*+?.()|[\]{}]/g, '\\$&' );
+          var reg = new RegExp( '.*' + term + '.*', 'i' );
+          nameFilters.push(reg)
+        }
+      });
+      let filter = {};
+      if (typeFilters.length){
+        filter.type = {$in: typeFilters};
+      }
+      if (nameFilters.length){
+        filter.name = {$in: nameFilters};
+      }
+      return filter;
+    },
+  },
+  watch:{
+    filter(value){
+      this.$emit('input', value);
+    }
+  }
+}
+</script>
+
+<style lang="css" scoped>
+</style>

app/imports/ui/creature/CreatureFormDialog.vue

@@ -29,11 +29,11 @@
 </template>
 
 <script lang="js">
-import Creatures from '/imports/api/creature/Creatures.js';
-import {updateCreature} from '/imports/api/creature/Creatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import updateCreature from '/imports/api/creature/creatures/methods/updateCreature.js';
 import DialogBase from '/imports/ui/dialogStack/DialogBase.vue';
 import CreatureForm from '/imports/ui/creature/CreatureForm.vue'
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
+import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import ColorPicker from '/imports/ui/components/ColorPicker.vue';
 
 export default {

app/imports/ui/creature/CreatureListTile.vue

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