Merge branch 'version-2-dev' into version-2

README.md

@@ -66,5 +66,20 @@ 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">
+DISABLE_PATREON=<"true" if you want to prevent features being locked behind Patreon tiers>
+```
+
 Now, visiting [](http://localhost:3000/) should show you an empty instance of
 DiceCloud running.

app/.meteor/packages

@@ -3,50 +3,44 @@
 # 'meteor add' and 'meteor remove' will edit this file for you,
 # but you can also edit it by hand.
 
-accounts-password@1.6.2
+accounts-password
-accounts-ui@1.3.1
+random
-random@1.2.0
 dburles:collection-helpers
-reactive-var@1.0.11
+reactive-var
-underscore@1.0.10
+underscore
 momentjs:moment
 dburles:mongo-collection-instances
-percolate:migrations
+accounts-google
-accounts-google@1.3.3
+email
-email@2.0.0
 meteorhacks:subs-manager
 chuangbo:marked
-meteor-base@1.4.0
+meteor-base
-mobile-experience@1.1.0
+mobile-experience
-mongo@1.10.0
+mongo
-session@1.2.0
+session
-jquery@1.11.10
+tracker
-tracker@1.2.0
+logging
-logging@1.1.20
+reload
-reload@1.3.0
+ejson
-ejson@1.1.1
+check
-check@1.3.1
+standard-minifier-js
-standard-minifier-js@2.6.0
+shell-server
-shell-server@0.5.0
-seba:minifiers-autoprefixer
 templates:array
-ecmascript@0.14.3
+ecmascript
-es5-shim@4.8.0
+es5-shim
-reactive-dict@1.3.0
+reactive-dict
 percolate:synced-cron
 ongoworks:speakingurl
-service-configuration@1.0.11
+service-configuration
-google-config-ui@1.0.1
+dynamic-import
-dynamic-import@0.5.2
+ddp-rate-limiter
-ddp-rate-limiter@1.0.9
+rate-limit
-rate-limit@1.0.9
-meteortesting:mocha
 mdg:validated-method
 akryum:vue-router2
 static-html
-aldeed:collection2@3.0.0
+aldeed:collection2
 aldeed:schema-index
-akryum:vue-component
+zer0th:meteor-vuetify-loader
 accounts-patreon
 bozhao:link-accounts
 peerlibrary:reactive-publish
@@ -54,3 +48,6 @@ simple:rest
 simple:rest-method-mixin
 mikowals:batch-insert
 peerlibrary:subscription-data
+seba:minifiers-autoprefixer
+akryum:vue-component
+akryum:vue-sass

app/.meteor/release

@@ -1 +1 @@
-METEOR@1.11.1
+METEOR@2.2.1

app/.meteor/versions

@@ -1,29 +1,27 @@
-accounts-base@1.7.0
+accounts-base@1.9.0
 accounts-google@1.3.3
 accounts-oauth@1.2.0
-accounts-password@1.6.2
+accounts-password@1.7.1
 accounts-patreon@0.1.0
-accounts-ui@1.3.1
-accounts-ui-unstyled@1.4.2
 akryum:npm-check@0.1.2
 akryum:vue-component@0.15.2
 akryum:vue-component-dev-client@0.4.7
 akryum:vue-component-dev-server@0.1.4
 akryum:vue-router2@0.2.3
-aldeed:collection2@3.2.1
+akryum:vue-sass@0.1.2
+aldeed:collection2@3.4.1
 aldeed:schema-index@3.0.0
 allow-deny@1.1.0
-autoupdate@1.6.0
+autoupdate@1.7.0
-babel-compiler@7.5.3
+babel-compiler@7.6.2
 babel-runtime@1.5.0
 base64@1.0.12
 binary-heap@1.0.11
-blaze@2.3.4
+blaze-tools@1.1.2
-blaze-tools@1.0.10
 boilerplate-generator@1.7.1
-bozhao:link-accounts@2.2.1
+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
@@ -32,65 +30,56 @@ 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.3.3
+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.5.3
+dynamic-import@0.6.0
-ecmascript@0.14.3
+ecmascript@0.15.1
 ecmascript-runtime@0.7.0
-ecmascript-runtime-client@0.11.0
+ecmascript-runtime-client@0.11.1
-ecmascript-runtime-server@0.10.0
+ecmascript-runtime-server@0.10.1
 ejson@1.1.1
 email@2.0.0
 es5-shim@4.8.0
 fetch@0.1.1
 geojson-utils@1.0.10
-google-config-ui@1.0.1
 google-oauth@1.3.0
 hot-code-push@1.0.4
-html-tools@1.0.11
+html-tools@1.1.2
-htmljs@1.0.11
+htmljs@1.1.1
-http@1.4.2
+http@1.4.4
-id-map@1.1.0
+id-map@1.1.1
 inter-process-messaging@0.1.1
-jquery@1.11.11
 lai:collection-extensions@0.2.1_1
-launch-screen@1.2.0
+launch-screen@1.2.1
-less@2.8.0
 livedata@1.0.18
-lmieulet:meteor-coverage@1.1.4
 localstorage@1.2.0
-logging@1.1.20
+logging@1.2.0
 mdg:validated-method@1.2.0
 meteor@1.9.3
 meteor-base@1.4.0
-meteorhacks:picker@1.0.3
 meteorhacks:subs-manager@1.6.4
-meteortesting:browser-tests@1.3.4
-meteortesting:mocha@1.1.5
-meteortesting:mocha-core@7.0.1
 mikowals:batch-insert@1.2.0
-minifier-css@1.5.3
+minifier-css@1.5.4
-minifier-js@2.6.0
+minifier-js@2.6.1
-minimongo@1.6.0
+minimongo@1.6.2
 mobile-experience@1.1.0
 mobile-status-bar@1.1.0
 modern-browsers@0.1.5
-modules@0.15.0
+modules@0.16.0
 modules-runtime@0.12.0
 momentjs:moment@2.29.1
-mongo@1.10.0
+mongo@1.11.1
-mongo-decimal@0.1.1
+mongo-decimal@0.1.2
 mongo-dev-server@1.1.0
-mongo-id@1.0.7
+mongo-id@1.0.8
-npm-bcrypt@0.9.3
+npm-bcrypt@0.9.4
-npm-mongo@3.8.1
+npm-mongo@3.9.0
 oauth@1.3.2
 oauth2@1.3.0
-observe-sequence@1.0.16
 ongoworks:speakingurl@9.0.0
 ordered-dict@1.1.0
 patreon-oauth@0.1.0
@@ -104,18 +93,18 @@ peerlibrary:reactive-mongo@0.4.0
 peerlibrary:reactive-publish@0.10.0
 peerlibrary:server-autorun@0.8.0
 peerlibrary:subscription-data@0.8.0
-percolate:migrations@0.9.8
 percolate:synced-cron@1.3.2
 promise@0.11.2
-raix:eventemitter@0.1.3
+raix:eventemitter@1.0.0
 random@1.2.0
 rate-limit@1.0.9
+react-fast-refresh@0.1.1
 reactive-dict@1.3.0
 reactive-var@1.0.11
-reload@1.3.0
+reload@1.3.1
 retry@1.1.0
 routepolicy@1.1.0
-seba:minifiers-autoprefixer@1.2.1
+seba:minifiers-autoprefixer@2.0.1
 service-configuration@1.0.11
 session@1.2.0
 sha@1.0.9
@@ -123,20 +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
+socket-stream-client@0.3.3
-spacebars@1.0.15
+spacebars-compiler@1.3.0
-spacebars-compiler@1.1.3
 srp@1.1.0
-standard-minifier-js@2.6.0
+standard-minifier-js@2.6.1
-static-html@1.2.2
+static-html@1.3.2
 templates:array@1.0.3
-templating@1.3.2
+templating-tools@1.2.1
-templating-compiler@1.3.3
+tmeasday:check-npm-versions@1.0.2
-templating-runtime@1.3.2
-templating-tools@1.1.2
-tmeasday:check-npm-versions@0.3.2
 tracker@1.2.0
+typescript@4.2.2
 underscore@1.0.10
-url@1.3.1
+url@1.3.2
-webapp@1.9.1
+webapp@1.10.1
-webapp-hashing@1.0.9
+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/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/applyAction.js

@@ -4,7 +4,7 @@ import embedInlineCalculations from '/imports/api/creature/computation/afterComp
 export default function applyAction({prop, log}){
   let content = { name: prop.name };
   if (prop.summary){
-    content.description = embedInlineCalculations(
+    content.value = embedInlineCalculations(
       prop.summary, prop.summaryCalculations
     );
   }

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

@@ -13,42 +13,43 @@ export default function applyAdjustment({
     ...creature.variables,
     ...actionContext,
   };
-  try {
+  var {result, context} = evaluateString({
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce');
+    string: prop.amount,
-    if (typeof result !== 'number') {
+    scope,
-      log.content.push({
+    fn: 'reduce'
-        name: 'Attribute damage',
+  });
-        error: errors.join(', ') || 'Something went wrong',
+  context.errors.forEach(e => {
-      });
-    }
-  } catch (e){
     log.content.push({
-      name: 'Attribute damage',
+      name: 'Attribute damage error',
-      error: e.toString(),
+      value: e.message || e.toString(),
     });
-  }
+  });
   if (damageTargets) {
     damageTargets.forEach(target => {
       if (prop.target === 'each'){
-        result = evaluateString(prop.amount, scope, 'reduce');
+        ({result} = evaluateString({
+          string: prop.amount,
+          scope,
+          fn: 'reduce'
+        }));
       }
       damagePropertiesByName.call({
         creatureId: target._id,
         variableName: prop.stat,
         operation: prop.operation || 'increment',
-        value: result
+        value: result.value,
       });
       log.content.push({
         name: 'Attribute damage',
-        resultPrefix: `${prop.stat} ${prop.operation === 'set' ? 'set to' : ''}`,
+        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-        result: `${-result}`,
+        ` ${result.isNumber ? -result.value : result.toString()}`,
       });
     });
   } else {
     log.content.push({
       name: 'Attribute damage',
-      resultPrefix: `${prop.stat} ${prop.operation === 'set' ? 'set to' : ''}`,
+      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-      result: `${-result}`,
+      ` ${result.isNumber ? -result.value : result.toString()}`,
     });
   }
 }

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

@@ -17,7 +17,6 @@ export default function applyAttack({
 
   log.content.push({
     name: criticalHit ? 'Critical Hit!' : 'To Hit',
-    resultPrefix: `1d20 [${value}] + ${prop.rollBonusResult} = `,
+    value: `1d20 [${value}] + ${prop.rollBonusResult} = ` + result,
-    result,
   });
 }

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

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

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

@@ -15,75 +15,101 @@ export default function applyDamage({
     ...creature.variables,
     ...actionContext,
   };
+  // Add the target's variables to the scope
   if (targets.length === 1){
     scope.target = targets[0].variables;
   }
+  // Determine if the hit is critical
   let criticalHit = !!(
     actionContext.criticalHit &&
     actionContext.criticalHit.value &&
     prop.damageType !== 'healing' // Can't critically heal
   );
+  // Double the damage rolls if the hit is critical
   let context = new CompilationContext({
     doubleRolls: criticalHit,
   });
-  try {
+
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce', context);
+  // Compute the roll the first time, logging any errors
-    if (typeof result !== 'number') {
+  var {result} = evaluateString({
-      log.content.push({
+    string: prop.amount,
-        error: errors.join(', '),
+    scope,
-      });
+    fn: 'reduce',
-    }
+    context
-  } catch (e){
+  });
+
+  // If the result is an error bail out now
+  if (result.constructor.name === 'ErrorNode'){
     log.content.push({
-      error: e.toString(),
+      name: 'Damage error',
+      value: result.toString(),
     });
+    return;
   }
-  let suffix = (criticalHit ? ' critical ' : '') +
+
+  // Memoise the damage suffix for the log
+  let suffix = (criticalHit ? ' critical ' : ' ') +
     prop.damageType +
-    (prop.damageType !== 'healing' ? ' damage': '');
+    (prop.damageType !== ' healing ' ? ' damage ': '');
 
   if (damageTargets && damageTargets.length) {
+    // Iterate through all the targets
     damageTargets.forEach(target => {
       let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
+
+      // Reroll the damage if needed
       if (prop.target === 'each'){
-        result = evaluateString(prop.amount, scope, 'reduce');
+        ({result, context} = evaluateString({
+          string: prop.amount,
+          scope,
+          fn: 'reduce'
+        }));
       }
+      // If the result is an error or not a number bail out now
+      if (result.constructor.name === 'ErrorNode' || !result.isNumber){
+        log.content.push({
+          name: 'Damage error',
+          value: result.toString(),
+        });
+        return;
+      }
+
+      // Deal the damage to the target
       let damageDealt = dealDamage.call({
         creatureId: target._id,
         damageType: prop.damageType,
-        amount: result,
+        amount: result.value,
       });
+
+      // Log the damage done
       if (target._id === creature._id){
+        // Target is same as self, log damage as such
         log.content.push({
           name,
-          result: damageDealt,
+          value: damageDealt + suffix + ' to self',
-          details: suffix + 'to self',
         });
       } else {
         log.content.push({
           name,
-          resultPrefix: 'Dealt ',
+          value: 'Dealt ' + damageDealt + suffix + ` ${target.name && ' to '}${target.name}`,
-          result: damageDealt,
-          details: suffix + `${target.name && ' to '}${target.name}`,
         });
+        // Log the damage received on that creature's log as well
         insertCreatureLog.call({
           log: {
+            creatureId: target._id,
             content: [{
               name,
-              resultPrefix: 'Recieved ',
+              value: 'Recieved ' + damageDealt + suffix,
-              result: damageDealt,
-              details: suffix,
             }],
-            creatureId: target._id,
           }
         });
       }
     });
   } else {
+    // There are no targets, just log the result
     log.content.push({
       name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
-      result,
+      value: result.toString() + suffix,
-      details: suffix,
     });
   }
 }

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

@@ -10,7 +10,7 @@ import applySave from '/imports/api/creature/actions/applySave.js';
 function applyProperty(options){
   let prop = options.prop;
   if (prop.type === 'buff'){
-    // ignore only applied buffs
+    // ignore only applied buffs, don't apply them again
     if (prop.applied === true){
       return false;
     }
@@ -40,7 +40,7 @@ function applyProperty(options){
       break;
     case 'buff':
       applyBuff(options);
-      break;
+      return false;
     case 'toggle':
       return applyToggle(options);
     case 'roll':
@@ -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/applyRoll.js

@@ -10,23 +10,16 @@ export default function applyRoll({
     ...creature.variables,
     ...actionContext,
   };
-  try {
+  var {result} = evaluateString({
-    var {result, errors} = evaluateString(prop.roll, scope, 'reduce');
+    string: prop.roll,
-    actionContext[prop.variableName] = result;
+    scope,
-    log.content.push({
+    fn: 'reduce'
-      name: prop.name,
+  });
-      resultPrefix: prop.variableName + ' = ' + prop.roll + ' = ',
+  if (result.isNumber){
-      result,
+    actionContext[prop.variableName] = result.value;
-    });
-    if (errors.length) {
-      log.content.push({
-        error: errors.join(', '),
-      });
-    }
-
-  } catch (e){
-    log.content.push({
-      error: e.toString(),
-    });
   }
+  log.content.push({
+    name: prop.name,
+    value: prop.variableName + ' = ' + prop.roll + ' = ' + result.toString(),
+  });
 }

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

@@ -14,19 +14,16 @@ export default function applySave({
   };
   try {
     // Calculate the DC
-    var {result, errors} = evaluateString(prop.dc, scope, 'reduce');
+    var {result} = evaluateString({
-    let dc = result;
+      string: prop.dc,
+      scope,
+      fn: 'reduce'
+    });
+    let dc = result.value;
     log.content.push({
       name: prop.name,
-      resultPrefix: ' DC ',
+      value: ' DC ' + result.toString(),
-      result,
     });
-    if (errors.length) {
-      log.content.push({
-        error: errors.join(', '),
-      });
-      return false;
-    }
     if (prop.target === 'self'){
       let save = CreaturesProperties.findOne({
         'ancestors.id': creature._id,
@@ -38,7 +35,8 @@ export default function applySave({
       });
       if (!save){
         log.content.push({
-          error: 'No saving throw found: ' + prop.stat,
+          name: 'Saving throw error',
+          value: 'No saving throw found: ' + prop.stat,
         });
         return;
       }
@@ -62,9 +60,7 @@ export default function applySave({
       let saveSuccess = result >= dc;
       log.content.push({
         name: 'Save',
-        resultPrefix,
+        value: resultPrefix + result + (saveSuccess ? 'Passed' : 'Failed')
-        result,
-        details: saveSuccess ? 'Passed' : 'Failed'
       });
       return !saveSuccess;
     } else {
@@ -73,7 +69,8 @@ export default function applySave({
     }
   } catch (e){
     log.content.push({
-      error: e.toString(),
+      name: 'Save error',
+      value: e.toString(),
     });
   }
 }

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

@@ -13,23 +13,21 @@ export default function applyToggle({
   if (Number.isFinite(+prop.condition)){
     return !!+prop.condition;
   }
-  try {
+  var {result} = evaluateString({
-    var {result, errors} = evaluateString(prop.condition, scope, 'reduce');
+    string: prop.condition,
-    if (typeof result !== 'number' && typeof result !== 'boolean') {
+    scope,
-      log.content.push({
+    fn: 'reduce'
-        error: errors.join(', '),
+  });
-      });
+  if (result.constructor.name === 'ErrorNode') {
-      return false;
-    }
     log.content.push({
-      name: prop.name,
+      name: 'Toggle error',
-      resultPrefix: prop.condition + ' = ',
+      value: result.toString(),
-      result,
-    });
-    return !!result;
-  } catch (e){
-    log.content.push({
-      error: e.toString(),
     });
+    return false;
   }
+  log.content.push({
+    name: prop.name || 'Toggle',
+    value: prop.condition + ' = ' + result.toString(),
+  });
+  return !!result.value;
 }

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,11 +62,13 @@ const castSpellWithSlot = new ValidatedMethod({
         value: 1,
       });
     }
+    let actionContext = getAncestorContext(spell);
+
 		doActionWork({
       action: spell,
-      context: {slotLevel},
+      actionContext: {slotLevel, ...actionContext},
       creature,
-      target,
+      targets: target ? [target] : [],
       method: this,
     });
     // Note this only recomputes the top-level creature, not the nearest one

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

@@ -2,14 +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 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',
@@ -35,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 => {
@@ -42,13 +48,18 @@ 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);
+
+    // The action might add properties which need to be activated
+    recomputeInactiveProperties(creature._id);
+
     // recompute creatures
 		recomputeCreatureByDoc(creature);
     targets.forEach(target => {
+      recomputeInactiveProperties(target._id);
       recomputeCreatureByDoc(target);
     });
   },
@@ -58,7 +69,7 @@ export function doActionWork({
   action,
   creature,
   targets,
-  context = {},
+  actionContext = {},
   method
 }){
   // Create the log
@@ -77,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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.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/actions/spendResources.js

@@ -51,7 +51,7 @@ export default function spendResources({prop, log}){
   // Now that we have confirmed that there are no errors, do actual work
   //Items
   itemQuantityAdjustments.forEach(adjustQuantityWork);
-  
+
   // Use uses
   if (prop.usesResult){
     CreatureProperties.update(prop._id, {
@@ -61,7 +61,7 @@ export default function spendResources({prop, log}){
     });
     log.content.push({
       name: 'Uses left',
-      result: prop.usesResult - prop.usesUsed - 1,
+      value: prop.usesResult - (prop.usesUsed || 0) - 1,
     });
   }
 
@@ -84,10 +84,10 @@ export default function spendResources({prop, log}){
   // Log all the spending
   if (gainLog.length) log.content.push({
     name: 'Gained',
-    description: gainLog.join('\n'),
+    value: gainLog.join('\n'),
   });
   if (spendLog.length) log.content.push({
     name: 'Spent',
-    description: spendLog.join('\n'),
+    value: spendLog.join('\n'),
   });
 }

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/afterComputation/evaluateString.js

@@ -1,30 +1,67 @@
 import { parse, CompilationContext } from '/imports/parser/parser.js';
 import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
+import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
+import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
 
-export default function evaluateString(string, scope, fn = 'compile', context){
+//TODO replace constants with their parsed node
-  let errors = [];
+
+export default function evaluateString({string, scope, fn = 'compile', context}){
+  if (!context){
+    context = new CompilationContext({});
+  }
   if (!string){
-    errors.push('No string provided');
+    context.storeError('No string provided');
-    return {result: string, errors};
+    return {result: {value: string}, context};
   }
 
-  if (!scope) errors.push('No scope provided');
+  if (!scope) context.storeError('No scope provided');
 
   // Parse the string using mathjs
   let node;
   try {
     node = parse(string);
   } catch (e) {
-    errors.push(e);
+    context.storeError(e);
-    return {result: string, errors};
+    return {result: {value: string}, context};
-  }
-  if (!context){
-    context = new CompilationContext({});
   }
+  node = replaceConstants({calc: node, context, scope});
   let result = node[fn](scope, context);
-  if (result instanceof ConstantNode){
+  return {result, context};
-    return {result: result.value, errors: context.errors}
+}
-  } else {
+
-    return {result: result.toString(), errors: context.errors};
+// Replace constants in the calc with the right ParseNodes
-  }
+function replaceConstants({calc, context, scope}){
+  let constFailed = [];
+  calc = calc.replaceNodes(node => {
+    if (!(node instanceof SymbolNode)) return;
+    let constant = scope[node.name];
+    // replace constants that aren't overridden by stats or disabled by a toggle
+    if (constant && constant.type === 'constant'){
+      // Fail if the constant has errors
+      if (constant.errors && constant.errors.length){
+        constFailed.push(node.name);
+        return;
+      }
+      let parsedConstantNode;
+      try {
+        parsedConstantNode = parse(constant.calculation);
+      } catch(e){
+        constFailed.push(node.name);
+        return;
+      }
+      if (!parsedConstantNode) constFailed.push(node.name);
+      return parsedConstantNode;
+    }
+  });
+  constFailed.forEach(name => {
+    context.storeError({
+      type: 'error',
+      message: `${name} is a constant property with parsing errors`
+    });
+  });
+  let failed = !!constFailed.length;
+  if (failed){
+    calc = new ErrorNode({error: 'Failed to replace constants'});
+  }
+  return calc;
 }

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

@@ -1,13 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-
-// Strings can have computations in bracers like so: {computation}
-export default function evalutateStringWithEmbeddedCalculations(string, scope){
-  console.warn('evalutateStringWithEmbeddedCalculations should be replaced with ' +
-  'fetching the result from the compuations on the property doc');
-	if (!string) return string;
-  // Compute everything inside bracers
-	return string.replace(/\{([^{}]*)\}/g, function(match, p1){
-    let {result} = evaluateString(p1, scope);
-    return result;
-	});
-}

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

@@ -7,6 +7,7 @@ export default class ComputationMemo {
   constructor(props, creature){
     this.statsByVariableName = {};
     this.constantsByVariableName = {};
+    this.constantsById = {};
     this.extraStatsByVariableName = {};
     this.statsById = {};
     this.originalPropsById = {};
@@ -77,11 +78,7 @@ export default class ComputationMemo {
   }
   addConstant(prop){
     prop = this.registerProperty(prop);
-    if (
+    this.constantsById[prop._id] = prop;
-      !this.constantsByVariableName[prop.variableName]
-    ){
-      this.constantsByVariableName[prop.variableName] = prop
-    }
   }
   registerProperty(prop){
     this.originalPropsById[prop._id] = cloneDeep(prop);
@@ -107,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 (
@@ -193,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){
@@ -256,7 +234,6 @@ const propDetailsByType = {
   default(){
     return {
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   },
   toggle(){
@@ -264,7 +241,6 @@ const propDetailsByType = {
       computed: false,
       busyComputing: false,
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   },
   attribute(){
@@ -272,8 +248,8 @@ const propDetailsByType = {
       computed: false,
       busyComputing: false,
       effects: [],
+      proficiencies: [],
       toggleAncestors: [],
-      disabledByToggle: false,
       idsOfSameName: [],
     };
   },
@@ -284,7 +260,6 @@ const propDetailsByType = {
       effects: [],
       proficiencies: [],
       toggleAncestors: [],
-      disabledByToggle: false,
       idsOfSameName: [],
     };
   },
@@ -293,26 +268,22 @@ const propDetailsByType = {
       computed: false,
       busyComputing: false,
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   },
   classLevel(){
     return {
       computed: true,
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   },
   proficiency(){
     return {
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   },
   denormalizedStat(){
     return {
       toggleAncestors: [],
-      disabledByToggle: false,
     };
   }
 }

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){
+  constructor(){
-    delete this.baseValueErrors;
+    this.base = undefined;
-    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;
-    }
     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 (Number.isFinite(result)){
-        if (effect.statBase){
+          if(Number.isFinite(this.base)){
-          if (this.statBaseValue === undefined || result > this.statBaseValue){
+            this.base = Math.max(this.base, result);
-            this.statBaseValue = result;
+          } else {
+            this.base = result;
           }
         }
         break;

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

@@ -2,6 +2,11 @@ import computeToggle from '/imports/api/creature/computation/engine/computeToggl
 import { union } from 'lodash';
 
 export default function applyToggles(prop, memo){
+  // If it used to be inactive delete those fields
+  if (prop.inactive) prop.inactive = undefined;
+  if (prop.deactivatedByAncestor) prop.deactivatedByAncestor = undefined;
+  if (prop.deactivatedByToggle) prop.deactivatedByToggle = undefined;
+  // Iterate through the toggle ancestors from oldest to nearest
   prop.computationDetails.toggleAncestors.forEach(toggleId => {
     let toggle = memo.togglesById[toggleId];
     computeToggle(toggle, memo);
@@ -10,8 +15,11 @@ export default function applyToggles(prop, memo){
       [toggle._id],
       toggle.dependencies,
     );
+    // Deactivate if the toggle is false
     if (!toggle.toggleResult){
-      prop.computationDetails.disabledByToggle = true;
+      prop.inactive = true;
+      prop.deactivatedByAncestor = true;
+      prop.deactivatedByToggle = true;
     }
   });
 }

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

@@ -1,5 +1,5 @@
 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 { union } from 'lodash';
 
@@ -14,7 +14,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;
   }
@@ -32,8 +40,6 @@ function getAggregatorResult(stat, aggregator){
 
 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 +84,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,12 +95,12 @@ 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.computationDetails.disabledByToggle &&
+      !prof.deactivatedByToggle &&
       prof.value > stat.proficiency
     ){
       stat.proficiency = prof.value;
@@ -111,29 +115,37 @@ function combineSkill(stat, aggregator, memo){
   let profBonusStat = memo.statsByVariableName['proficiencyBonus'];
   let profBonus = profBonusStat && profBonusStat.value;
 
-  if (typeof profBonus !== 'number' && memo.statsByVariableName['level']){
+  if (profBonusStat){
-    let level = memo.statsByVariableName['level'].value;
-    profBonus = Math.ceil(level / 4) + 1;
-    if (level._id){
-      stat.dependencies = union(stat.dependencies, [level._id]);
-    }
-    if (level.dependencies){
-      stat.dependencies = union(stat.dependencies, level.dependencies);
-    }
-  } else {
     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;
+    profBonus = Math.ceil(level / 4) + 1;
+    if (levelProp._id){
+      stat.dependencies = union(stat.dependencies, [levelProp._id]);
+    }
+    if (levelProp.dependencies){
+      stat.dependencies = union(stat.dependencies, levelProp.dependencies);
+    }
+  }
+
   // Multiply the proficiency bonus by the actual proficiency
-  profBonus *= stat.proficiency;
+  if(stat.proficiency === 0.49){
-  // Base value
+    // Round down proficiency bonus in the special case
-  stat.baseValue = aggregator.statBaseValue;
+    profBonus = Math.floor(profBonus * 0.5);
-  stat.baseValueErrors = aggregator.baseValueErrors;
+  } 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/computeConstant.js

@@ -0,0 +1,12 @@
+import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
+
+export default function computeConstant(constant, memo){
+  // Apply any toggles
+  applyToggles(constant, memo);
+  if (constant.deactivatedByToggle) return;
+  if (
+    !memo.constantsByVariableName[constant.variableName]
+  ){
+    memo.constantsByVariableName[constant.variableName] = constant
+  }
+}

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

@@ -1,8 +1,11 @@
 import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
 import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
+import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
 import { union } from 'lodash';
 
 export default function computeEndStepProperty(prop, memo){
+  applyToggles(prop, memo);
+
   switch (prop.type){
     case 'action':
     case 'spell':
@@ -75,26 +78,33 @@ function computeAction(prop, memo){
   });
   // Items consumed
   prop.resources.itemsConsumed.forEach((itemConsumed, i) => {
-    let item = itemConsumed.itemId && memo.equipmentById[itemConsumed.itemId];
+    let item = itemConsumed.itemId ?
-    prop.resources.itemsConsumed[i].itemId = item && item._id;
+      memo.equipmentById[itemConsumed.itemId] :
-    let available = item && item.quantity || 0;
+      undefined;
+    let available = item ? item.quantity : 0;
     prop.resources.itemsConsumed[i].available = available;
-    let name = item && item.name;
-    if (item && item.quantity !== 1 && item.plural){
-      name = item.plural;
-    }
-    prop.resources.itemsConsumed[i].itemName = name;
-    prop.resources.itemsConsumed[i].itemIcon = item && item.icon;
-    prop.resources.itemsConsumed[i].itemColor = item && item.color;
     if (!item || available < itemConsumed.quantity){
       prop.insufficientResources = true;
     }
     if (item){
+      prop.resources.itemsConsumed[i].itemId = item._id;
+      let name = item.name;
+      if (item.quantity !== 1 && item.plural){
+        name = item.plural;
+      }
+      if (name) prop.resources.itemsConsumed[i].itemName = name;
+      if (item.icon) prop.resources.itemsConsumed[i].itemIcon = item.icon;
+      if (item.color) prop.resources.itemsConsumed[i].itemColor = item.color;
       prop.dependencies = union(
         prop.dependencies,
         [item._id],
         item.dependencies
       );
+    } else {
+      delete prop.resources.itemsConsumed[i].itemId;
+      delete prop.resources.itemsConsumed[i].itemName;
+      delete prop.resources.itemsConsumed[i].itemIcon;
+      delete prop.resources.itemsConsumed[i].itemColor;
     }
   });
 }

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

@@ -1,4 +1,5 @@
 import { forOwn, has, union } from 'lodash';
+import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
 
 export default function computeLevels(memo){
   computeClassLevels(memo);
@@ -7,11 +8,13 @@ export default function computeLevels(memo){
 
 function computeClassLevels(memo){
   forOwn(memo.classLevelsById, classLevel => {
+    applyToggles(classLevel, memo);
     //  class levels are mutually dependent
     classLevel.dependencies = union(
       classLevel.dependencies,
       Object.keys(memo.classLevelsById)
     );
+    if (classLevel.deactivatedByToggle) return;
     let name = classLevel.variableName;
     let stat = memo.statsByVariableName[name];
     if (!stat){
@@ -29,7 +32,7 @@ function computeClassLevels(memo){
 
 function computeTotalLevel(memo){
   let currentLevel = memo.statsByVariableName['level'];
-  if (!currentLevel){
+  if (!currentLevel || currentLevel.deactivatedByToggle){
     currentLevel = {
       value: 0,
       dependencies: [],

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

@@ -5,10 +5,15 @@ import computeEffect from '/imports/api/creature/computation/engine/computeEffec
 import computeToggle from '/imports/api/creature/computation/engine/computeToggle.js';
 import computeEndStepProperty from '/imports/api/creature/computation/engine/computeEndStepProperty.js';
 import computeInlineCalculations from '/imports/api/creature/computation/engine/computeInlineCalculations.js';
+import computeConstant from '/imports/api/creature/computation/engine/computeConstant.js';
 
 export default function computeMemo(memo){
   // Compute level
   computeLevels(memo);
+  // Compute all constants that could be used
+  forOwn(memo.constantsById, constant => {
+    computeConstant (constant, memo);
+  });
   // Compute all stats, even if they are overriden
   forOwn(memo.statsById, stat => {
     computeStat (stat, memo);

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,32 +20,142 @@ 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);
 
-  if (!stat.computationDetails.disabledByToggle){
+  let effects = stat.computationDetails.effects || [];
-    // Compute and aggregate all the effects
+  let proficiencies = stat.computationDetails.proficiencies || [];
-    let aggregator = new EffectAggregator(stat, memo)
+
-    each(stat.computationDetails.effects, (effect) => {
+  // Get references to all the stats that share the variable name
-      computeEffect(effect, memo);
+  let sameNameStats
-      if (effect._id){
+
-        stat.dependencies = union(
+  if (stat.computationDetails.idsOfSameName){
-          stat.dependencies,
+    sameNameStats = stat.computationDetails.idsOfSameName.map(
-          [effect._id]
+      id => memo.propsById[id]
-        );
+    );
-      }
+  } else {
-      stat.dependencies = union(
+    sameNameStats = [];
-        stat.dependencies,
-        effect.dependencies
-      )
-      if (!effect.computationDetails.disabledByToggle){
-        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;
+  let allStats = [stat, ...sameNameStats];
-  stat.computationDetails.busyComputing = false;
+
+  // 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) {
+      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();
+  let effectDeps = [];
+  each(effects, (effect) => {
+    // Compute
+    computeEffect(effect, memo);
+    if (effect.deactivatedByToggle) return;
+
+    // dependencies
+    if (effect._id) effectDeps = union(effectDeps, [effect._id]);
+    effectDeps = union(effectDeps, effect.dependencies);
+
+    // Add computed effect to aggregator
+    aggregator.addEffect(effect);
+  });
+
+  // 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/computeToggle.js

@@ -1,4 +1,5 @@
 import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
+import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
 import { union } from 'lodash';
 
 export default function computeToggle(toggle, memo){
@@ -16,6 +17,9 @@ export default function computeToggle(toggle, memo){
   // Before doing any work, mark this toggle as busy
   toggle.computationDetails.busyComputing = true;
 
+  // Apply any parent toggles
+  applyToggles(toggle, memo);
+
   // Do work
   delete toggle.errors;
   if (toggle.enabled){
@@ -41,6 +45,11 @@ export default function computeToggle(toggle, memo){
       toggle.errors = context.errors;
     }
   }
+  if (!toggle.toggleResult){
+    toggle.inactive = true;
+    toggle.deactivatedBySelf = true;
+    toggle.deactivatedByToggle = true;
+  }
   toggle.computationDetails.computed = true;
   toggle.computationDetails.busyComputing = false;
 }

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

@@ -71,8 +71,8 @@ function replaceConstants({calc, memo, prop, dependencies, context}){
     } else if (node.name === '#constant'){
       constant = findAncestorByType({type: 'constant', prop, memo});
     }
-    // replace constants that aren't overridden by stats
+    // replace constants that aren't overridden by stats or disabled by a toggle
-    if (constant && !stat){
+    if (constant && !constant.deactivatedByToggle && !stat){
       dependencies = union(dependencies, [
         constant._id,
         ...constant.dependencies

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

@@ -1,15 +1,6 @@
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 
 export default function getComputationProperties(creatureId){
-  // find ids of all toggles that have conditions, even if they are inactive
-  let toggleIds = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    type: 'toggle',
-    removed: {$ne: true},
-    condition: { $exists: true },
-  }, {
-    fields: {_id: 1},
-  }).map(t => t._id);
   // Find all the relevant properties
   return CreatureProperties.find({
     'ancestors.id': creatureId,
@@ -17,17 +8,15 @@ export default function getComputationProperties(creatureId){
     $or: [
       // All active properties
       {inactive: {$ne: true}},
-      // All active and inactive toggles with conditions
+      // Unless they were deactivated because of a toggle
-      // Same as {$in: toggleIds}, but should be slightly faster
+      {deactivatedByToggle: true},
-      {type: 'toggle', condition: { $exists: true }},
-      // All decendents of the above toggles
-      {'ancestors.id': {$in: toggleIds}},
     ]
   }, {
     // Filter out fields never used by calculations
     fields: {
       icon: 0,
     },
+    // Obey tree order
     sort: {
       order: 1,
     }

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

@@ -8,23 +8,26 @@ export default function writeAlteredProperties(memo){
   // Loop through all properties on the memo
   forOwn(memo.propsById, changed => {
     let schema = propertySchemasIndex[changed.type];
-    if (!schema) return;
+    if (!schema){
-    let extraIds = changed.computationDetails.idsOfSameName;
+      console.warn('No schema for ' + changed.type);
-    let ids;
+      return;
-    if (extraIds && extraIds.length){
+    }
-      ids = [changed._id, ...extraIds];
+    let id = changed._id;
-    } else {
+    let op = undefined;
-      ids = [changed._id];
+    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', ...schema.objectKeys()];
-      op = addChangedKeysToOp(op, keys, original, changed);
-      if (op){
-        bulkWriteOperations.push(op);
-      }
-    });
   });
   writePropertiesSequentially(bulkWriteOperations);
 }

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

@@ -1,39 +1,49 @@
 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) {
   const fields = [
-    'name',
-    'attributeType',
-    'baseValue',
-    'spellSlotLevelValue',
-    'damage',
-    'decimal',
-    'reset',
-    'resetMultiplier',
-    'value',
-    'currentValue',
-    'modifier',
     'ability',
-    'skillType',
-    'baseProficiency',
     'abilityMod',
     'advantage',
-    'passiveBonus',
+    'attributeType',
-    'proficiency',
+    'baseProficiency',
+    'baseValue',
+    'calculation',
     'conditionalBenefits',
-    'rollBonuses',
+    'currentValue',
+    'damage',
+    'decimal',
     'fail',
     'level',
+    'modifier',
+    'name',
+    'passiveBonus',
+    'proficiency',
+    'reset',
+    'resetMultiplier',
+    'rollBonuses',
+    'skillType',
+    'spellSlotLevelValue',
+    'type',
+    'value',
   ];
 
   if (fullRecompute){
     memo.creatureVariables = {};
     forOwn(memo.statsByVariableName, (stat, variableName) => {
+      // Don't save context variables
+      if (variableName[0] === '#') return;
       let condensedStat = pick(stat, fields);
       memo.creatureVariables[variableName] = condensedStat;
     });
+    forOwn(memo.constantsByVariableName, (stat, variableName) => {
+      let condensedStat = pick(stat, fields);
+      if (!memo.creatureVariables[variableName]){
+        memo.creatureVariables[variableName] = condensedStat;
+      }
+    });
     Creatures.update(creatureId, {$set: {
       variables: memo.creatureVariables,
       computeVersion: VERSION,

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({
@@ -89,7 +89,6 @@ export function recomputeCreatureByDoc(creature){
   writeCreatureVariables(computationMemo, creatureId);
   recomputeDamageMultipliersById(creatureId);
   recomputeSlotFullness(creatureId);
-  recomputeInactiveProperties(creatureId);
   return computationMemo;
 }
 

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

@@ -50,6 +50,13 @@ let CreaturePropertySchema = new SimpleSchema({
     optional: true,
     index: 1,
   },
+  // Denormalised flag if this property was made inactive because of a toggle
+  // calculation. Either an ancestor toggle calculation or its own.
+  deactivatedByToggle: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+  },
   // Denormalised list of all properties or creatures this property depends on
   dependencies: {
     type: Array,
@@ -58,7 +65,6 @@ let CreaturePropertySchema = new SimpleSchema({
   },
   'dependencies.$': {
     type: String,
-    regEx: SimpleSchema.RegEx.Id,
   },
 });
 

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';
@@ -50,7 +50,7 @@ const damagePropertiesByName = new ValidatedMethod({
       damagePropertyWork({property, operation, value});
       lastProperty = property;
     });
-    recomputePropertyDependencies(lastProperty);
+    if (lastProperty) recomputePropertyDependencies(lastProperty);
   }
 });
 

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

@@ -24,6 +24,9 @@ const damageProperty = new ValidatedMethod({
   run({_id, operation, value}) {
     // Check permissions
 		let property = CreatureProperties.findOne(_id);
+    if (!property) throw new Meteor.Error(
+      'Damage property failed', 'Property doesn\'t exist'
+    );
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 		// Check if property can take damage
@@ -34,9 +37,10 @@ const damageProperty = new ValidatedMethod({
 				`Property of type "${property.type}" can't be damaged`
 			);
 		}
-		damagePropertyWork({property, operation, value});
+		let result = damagePropertyWork({property, operation, value});
     // Dependencies can't be changed through damage, only recompute deps
     recomputePropertyDependencies(property);
+    return result;
   },
 });
 

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

@@ -2,9 +2,24 @@ 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 getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { insertPropertyWork } from '/imports/api/creature/creatureProperties/methods/insertProperty.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import {
+	setLineageOfDocs,
+	renewDocIds
+} from '/imports/api/parenting/parenting.js';
+import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
+import { reorderDocs } from '/imports/api/parenting/order.js';
+import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+var snackbar;
+if (Meteor.isClient){
+  snackbar = require(
+    '/imports/ui/components/snackbars/SnackbarQueue.js'
+  ).snackbar
+}
+
+const DUPLICATE_CHILDREN_LIMIT = 50;
 
 const duplicateProperty = new ValidatedMethod({
   name: 'creatureProperties.duplicate',
@@ -20,13 +35,70 @@ const duplicateProperty = new ValidatedMethod({
     timeInterval: 5000,
   },
   run({_id}) {
-    let creatureProperty = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
-    let rootCreature = getRootCreatureAncestor(creatureProperty);
+    let creature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
+
-    insertPropertyWork({
+    assertEditPermission(creature, this.userId);
-      property: creatureProperty,
+
-      creature: rootCreature,
+    // Renew the doc ID
+    let randomSrc = DDP.randomStream('duplicateProperty');
+    let propertyId = randomSrc.id();
+    property._id = propertyId;
+
+    // Get all the descendants
+    let nodes = CreatureProperties.find({
+			'ancestors.id': _id,
+			removed: {$ne: true},
+		}, {
+      limit: DUPLICATE_CHILDREN_LIMIT + 1,
+      sort: {order: 1},
+    }).fetch();
+
+    // Alert the user if the limit was hit
+    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
+      nodes.pop();
+      if (Meteor.isClient){
+        snackbar({
+          text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
+        });
+      }
+    }
+
+    // re-map all the ancestors
+    setLineageOfDocs({
+			docArray: nodes,
+			newAncestry : [
+        ...property.ancestors,
+        {id: propertyId, collection: 'creatureProperties'}
+      ],
+			oldParent : {id: _id, collection: 'creatureProperties'},
+		});
+
+    // Give the docs new IDs without breaking internal references
+    renewDocIds({docArray: nodes});
+
+    // Order the root node
+    property.order += 0.5;
+
+    // Insert the properties
+		CreatureProperties.batchInsert([property, ...nodes]);
+
+    // Tree structure changed by inserts, reorder the tree
+    reorderDocs({
+      collection: CreatureProperties,
+      ancestorId: property.ancestors[0].id,
     });
+
+    // Inserting the active status of the property needs to be denormalised
+    recomputeInactiveProperties(creature._id);
+
+    // Recompute the inventory
+    recomputeInventory(creature._id);
+
+    // Inserting a creature property invalidates dependencies: full recompute
+    recomputeCreatureByDoc(creature);
+
+    return propertyId;
   },
 });
 

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

@@ -5,24 +5,10 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import INVENTORY_TAGS from '/imports/constants/INVENTORY_TAGS.js';
+import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-
+import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-export function getParentRefByTag(creatureId, tag){
-  let prop = CreatureProperties.findOne({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    inactive: {$ne: true},
-    tags: tag,
-  }, {
-    sort: {order: 1},
-  });
-  if (prop){
-    return {id: prop._id, collection: 'creatureProperties'};
-  } else {
-    return {id: creatureId, collection: 'creatures'};
-  }
-}
 
 // Equipping or unequipping an item will also change its parent
 const equipItem = new ValidatedMethod({
@@ -49,8 +35,9 @@ const equipItem = new ValidatedMethod({
     }, {
 			selector: {type: 'item'},
 		});
-    let tag = equipped ? INVENTORY_TAGS.equipment : INVENTORY_TAGS.carried;
+    let tag = equipped ? BUILT_IN_TAGS.equipment : BUILT_IN_TAGS.carried;
     let parentRef = getParentRefByTag(creature._id, tag);
+    if (!parentRef) parentRef = {id: creature._id, collection: 'creatures'};
 
     organizeDoc.call({
       docRef: {
@@ -62,6 +49,7 @@ const equipItem = new ValidatedMethod({
       skipRecompute: true,
     });
 
+    recomputeInactiveProperties(creature._id);
     recomputeInventory(creature._id);
     recomputeCreatureByDoc(creature);
   },

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

@@ -0,0 +1,13 @@
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+
+export default function getParentRefByTag(creatureId, tag){
+  let prop = CreatureProperties.findOne({
+    'ancestors.id': creatureId,
+    removed: {$ne: true},
+    inactive: {$ne: true},
+    tags: tag,
+  }, {
+    sort: {order: 1},
+  });
+  return prop && {id: prop._id, collection: 'creatureProperties'};
+}

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

@@ -1,4 +1,4 @@
-import '//imports/api/creature/creatureProperties/methods/adjustQuantity.js';
+import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
 import '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
 import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
 import '/imports/api/creature/creatureProperties/methods/dealDamage.js';

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

@@ -2,23 +2,129 @@ import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import SimpleSchema from 'simpl-schema';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import { getAncestry } from '/imports/api/parenting/parenting.js';
+import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
+import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
+import { getHighestOrder } from '/imports/api/parenting/order.js';
 
 const insertProperty = new ValidatedMethod({
   name: 'creatureProperties.insert',
-	validate: null,
+	validate: new SimpleSchema({
+    creatureProperty: {
+      type: Object,
+      blackbox: true,
+    },
+    parentRef: RefSchema,
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty}) {
+  run({creatureProperty, parentRef}) {
-    let rootCreature = getRootCreatureAncestor(creatureProperty);
+    // get the new ancestry for the properties
+		let {parentDoc, ancestors} = getAncestry({parentRef});
+
+		// Check permission to edit
+    let rootCreature;
+		if (parentRef.collection === 'creatures'){
+      rootCreature = parentDoc;
+		} else if (parentRef.collection === 'creatureProperties'){
+      rootCreature = getRootCreatureAncestor(parentDoc);
+		} else {
+			throw `${parentRef.collection} is not a valid parent collection`
+		}
     assertEditPermission(rootCreature, this.userId);
+
+    creatureProperty.parent = parentRef;
+    creatureProperty.ancestors = ancestors;
+
+		return insertPropertyWork({
+      property: creatureProperty,
+      creature: rootCreature,
+    });
+  },
+});
+
+const insertPropertyAsChildOfTag = new ValidatedMethod({
+  name: 'creatureProperties.insertAsChildOfTag',
+  validate: new SimpleSchema({
+    creatureProperty: {
+      type: Object,
+      blackbox: true,
+    },
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    tag: {
+      type: String,
+      max: 20,
+    },
+    tagDefaultName: {
+      type: String,
+      max: 20,
+      optional: true,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({creatureProperty, creatureId, tag, tagDefaultName}) {
+    let parentRef = getParentRefByTag(creatureId, tag);
+
+    if (!parentRef){
+      // Use the creature as the parent and mark that we need to insert the folder first later
+      var insertFolderFirst = true;
+      parentRef = {id: creatureId, collection: 'creatures'};
+    }
+
+    // get the new ancestry for the properties
+		let {parentDoc, ancestors} = getAncestry({parentRef});
+
+    // Check permission to edit
+    let rootCreature;
+		if (parentRef.collection === 'creatures'){
+      rootCreature = parentDoc;
+		} else if (parentRef.collection === 'creatureProperties'){
+      rootCreature = getRootCreatureAncestor(parentDoc);
+		} else {
+			throw `${parentRef.collection} is not a valid parent collection`
+		}
+    assertEditPermission(rootCreature, this.userId);
+
+    // Add the folder first if we need to
+    if (insertFolderFirst){
+      let order = getHighestOrder({
+        collection: CreatureProperties,
+        ancestorId: parentRef.id,
+      }) + 1;
+      let id = CreatureProperties.insert({
+        type: 'folder',
+        name: tagDefaultName || (tag.charAt(0).toUpperCase() + tag.slice(1)),
+        tags: [tag],
+        parent: parentRef,
+        ancestors: [parentRef],
+        order,
+      });
+      // Make the folder our new parent
+      let newParentRef = {id, collection: 'creatureProperties'};
+      ancestors = [parentRef, newParentRef];
+      parentRef = newParentRef;
+      creatureProperty.order = order + 1;
+    }
+
+    creatureProperty.parent = parentRef;
+    creatureProperty.ancestors = ancestors;
+
 		return insertPropertyWork({
       property: creatureProperty,
       creature: rootCreature,
@@ -47,3 +153,4 @@ export function insertPropertyWork({property, creature}){
 }
 
 export default insertProperty;
+export { insertPropertyAsChildOfTag };

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

@@ -16,6 +16,7 @@ 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',
@@ -27,13 +28,17 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 		parentRef: {
 			type: RefSchema,
 		},
+    order: {
+      type: Number,
+      optional: true,
+    },
 	}).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({nodeId, parentRef}) {
+	run({nodeId, parentRef, order}) {
 		// get the new ancestry for the properties
 		let {parentDoc, ancestors} = getAncestry({parentRef});
 
@@ -50,6 +55,7 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 
 		// 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},
@@ -61,6 +67,9 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 			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];
@@ -79,10 +88,14 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 		});
 
 		// Order the root node
-		setDocToLastOrder({
+    if (order === undefined){
-			collection: CreatureProperties,
+      setDocToLastOrder({
-			doc: node,
+        collection: CreatureProperties,
-		});
+        doc: node,
+      });
+    } else {
+      node.order = order;
+    }
 
 		// Insert the creature properties
     CreatureProperties.batchInsert(nodes);
@@ -107,4 +120,98 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
 	},
 });
 
+// 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/creatureProperties/methods/updateCreatureProperty.js

@@ -3,7 +3,7 @@ import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
 import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
 import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
 
@@ -59,7 +59,8 @@ const updateCreatureProperty = new ValidatedMethod({
       recomputeInventory(rootCreature._id);
     }
     // Updating a property is likely to change dependencies, do a full recompute
-    recomputeCreatureByDoc(rootCreature);
+    // denormalised stats might change, so fetch the creature again
+    recomputeCreatureById(rootCreature._id);
   },
 });
 

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

@@ -1,15 +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 '/imports/api/creature/removeCreature.js';
-import '/imports/api/creature/restCreature.js';
 
 //set up the collection for creatures
 let Creatures = new Mongo.Collection('creatures');
@@ -35,6 +27,16 @@ let CreatureSettingsSchema = new SimpleSchema({
     type: Boolean,
     optional: true,
   },
+  // Show the tree tab
+  showTreeTab: {
+    type: Boolean,
+    optional: true,
+  },
+  // Hide the spells tab
+  hideSpellsTab: {
+    type: Boolean,
+    optional: true,
+  },
   // How much each hitDice resets on a long rest
   hitDiceResetMultiplier: {
     type: Number,
@@ -165,87 +167,8 @@ CreatureSchema.extend(SharingSchema);
 
 Creatures.attachSchema(CreatureSchema);
 
-const insertCreature = new ValidatedMethod({
 
-  name: 'creatures.insertCreature',
+import '/imports/api/creature/creatures/methods/index.js';
-
-  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,
-		});
-    CreatureProperties.insert({
-      slotTags: ['base'],
-      quantityExpected: 1,
-      type: 'propertySlot',
-      name: 'Base',
-      description: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base, your sheet will be empty.',
-      hideWhenFull: true,
-      parent: {collection: 'creatures', id: creatureId},
-      ancestors: [{collection: 'creatures', id: creatureId}],
-      order: 0,
-      tags: [],
-      spaceLeft: 1,
-      totalFilled: 0,
-    });
-		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},
-      });
-    }
-  },
-});
 
 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/defaultCharacterProperties.js

@@ -0,0 +1,47 @@
+import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
+
+export default function defaultCharacterProperties(creatureId){
+  if (!creatureId) throw 'creatureId is required';
+  const creatureRef = {collection: 'creatures', id: creatureId};
+  let randomSrc = DDP.randomStream('defaultProperties');
+  const inventoryId = randomSrc.id();
+  const inventoryRef = {collection: 'creatureProperties', id: inventoryId};
+  return [
+    {
+      type: 'propertySlot',
+      name: 'Ruleset',
+      description: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base, your sheet will be empty.',
+      slotTags: ['base'],
+      tags: [],
+      quantityExpected: 1,
+      hideWhenFull: true,
+      spaceLeft: 1,
+      totalFilled: 0,
+      order: 0,
+      parent: creatureRef,
+      ancestors: [creatureRef],
+    }, {
+      _id: inventoryId,
+      type: 'folder',
+      name: 'Inventory',
+      tags: [BUILT_IN_TAGS.inventory],
+      order: 1,
+      parent: creatureRef,
+      ancestors: [creatureRef],
+    }, {
+      type: 'folder',
+      name: 'Equipment',
+      tags: [BUILT_IN_TAGS.equipment],
+      order: 2,
+      parent: inventoryRef,
+      ancestors: [creatureRef, inventoryRef],
+    }, {
+      type: 'folder',
+      name: 'Carried',
+      tags: [BUILT_IN_TAGS.carried],
+      order: 3,
+      parent: inventoryRef,
+      ancestors: [creatureRef, inventoryRef],
+    },
+  ];
+}

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({
+        nodeId: '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 { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-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 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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-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';
 
 export const recomputeDamageMultipliers = new ValidatedMethod({

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

@@ -7,7 +7,6 @@ export default function recomputeInactiveProperties(ancestorId){
       {disabled: true}, // Everything can be disabled
       {type: 'buff', applied: false}, // Buffs can be applied
       {type: 'item', equipped: {$ne: true}},
-      {type: 'toggle', toggleResult: false},
       {type: 'spell', prepared: {$ne: true}, alwaysPrepared: {$ne: true}},
     ],
   };
@@ -56,14 +55,18 @@ export default function recomputeInactiveProperties(ancestorId){
   CreatureProperties.update({
     'ancestors.id': {$eq: ancestorId, $nin: disabledIds},
     '_id': {$nin: disabledIds},
+    // if it was a toggle responsible, we leave it alone
+    deactivatedByToggle: {$ne: true},
     $or: [
       {inactive: true},
       {deactivatedByAncestor: true},
+      {deactivatedBySelf: true}
     ],
   }, {
     $unset: {
       inactive: 1,
       deactivatedByAncestor: 1,
+      deactivatedBySelf: 1,
     },
   }, {
     multi: true,

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

@@ -1,5 +1,5 @@
 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 { nodesToTree } from '/imports/api/parenting/parenting.js';
 
 export default function recomputeInventory(creatureId){
@@ -84,13 +84,13 @@ function getInventoryData(tree, containersToWrite){
   for (let key in data){
     data[key] += childData[key];
   }
+  if (node.contentsWeightless){
+    data.weightCarried = node.weight;
+  }
   if (node.carried === false){
     data.weightCarried = 0;
     data.valueCarried = 0;
   }
-  if (node.contentsWeightless){
-    data.weightCarried = node.weight;
-  }
   return data
 }
 

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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/Creatures.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,
@@ -58,6 +58,7 @@ function removeOldLogs(creatureId){
     sort: {date: -1},
     skip: PER_CREATURE_LOG_LIMIT,
   });
+  if (!firstExpiredLog) return;
   // Remove all logs older than the one over the limit
   CreatureLogs.remove({
     creatureId,
@@ -69,32 +70,10 @@ function logToMessageData(log){
   let embed = {
     fields: [],
   };
-  log.content.forEach(c => {
+  log.content.forEach(field => {
-    let field = {};
+    if (!field.name) field.name = '\u200b';
-    let descriptionField = {};
+    if (!field.value) field.value = '\u200b';
-    if (c.name) field.name = c.name;
+    embed.fields.push(field);
-    let valueArray = [];
-    if (c.error) valueArray.push(`*${c.error}*`);
-    if (c.resultPrefix) valueArray.push(`${c.resultPrefix}`);
-    if (c.result) valueArray.push(`\`${c.result}\``);
-    if (c.details) valueArray.push(c.details);
-    if (valueArray.length) field.value = valueArray.join(' ');
-    if (c.description){
-      if (!field.value){
-        field.value = c.description;
-      } else {
-        descriptionField.value = c.description;
-      }
-    }
-    if (field.name || field.value){
-      if (!field.name) field.name = '\u200b';
-      if (!field.value) field.value = '\u200b';
-      embed.fields.push(field);
-    }
-    if (descriptionField.value){
-      descriptionField.name = '\u200b';
-      embed.fields.push(descriptionField);
-    }
   });
   return { embeds: [embed] };
 }
@@ -109,7 +88,7 @@ function logWebhook({log, creature}){
 }
 
 const insertCreatureLog = new ValidatedMethod({
-  name: 'creatureLogs.methods.insertCreatureLog',
+  name: 'creatureLogs.methods.insert',
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
@@ -138,7 +117,7 @@ const insertCreatureLog = new ValidatedMethod({
 export function insertCreatureLogWork({log, creature, method}){
   // Build the new log
   if (typeof log === 'string'){
-    log = {text: log};
+    log = {content: [{value: log}]};
   }
   log.date = new Date();
   // Insert it
@@ -190,30 +169,30 @@ const logRoll = new ValidatedMethod({
       parsedResult = parse(roll);
     } catch (e){
       let error = prettifyParseError(e);
-      logContent.push({error});
+      logContent.push({name: 'Parse Error', value: error});
     }
     if (parsedResult) try {
       let rollContext = new CompilationContext();
       let compiled = parsedResult.compile(creature.variables, rollContext);
       let compiledString = compiled.toString();
       if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
-        details: roll
+        value: roll
       });
       logContent.push({
-        details: compiledString
+        value: compiledString
       });
       let rolled = compiled.roll(creature.variables, rollContext);
       let rolledString = rolled.toString();
       if (rolledString !== compiledString) logContent.push({
-        result: rolled.toString()
+        value: rolled.toString()
       });
       let result = rolled.reduce(creature.variables, rollContext);
       let resultString = result.toString();
       if (resultString !== rolledString) logContent.push({
-        result: resultString
+        value: resultString
       });
     } catch (e){
-      logContent = [{error: 'Calculation error'}];
+      logContent = [{name: 'Calculation error'}];
     }
     const log = {
       content: logContent,

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

@@ -3,31 +3,14 @@ import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
 import RollDetailsSchema from '/imports/api/properties/subSchemas/RollDetailsSchema.js';
 
 let LogContentSchema = new SimpleSchema({
+  // The name of the field, included in discord webhook message
   name: {
     type: String,
     optional: true,
   },
-  error: {
+  // The details of the field, included in discord webhook message
-    type: String,
+  // Markdown support
-    optional: true,
+  value: {
-  },
-  resultPrefix: {
-    type: String,
-    optional: true,
-  },
-  result: {
-    type: String,
-    optional: true,
-  },
-  expandedResult: {
-    type: String,
-    optional: true,
-  },
-  details: {
-    type: String,
-    optional: true,
-  },
-  description: {
     type: String,
     optional: true,
   },

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/creature/v1Migration/migrateCharacter.js

@@ -0,0 +1,12 @@
+import { fetch } from 'meteor/fetch'
+
+export default function importCharacter(url){
+  // Using v1's JSON API to fetch the character data in a usable format
+  // url -> https://dicecloud.com/character/<id>/json?key=<key>
+  fetch(url)
+    .then(response => response.json())
+    .then(data => {
+      let character = data.characters[0];
+      console.log(character.name  + ' fetched successfuly')
+    });
+}

app/imports/api/library/LibraryNodes.js

@@ -11,6 +11,8 @@ import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js
 import { softRemove } from '/imports/api/parenting/softRemove.js';
 import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
 import { storedIconsSchema } from '/imports/api/icons/Icons.js';
+import '/imports/api/library/methods/index.js';
+import { updateReferenceNodeWork } from '/imports/api/library/methods/updateReferenceNode.js';
 
 let LibraryNodes = new Mongo.Collection('libraryNodes');
 
@@ -75,31 +77,15 @@ 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;
   },
 });
 
-const duplicateNode = new ValidatedMethod({
-  name: 'libraryNodes.duplicate',
-	validate: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    }
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    let libraryNode = LibraryNodes.findOne(_id);
-    assertNodeEditPermission(libraryNode, this.userId);
-    delete libraryNode._id;
-		return LibraryNodes.insert(libraryNode);
-  },
-})
-
 const updateLibraryNode = new ValidatedMethod({
   name: 'libraryNodes.update',
   validate({_id, path}){
@@ -129,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;
   },
 });
 
@@ -195,7 +186,6 @@ export default LibraryNodes;
 export {
 	LibraryNodeSchema,
 	insertNode,
-  duplicateNode,
 	updateLibraryNode,
 	pullFromLibraryNode,
 	pushToLibraryNode,

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

@@ -0,0 +1,87 @@
+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 } from '/imports/api/sharing/sharingPermissions.js';
+import {
+	setLineageOfDocs,
+	renewDocIds
+} from '/imports/api/parenting/parenting.js';
+import { reorderDocs } from '/imports/api/parenting/order.js';
+
+var snackbar;
+if (Meteor.isClient){
+  snackbar = require(
+    '/imports/ui/components/snackbars/SnackbarQueue.js'
+  ).snackbar
+}
+
+const DUPLICATE_CHILDREN_LIMIT = 50;
+
+const duplicateLibraryNode = new ValidatedMethod({
+  name: 'libraryNodes.duplicate',
+	validate: new SimpleSchema({
+    _id: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    }
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({_id}) {
+    let libraryNode = LibraryNodes.findOne(_id);
+    assertDocEditPermission(libraryNode, this.userId);
+
+    let randomSrc = DDP.randomStream('duplicateLibraryNode');
+    let libraryNodeId = randomSrc.id();
+    libraryNode._id = libraryNodeId;
+
+    let nodes = LibraryNodes.find({
+			'ancestors.id': _id,
+			removed: {$ne: true},
+		}, {
+      limit: DUPLICATE_CHILDREN_LIMIT + 1,
+      sort: {order: 1},
+    }).fetch();
+
+    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
+      nodes.pop();
+      if (Meteor.isClient){
+        snackbar({
+          text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
+        });
+      }
+    }
+
+    // re-map all the ancestors
+    setLineageOfDocs({
+			docArray: nodes,
+			newAncestry : [
+        ...libraryNode.ancestors,
+        {id: libraryNodeId, collection: 'libraryNodes'}
+      ],
+			oldParent : {id: _id, collection: 'libraryNodes'},
+		});
+
+    // Give the docs new IDs without breaking internal references
+    renewDocIds({docArray: nodes});
+
+    // Order the root node
+    libraryNode.order += 0.5;
+
+		LibraryNodes.batchInsert([libraryNode, ...nodes]);
+
+    // Tree structure changed by inserts, reorder the tree
+    reorderDocs({
+      collection: LibraryNodes,
+      ancestorId: libraryNode.ancestors[0].id,
+    });
+
+    return libraryNodeId;
+  },
+});
+
+export default duplicateLibraryNode;

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

@@ -0,0 +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: {name: doc.name, type: doc.type},
+  };
+  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/properties/Adjustments.js

@@ -33,7 +33,7 @@ const AdjustmentSchema = new SimpleSchema({
 
 const ComputedOnlyAdjustmentSchema = new SimpleSchema({
   amountResult: {
-    type: SimpleSchema.Integer,
+    type: SimpleSchema.oneOf(String, Number),
     optional: true,
   },
   amountErrors: {

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

@@ -29,7 +29,7 @@ const DamageSchema = new SimpleSchema({
 
 const ComputedOnlyDamageSchema = new SimpleSchema({
   amountResult: {
-    type: SimpleSchema.oneOf(String, SimpleSchema.Integer),
+    type: SimpleSchema.oneOf(String, Number),
     optional: true,
   },
   amountErrors: {

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,47 @@
+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.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/computedOnlyPropertySchemasIndex.js

@@ -4,21 +4,23 @@ import { ComputedOnlyAdjustmentSchema } from '/imports/api/properties/Adjustment
 import { ComputedOnlyAttackSchema } from '/imports/api/properties/Attacks.js';
 import { ComputedOnlyAttributeSchema } from '/imports/api/properties/Attributes.js';
 import { ComputedOnlyBuffSchema } from '/imports/api/properties/Buffs.js';
-// import { ClassLevelSchema } from '/imports/api/properties/ClassLevels.js';
+import { ClassLevelSchema } from '/imports/api/properties/ClassLevels.js';
+import { ConstantSchema } from '/imports/api/properties/Constants.js';
 import { ComputedOnlyContainerSchema } from '/imports/api/properties/Containers.js';
 import { ComputedOnlyDamageSchema } from '/imports/api/properties/Damages.js';
 import { DamageMultiplierSchema } from '/imports/api/properties/DamageMultipliers.js';
 import { ComputedOnlyEffectSchema } from '/imports/api/properties/Effects.js';
 import { ComputedOnlyFeatureSchema } from '/imports/api/properties/Features.js';
-// import { FolderSchema } from '/imports/api/properties/Folders.js';
+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 { 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';
 import { ComputedOnlySlotSchema } from '/imports/api/properties/Slots.js';
-// import { SlotFillerSchema } from '/imports/api/properties/SlotFillers.js';
+import { SlotFillerSchema } from '/imports/api/properties/SlotFillers.js';
 import { ComputedOnlySpellSchema } from '/imports/api/properties/Spells.js';
 import { ComputedOnlySpellListSchema } from '/imports/api/properties/SpellLists.js';
 import { ComputedOnlyToggleSchema } from '/imports/api/properties/Toggles.js';
@@ -29,23 +31,26 @@ const propertySchemasIndex = {
   attack: ComputedOnlyAttackSchema,
   attribute: ComputedOnlyAttributeSchema,
   buff: ComputedOnlyBuffSchema,
-  // classLevel: ClassLevelSchema,
+  classLevel: ClassLevelSchema,
+  constant: ConstantSchema,
+  container: ComputedOnlyContainerSchema,
   damage: ComputedOnlyDamageSchema,
   damageMultiplier: DamageMultiplierSchema,
   effect: ComputedOnlyEffectSchema,
   feature: ComputedOnlyFeatureSchema,
-  // folder: FolderSchema,
+  folder: FolderSchema,
+  item: ComputedOnlyItemSchema,
   note: ComputedOnlyNoteSchema,
-  // proficiency: ProficiencySchema,
+  proficiency: ProficiencySchema,
   propertySlot: ComputedOnlySlotSchema,
+  reference: ReferenceSchema,
   roll: ComputedOnlyRollSchema,
   savingThrow: ComputedOnlySavingThrowSchema,
   skill: ComputedOnlySkillSchema,
+  slotFiller: SlotFillerSchema,
   spellList: ComputedOnlySpellListSchema,
   spell: ComputedOnlySpellSchema,
   toggle: ComputedOnlyToggleSchema,
-  container: ComputedOnlyContainerSchema,
-  item: ComputedOnlyItemSchema,
   any: new SimpleSchema({}),
 };
 

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/properties/subSchemas/InlineComputationSchema.js

@@ -10,7 +10,11 @@ const InlineComputationSchema = new SimpleSchema({
     type: String,
     optional: true,
   },
-  errors: ErrorSchema,
+  errors: {
+    type: Array,
+    optional: true,
+  },
+  'errors.$': ErrorSchema,
 });
 
 export default InlineComputationSchema;

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,7 @@ 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';
+const defaultLibraries = process.env.DEFAULT_LIBRARIES && process.env.DEFAULT_LIBRARIES.split(',') || [];
 
 const userSchema = new SimpleSchema({
 	username: {
@@ -63,7 +64,7 @@ const userSchema = new SimpleSchema({
 	},
 	subscribedLibraries: {
 		type: Array,
-		defaultValue: [],
+		defaultValue: defaultLibraries,
 		max: 100,
 	},
 	'subscribedLibraries.$': {

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 Creatures from '/imports/api/creature/creatures/Creatures.js';
-import {removeCreatureWork} from '/imports/api/creature/removeCreature.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 = !!process.env.DISABLE_PATREON;
 
-const TIERS = [
+const TIERS = Object.freeze([
   {
     name: 'Commoner',
     minimumEntitledCents: 0,
     invites: 0,
+    characterSlots: 0, //5,
     paidBenefits: false,
   }, {
     name: 'Dreamer',
     minimumEntitledCents: 100,
     invites: 0,
+    characterSlots: 0, //5,
     paidBenefits: false,
   }, {
     name: 'Wanderer',
     minimumEntitledCents: 300,
     invites: 0,
+    characterSlots: 0, //5,
     paidBenefits: false,
   }, {
     //cost per user $5
     name: 'Adventurer',
     minimumEntitledCents: 500,
     invites: 0,
+    characterSlots: -1, //20,
     paidBenefits: true,
   }, {
     //cost per user $3.33
     name: 'Hero',
     minimumEntitledCents: 1000,
     invites: 2,
+    characterSlots: -1, //50,
     paidBenefits: true,
   }, {
     //cost per user $3.333
     name: 'Legend',
     minimumEntitledCents: 2000,
     invites: 5,
+    characterSlots: -1, //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;