Bumped version

It was hiding behind FAB

.gitignore

@@ -0,0 +1 @@
+build

README.md

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

app/.gitignore

@@ -2,6 +2,8 @@
 .meteor/meteorite
 .demeteorized
 .cache
+.vscode
+fileStorage
 settings.json
 public/components
 public/_imports.html

app/.meteor/packages

@@ -3,52 +3,49 @@
 # 'meteor add' and 'meteor remove' will edit this file for you,
 # but you can also edit it by hand.
 
-accounts-password@1.6.0
-accounts-ui@1.3.1
-random@1.2.0
-dburles:collection-helpers
-reactive-var@1.0.11
-underscore@1.0.10
-momentjs:moment
+accounts-password@2.3.1
+random@1.2.1
+underscore@1.0.11
 dburles:mongo-collection-instances
-percolate:migrations
-accounts-google@1.3.3
-email@1.2.3
-meteorhacks:subs-manager
-chuangbo:marked
-meteor-base@1.4.0
+accounts-google@1.4.0
+email@2.2.2
+meteor-base@1.5.1
 mobile-experience@1.1.0
-mongo@1.10.0
-session@1.2.0
-jquery@1.11.10
-tracker@1.2.0
-logging@1.1.20
-reload@1.3.0
-ejson@1.1.1
-check@1.3.1
-standard-minifier-js@2.6.0
+mongo@1.16.1
+session@1.2.1
+tracker@1.2.1
+logging@1.3.1
+reload@1.3.1
+ejson@1.1.3
+check@1.3.2
+standard-minifier-js@2.8.1
 shell-server@0.5.0
-seba:minifiers-autoprefixer
-templates:array
-ecmascript@0.14.3
+ecmascript@0.16.3
 es5-shim@4.8.0
-reactive-dict@1.3.0
-percolate:synced-cron
-ongoworks:speakingurl
-service-configuration@1.0.11
-google-config-ui@1.0.1
-dynamic-import@0.5.2
-ddp-rate-limiter@1.0.7
+service-configuration@1.3.1
+dynamic-import@0.7.2
+ddp-rate-limiter@1.1.1
 rate-limit@1.0.9
-meteortesting:mocha
 mdg:validated-method
-akryum:vue-router2
-static-html
-aldeed:collection2@3.0.0
+static-html@1.3.2
+aldeed:collection2
 aldeed:schema-index
-akryum:vue-component
 accounts-patreon
 bozhao:link-accounts
 peerlibrary:reactive-publish
 simple:rest
 simple:rest-method-mixin
+mikowals:batch-insert
+peerlibrary:subscription-data
+zer0th:meteor-vuetify-loader
+akryum:vue-component
+akryum:vue-router2
+percolate:migrations
+meteortesting:mocha
+ostrio:files
+simple:rest-bearer-token-parser
+simple:rest-json-error-handler
+littledata:synced-cron
+mdg:meteor-apm-agent
+typescript@4.5.4
+seba:minifiers-autoprefixer

app/.meteor/release

@@ -1 +1 @@
-METEOR@1.10.2
+METEOR@2.8.1

app/.meteor/versions

@@ -1,137 +1,129 @@
-accounts-base@1.6.0
-accounts-google@1.3.3
-accounts-oauth@1.2.0
-accounts-password@1.6.0
+accounts-base@2.2.5
+accounts-google@1.4.0
+accounts-oauth@1.4.1
+accounts-password@2.3.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.0.6
+aldeed:collection2@3.5.0
 aldeed:schema-index@3.0.0
-allow-deny@1.1.0
-autoupdate@1.6.0
-babel-compiler@7.5.3
-babel-runtime@1.5.0
+allow-deny@1.1.1
+autoupdate@1.8.0
+babel-compiler@7.9.2
+babel-runtime@1.5.1
 base64@1.0.12
 binary-heap@1.0.11
-blaze@2.3.4
-blaze-tools@1.0.10
-boilerplate-generator@1.7.0
-bozhao:link-accounts@2.1.1
+blaze-tools@1.1.3
+boilerplate-generator@1.7.1
+bozhao:link-accounts@2.6.1
 caching-compiler@1.2.2
-caching-html-compiler@1.1.3
-callback-hook@1.3.0
-check@1.3.1
-chuangbo:marked@0.3.5_1
+caching-html-compiler@1.2.1
+callback-hook@1.4.0
+check@1.3.2
 coffeescript@2.4.1
 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
+dburles:mongo-collection-instances@0.3.6
+ddp@1.4.1
+ddp-client@2.6.1
 ddp-common@1.4.0
-ddp-rate-limiter@1.0.7
-ddp-server@2.3.1
-deps@1.0.12
-diff-sequence@1.1.1
-dynamic-import@0.5.2
-ecmascript@0.14.3
-ecmascript-runtime@0.7.0
-ecmascript-runtime-client@0.10.0
-ecmascript-runtime-server@0.9.0
-ejson@1.1.1
-email@1.2.3
+ddp-rate-limiter@1.1.1
+ddp-server@2.6.0
+diff-sequence@1.1.2
+dynamic-import@0.7.2
+ecmascript@0.16.3
+ecmascript-runtime@0.8.0
+ecmascript-runtime-client@0.12.1
+ecmascript-runtime-server@0.11.0
+ejson@1.1.3
+email@2.2.2
 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
+fetch@0.1.2
+geojson-utils@1.0.11
+google-oauth@1.4.2
 hot-code-push@1.0.4
-html-tools@1.0.11
-htmljs@1.0.11
-http@1.4.2
-id-map@1.1.0
+html-tools@1.1.3
+htmljs@1.1.1
+http@2.0.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
-less@2.8.0
+lai:collection-extensions@0.3.0
+launch-screen@1.3.0
+littledata:synced-cron@1.5.1
 livedata@1.0.18
-lmieulet:meteor-coverage@1.1.4
 localstorage@1.2.0
-logging@1.1.20
+logging@1.3.1
+mdg:meteor-apm-agent@3.5.1
 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.3
-meteortesting:mocha@1.1.5
-meteortesting:mocha-core@7.0.1
-minifier-css@1.5.0
-minifier-js@2.6.0
-minimongo@1.6.0
+meteor@1.10.2
+meteor-base@1.5.1
+meteortesting:browser-tests@1.3.5
+meteortesting:mocha@2.0.3
+meteortesting:mocha-core@8.1.2
+mikowals:batch-insert@1.3.0
+minifier-css@1.6.1
+minifier-js@2.7.5
+minimongo@1.9.0
 mobile-experience@1.1.0
 mobile-status-bar@1.1.0
-modern-browsers@0.1.5
-modules@0.15.0
-modules-runtime@0.12.0
-momentjs:moment@2.24.0
-mongo@1.10.0
-mongo-decimal@0.1.1
+modern-browsers@0.1.9
+modules@0.19.0
+modules-runtime@0.13.1
+mongo@1.16.1
+mongo-decimal@0.1.3
 mongo-dev-server@1.1.0
-mongo-id@1.0.7
-npm-bcrypt@0.9.3
-npm-mongo@3.7.0
-oauth@1.3.0
-oauth2@1.3.0
-observe-sequence@1.0.16
-ongoworks:speakingurl@9.0.0
+mongo-id@1.0.8
+mongo-livedata@1.0.12
+npm-mongo@4.11.0
+oauth@2.1.2
+oauth2@1.3.1
 ordered-dict@1.1.0
+ostrio:cookies@2.7.2
+ostrio:files@2.3.2
 patreon-oauth@0.1.0
 peerlibrary:assert@0.3.0
+peerlibrary:check-extension@0.7.0
+peerlibrary:computed-field@0.10.0
+peerlibrary:data-lookup@0.3.0
 peerlibrary:extend-publish@0.6.0
 peerlibrary:fiber-utils@0.10.0
-peerlibrary:reactive-mongo@0.4.0
+peerlibrary:reactive-mongo@0.4.1
 peerlibrary:reactive-publish@0.10.0
 peerlibrary:server-autorun@0.8.0
-percolate:migrations@0.9.8
-percolate:synced-cron@1.3.2
-promise@0.11.2
-raix:eventemitter@0.1.3
-random@1.2.0
+peerlibrary:subscription-data@0.8.0
+percolate:migrations@1.1.0
+promise@0.12.1
+raix:eventemitter@1.0.0
+random@1.2.1
 rate-limit@1.0.9
-reactive-dict@1.3.0
-reactive-var@1.0.11
-reload@1.3.0
+react-fast-refresh@0.2.3
+reactive-dict@1.3.1
+reactive-var@1.0.12
+reload@1.3.1
 retry@1.1.0
-routepolicy@1.1.0
-seba:minifiers-autoprefixer@1.1.2
-service-configuration@1.0.11
-session@1.2.0
+routepolicy@1.1.1
+seba:minifiers-autoprefixer@2.0.1
+service-configuration@1.3.1
+session@1.2.1
 sha@1.0.9
 shell-server@0.5.0
-simple:json-routes@2.1.0
-simple:rest@1.1.1
-simple:rest-method-mixin@1.0.1
-socket-stream-client@0.3.0
-spacebars@1.0.15
-spacebars-compiler@1.1.3
-srp@1.1.0
-standard-minifier-js@2.6.0
-static-html@1.2.2
-templates:array@1.0.3
-templating@1.3.2
-templating-compiler@1.3.3
-templating-runtime@1.3.2
-templating-tools@1.1.2
-tmeasday:check-npm-versions@0.3.2
-tracker@1.2.0
-underscore@1.0.10
-url@1.3.0
-webapp@1.9.1
-webapp-hashing@1.0.9
+simple:json-routes@2.3.1
+simple:rest@1.2.1
+simple:rest-bearer-token-parser@1.1.1
+simple:rest-json-error-handler@1.1.1
+simple:rest-method-mixin@1.1.0
+socket-stream-client@0.5.0
+spacebars-compiler@1.3.1
+standard-minifier-js@2.8.1
+static-html@1.3.2
+templating-tools@1.2.2
+tmeasday:check-npm-versions@1.0.2
+tracker@1.2.1
+typescript@4.5.4
+underscore@1.0.11
+url@1.3.2
+webapp@1.13.2
+webapp-hashing@1.1.1
+zer0th:meteor-vuetify-loader@0.1.41

app/client/head.html

@@ -1,38 +1,39 @@
 <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">
-	<link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png?v=lk6WXp6Pmj">
-	<link rel="icon" type="image/png" href="/favicon-32x32.png?v=lk6WXp6Pmj" sizes="32x32">
-	<link rel="icon" type="image/png" href="/favicon-194x194.png?v=lk6WXp6Pmj" sizes="194x194">
-	<link rel="icon" type="image/png" href="/favicon-96x96.png?v=lk6WXp6Pmj" sizes="96x96">
-	<link rel="icon" type="image/png" href="/android-chrome-192x192.png?v=lk6WXp6Pmj" sizes="192x192">
-	<link rel="icon" type="image/png" href="/favicon-16x16.png?v=lk6WXp6Pmj" sizes="16x16">
-	<link rel="manifest" href="/manifest.json?v=lk6WXp6Pmj">
-	<link rel="shortcut icon" href="/favicon.ico?v=lk6WXp6Pmj">
-	<meta name="msapplication-TileColor" content="#b91d1d">
-	<meta name="msapplication-TileImage" content="/mstile-144x144.png?v=lk6WXp6Pmj">
-	<meta name="theme-color" content="#d12929">
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png?v=lk6WXp6Pmj">
+  <link rel="icon" type="image/png" href="/favicon-32x32.png?v=lk6WXp6Pmj" sizes="32x32">
+  <link rel="icon" type="image/png" href="/favicon-194x194.png?v=lk6WXp6Pmj" sizes="194x194">
+  <link rel="icon" type="image/png" href="/favicon-96x96.png?v=lk6WXp6Pmj" sizes="96x96">
+  <link rel="icon" type="image/png" href="/android-chrome-192x192.png?v=lk6WXp6Pmj" sizes="192x192">
+  <link rel="icon" type="image/png" href="/favicon-16x16.png?v=lk6WXp6Pmj" sizes="16x16">
+  <link rel="manifest" href="/manifest.json?v=lk6WXp6Pmj">
+  <link rel="shortcut icon" href="/favicon.ico?v=lk6WXp6Pmj">
+  <meta name="msapplication-TileColor" content="#b91d1d">
+  <meta name="msapplication-TileImage" content="/mstile-144x144.png?v=lk6WXp6Pmj">
+  <meta name="theme-color" content="#d12929">
 
-	<style type="text/css" media="print">
-		@page {
-			margin: 0mm;
-		}
-		html {
-			margin: 0px;
-		}
-		* {
-			-webkit-transition: none !important;
-			transition: none !important;
-		}
-	</style>
+  <style type="text/css" media="print">
+    @page {
+      margin: 0mm;
+    }
+    html {
+      margin: 0px;
+    }
+    * {
+      -webkit-transition: none !important;
+      transition: none !important;
+    }
+  </style>
 </head>

app/client/main.js

@@ -1,3 +1,7 @@
-import '/imports/ui/vueSetup.js';
-import '/imports/ui/styles/stylesIndex.js';
-import '/imports/ui/styles/stylesIndex.js';
+import '/imports/api/simpleSchemaConfig.js';
+import '/imports/client/ui/vueSetup.js';
+import '/imports/client/ui/styles/stylesIndex.js';
+import '/imports/client/config.js';
+import '/imports/client/serviceWorker.js';
+
+import 'ngraph.graph';

app/exampleMeteorSettings.json

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

app/imports/api/campaign/Encounter.js

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

app/imports/api/campaign/Parties.js

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

app/imports/api/creature/CreatureProperties.js

@@ -1,461 +0,0 @@
-import { Meteor } from 'meteor/meteor';
-import { Mongo } from 'meteor/mongo';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import SimpleSchema from 'simpl-schema';
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import ChildSchema, { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import { recomputeCreature } from '/imports/api/creature/computation/recomputeCreature.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import Creatures from '/imports/api/creature/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
-import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex.js';
-import {
-	setLineageOfDocs,
-	getAncestry,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import {setDocToLastOrder} from '/imports/api/parenting/order.js';
-import { storedIconsSchema } from '/imports/api/icons/Icons.js';
-
-import '/imports/api/creature/actions/doAction.js';
-
-let CreatureProperties = new Mongo.Collection('creatureProperties');
-
-let CreaturePropertySchema = new SimpleSchema({
-	type: {
-    type: String,
-    allowedValues: Object.keys(propertySchemasIndex),
-  },
-	tags: {
-		type: Array,
-		defaultValue: [],
-	},
-	'tags.$': {
-		type: String,
-	},
-	disabled: {
-		type: Boolean,
-		optional: true,
-	},
-  icon: {
-    type: storedIconsSchema,
-    optional: true,
-  }
-});
-
-for (let key in propertySchemasIndex){
-	let schema = new SimpleSchema({});
-	schema.extend(propertySchemasIndex[key]);
-	schema.extend(CreaturePropertySchema);
-  schema.extend(ColorSchema);
-	schema.extend(ChildSchema);
-	schema.extend(SoftRemovableSchema);
-	CreatureProperties.attachSchema(schema, {
-		selector: {type: key}
-	});
-}
-
-export function getCreature(property){
-  if (!property) throw new Meteor.Error('No property provided');
-  let creature = Creatures.findOne(property.ancestors[0].id);
-  if (!creature) throw new Meteor.Error('Creature does not exist');
-  return creature;
-}
-
-function assertPropertyEditPermission(property, userId){
-  let creature = getCreature(property);
-  return assertEditPermission(creature, userId);
-}
-
-function recomputeCreatures(property){
-	for (let ref of property.ancestors){
-		if (ref.collection === 'creatures') {
-			recomputeCreature.call({charId: ref.id});
-		}
-	}
-}
-
-const insertProperty = new ValidatedMethod({
-  name: 'creatureProperties.insert',
-	validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({creatureProperty}) {
-    delete creatureProperty._id;
-    assertPropertyEditPermission(creatureProperty, this.userId);
-		let _id = CreatureProperties.insert(creatureProperty);
-		let property = CreatureProperties.findOne(_id);
-		recomputeCreatures(property);
-  },
-});
-
-const duplicateProperty = new ValidatedMethod({
-  name: 'creatureProperties.duplicate',
-  validate: new SimpleSchema({
-    _id: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    }
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id}) {
-    let creatureProperty = CreatureProperties.findOne(_id);
-    assertPropertyEditPermission(creatureProperty, this.userId);
-    delete creatureProperty._id;
-		CreatureProperties.insert(creatureProperty);
-    recomputeCreatures(creatureProperty);
-  },
-});
-
-const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'creatureProperties.insertPropertyFromLibraryNode',
-	validate: new SimpleSchema({
-		nodeId: {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-		parentRef: {
-			type: RefSchema,
-		},
-	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({nodeId, parentRef}) {
-		// get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
-		// Check permission to edit
-		if (parentRef.collection === 'creatures'){
-			assertEditPermission(parentDoc, this.userId);
-		} else if (parentRef.collection === 'creatureProperties'){
-			assertPropertyEditPermission(parentDoc, this.userId);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
-
-		// Fetch the library node and its decendents, provided they have not been
-		// removed
-		let node = LibraryNodes.findOne({
-			_id: nodeId,
-			removed: {$ne: true},
-		});
-		if (!node) throw `Node not found for nodeId: ${nodeId}`;
-		let oldParent = node.parent;
-		let nodes = LibraryNodes.find({
-			'ancestors.id': nodeId,
-			removed: {$ne: true},
-		}).fetch();
-		// The root node is last in the array of nodes
-		nodes.push(node);
-
-		// re-map all the ancestors
-		setLineageOfDocs({
-			docArray: nodes,
-			newAncestry: ancestors,
-			oldParent,
-		});
-
-		// Give the docs new IDs without breaking internal references
-		renewDocIds({
-			docArray: nodes,
-			collectionMap: {'libraryNodes': 'creatureProperties'}
-		});
-
-		// Order the root node
-		setDocToLastOrder({
-			collection: CreatureProperties,
-			doc: node,
-		});
-
-		// Insert the creature properties
-		let docId;
-		nodes.forEach(doc => {
-			docId = CreatureProperties.insert(doc);
-		});
-
-		// Recompute the creatures doc was attached to
-		let doc = CreatureProperties.findOne(docId);
-		recomputeCreatures(doc);
-
-		// Return the docId of the last property, the inserted root property
-		return docId;
-	},
-})
-
-const updateProperty = new ValidatedMethod({
-  name: 'creatureProperties.update',
-  validate({_id, path}){
-		if (!_id) return false;
-		// We cannot change these fields with a simple update
-		switch (path[0]){
-			case 'type':
-      case 'order':
-      case 'parent':
-      case 'ancestors':
-			case 'damage':
-				throw new Meteor.Error('Permission denied',
-				'This property can\'t be updated directly');
-		}
-  },
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, path, value}) {
-    let property = CreatureProperties.findOne(_id);
-    assertPropertyEditPermission(property, this.userId);
-    let pathString = path.join('.');
-    let modifier;
-    // unset empty values
-    if (value === null || value === undefined){
-      modifier = {$unset: {[pathString]: 1}};
-    } else {
-      modifier = {$set: {[pathString]: value}};
-    }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
-		recomputeCreatures(property);
-  },
-});
-
-export function damagePropertyWork({property, operation, value}){
-  if (operation === 'set'){
-    let currentValue = property.value;
-    // Set represents what we want the value to be after damage
-    // So we need the actual damage to get to that value
-    let damage = currentValue - value;
-    // Damage can't exceed total value
-    if (damage > currentValue) damage = currentValue;
-    // Damage must be positive
-    if (damage < 0) damage = 0;
-    CreatureProperties.update(property._id, {
-      $set: {damage}
-    }, {
-      selector: property
-    });
-  } else if (operation === 'increment'){
-    let currentValue = property.value - (property.damage || 0);
-    let currentDamage = property.damage;
-    let increment = value;
-    // Can't increase damage above the remaining value
-    if (increment > currentValue) increment = currentValue;
-    // Can't decrease damage below zero
-    if (-increment > currentDamage) increment = -currentDamage;
-    CreatureProperties.update(property._id, {
-      $inc: {damage: increment}
-    }, {
-      selector: property
-    });
-  }
-}
-
-const damageProperty = new ValidatedMethod({
-  name: 'creatureProperties.damage',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({_id, operation, value}) {
-		let currentProperty = CreatureProperties.findOne(_id);
-		// Check permissions
-		assertPropertyEditPermission(currentProperty, this.userId);
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(currentProperty);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${currentProperty.type}" can't be damaged`
-			);
-		}
-		damagePropertyWork({property: currentProperty, operation, value})
-		recomputeCreatures(currentProperty);
-  },
-});
-
-export function adjustQuantityWork({property, operation, value}){
-  // Check if property has quantity
-  let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')){
-    throw new Meteor.Error(
-      'Adjust quantity failed',
-      `Property of type "${property.type}" doesn't have a quantity`
-    );
-  }
-  if (operation === 'set'){
-    CreatureProperties.update(property._id, {
-      $set: {quantity: value}
-    }, {
-      selector: property
-    });
-  } else if (operation === 'increment'){
-    // value here is 'damage'
-    value = -value;
-    let currentQuantity = property.quantity;
-    if (currentQuantity + value < 0) value = -currentQuantity;
-    CreatureProperties.update(property._id, {
-      $inc: {quantity: value}
-    }, {
-      selector: property
-    });
-  }
-}
-
-const adjustQuantity = new ValidatedMethod({
-  name: 'creatureProperties.adjustQuantity',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({_id, operation, value}) {
-		let currentProperty = CreatureProperties.findOne(_id);
-		// Check permissions
-		assertPropertyEditPermission(currentProperty, this.userId);
-    adjustQuantityWork({property: currentProperty, operation, value});
-    recomputeCreatures(currentProperty);
-  },
-});
-
-const selectAmmoItem = new ValidatedMethod({
-  name: 'creatureProperties.selectAmmoItem',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    itemId: SimpleSchema.RegEx.Id,
-    itemConsumedIndex: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({actionId, itemId, itemConsumedIndex}) {
-		let action = CreatureProperties.findOne(actionId);
-		// Check permissions
-		assertPropertyEditPermission(action, this.userId);
-    // Check that this index has a document to edit
-    let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed){
-      throw new Meteor.Error('Resouce not found',
-        'Could not set ammo, because the ammo document was not found');
-    }
-    let itemToLink = CreatureProperties.findOne(itemId);
-    if (!itemToLink){
-      throw new Meteor.Error('Item not found',
-        'Could not set ammo: the item was not found');
-    }
-    let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
-    CreatureProperties.update(actionId, {
-      $set: {[path]: itemId}
-    }, {
-      selector: action,
-    });
-    recomputeCreatures(action);
-  },
-});
-
-const pushToProperty = new ValidatedMethod({
-	name: 'creatureProperties.push',
-	validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, path, value}){
-		let property = CreatureProperties.findOne(_id);
-    assertPropertyEditPermission(property, this.userId);
-		CreatureProperties.update(_id, {
-			$push: {[path.join('.')]: value},
-		}, {
-			selector: {type: property.type},
-		});
-		recomputeCreatures(property);
-	}
-});
-
-const pullFromProperty = new ValidatedMethod({
-	name: 'creatureProperties.pull',
-	validate: null,
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id, path, itemId}){
-		let property = CreatureProperties.findOne(_id);
-    assertPropertyEditPermission(property, this.userId);
-		CreatureProperties.update(_id, {
-			$pull: {[path.join('.')]: {_id: itemId}},
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-		recomputeCreatures(property);
-	}
-});
-
-const softRemoveProperty = new ValidatedMethod({
-	name: 'creatureProperties.softRemove',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-	run({_id}){
-		let property = CreatureProperties.findOne(_id);
-    assertPropertyEditPermission(property, this.userId);
-		softRemove({_id, collection: CreatureProperties});
-		recomputeCreatures(property);
-	}
-});
-
-
-export default CreatureProperties;
-export {
-	CreaturePropertySchema,
-	insertProperty,
-  duplicateProperty,
-	insertPropertyFromLibraryNode,
-	updateProperty,
-	damageProperty,
-  adjustQuantity,
-  selectAmmoItem,
-	pushToProperty,
-	pullFromProperty,
-	softRemoveProperty,
-};

app/imports/api/creature/Creatures.js

@@ -1,195 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import deathSaveSchema from '/imports/api/properties/subSchemas/DeathSavesSchema.js'
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import SharingSchema from '/imports/api/sharing/SharingSchema.js';
-import {assertEditPermission} from '/imports/api/sharing/sharingPermissions.js';
-import { getUserTier } from '/imports/api/users/patreon/tiers.js';
-
-import '/imports/api/creature/removeCreature.js';
-import '/imports/api/creature/restCreature.js';
-
-//set up the collection for creatures
-let Creatures = new Mongo.Collection('creatures');
-
-let CreatureSettingsSchema = new SimpleSchema({
-	//slowed down by carrying too much?
-	useVariantEncumbrance: {
-		type: Boolean,
-		optional: true,
-	},
-	//hide spellcasting tab
-	hideSpellcasting: {
-		type: Boolean,
-		optional: true,
-	},
-	// Swap around the modifier and stat
-	swapStatAndModifier: {
-		type: Boolean,
-		optional: true,
-	},
-  // Hide all the unused stats
-  hideUnusedStats: {
-    type: Boolean,
-    optional: true,
-  },
-  // How much each hitDice resets on a long rest
-  hitDiceResetMultiplier: {
-    type: Number,
-    optional: true,
-    min: 0,
-    max: 1,
-  }
-});
-
-let CreatureSchema = new SimpleSchema({
-	// Strings
-	name: {
-		type: String,
-		defaultValue: '',
-		optional: true,
-	},
-	alignment: {
-		type: String,
-		optional: true
-	},
-	gender: {
-		type: String,
-		optional: true
-	},
-	picture: {
-		type: String,
-		optional: true
-	},
-  avatarPicture: {
-    type: String,
-    optional: true,
-  },
-	// Mechanics
-	deathSave: {
-		type: deathSaveSchema,
-		defaultValue: {},
-	},
-  // Stats that are computed and denormalised outside of recomputation
-  denormalizedStats: {
-    type: Object,
-    defaultValue: {},
-  },
-  // Sum of all XP gained by this character
-	'denormalizedStats.xp': {
-		type: SimpleSchema.Integer,
-		defaultValue: 0,
-	},
-  // Sum of all levels granted by milestone XP
-  'denormalizedStats.milestoneLevels': {
-    type: SimpleSchema.Integer,
-    defaultValue: 0,
-  },
-  // Sum of all weights of items and containers that are carried
-	'denormalizedStats.weightCarried': {
-		type: Number,
-		defaultValue: 0,
-	},
-	type: {
-		type: String,
-		defaultValue: 'pc',
-		allowedValues: ['pc', 'npc', 'monster'],
-	},
-  damageMultipliers: {
-    type: Object,
-		blackbox: true,
-		defaultValue: {}
-  },
-	variables: {
-		type: Object,
-		blackbox: true,
-		defaultValue: {}
-	},
-
-	// Settings
-	settings: {
-		type: CreatureSettingsSchema,
-		defaultValue: {},
-	},
-});
-
-CreatureSchema.extend(ColorSchema);
-CreatureSchema.extend(SharingSchema);
-
-Creatures.attachSchema(CreatureSchema);
-
-const insertCreature = new ValidatedMethod({
-
-  name: 'creatures.insertCreature',
-
-  validate: null,
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run() {
-    if (!this.userId) {
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      'You need to be logged in to insert a creature');
-    }
-    let tier = getUserTier(this.userId);
-    if (!tier.paidBenefits){
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      `The ${tier.name} tier does not allow you to insert a creature`);
-    }
-
-		// Create the creature document
-    let charId = Creatures.insert({
-			owner: this.userId,
-		});
-		this.unblock();
-		return charId;
-  },
-
-});
-
-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 };

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

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

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

@@ -0,0 +1,58 @@
+
+import SimpleSchema from 'simpl-schema';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
+import { CreaturePropertySchema } from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
+let createS3FilesCollection;
+if (Meteor.isServer) {
+  createS3FilesCollection = require('/imports/api/files/server/s3FileStorage.js').createS3FilesCollection
+} else {
+  createS3FilesCollection = require('/imports/api/files/client/s3FileStorage.js').createS3FilesCollection
+}
+
+const ArchiveCreatureFiles = createS3FilesCollection({
+  collectionName: 'archiveCreatureFiles',
+  storagePath: Meteor.isDevelopment ? '../../../../../fileStorage/archiveCreatures' : 'assets/app/archiveCreatures',
+  onBeforeUpload(file) {
+    // Allow upload files under 10MB, and only in json format
+    if (file.size > 10485760) {
+      return 'Please upload with size equal or less than 10MB';
+    }
+    if (!/json/i.test(file.extension)) {
+      return 'Please upload only a JSON file';
+    }
+    return true;
+  },
+  onAfterUpload(file) {
+    if (Meteor.isServer) incrementFileStorageUsed(file.userId, file.size);
+  }
+});
+
+let archiveSchema = new SimpleSchema({
+  meta: {
+    type: Object,
+    blackbox: true,
+  },
+  creature: CreatureSchema,
+  properties: {
+    type: Array,
+  },
+  'properties.$': CreaturePropertySchema,
+  experiences: {
+    type: Array,
+  },
+  'experiences.$': {
+    type: Object,
+    blackbox: true,
+  },
+  logs: {
+    type: Array,
+  },
+  'logs.$': {
+    type: Object,
+    blackbox: true,
+  },
+});
+
+export default ArchiveCreatureFiles;
+export { archiveSchema };

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

@@ -0,0 +1,78 @@
+import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
+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 ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
+
+export function getArchiveObj(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 = {
+    meta: {
+      type: 'DiceCloud V2 Creature Archive',
+      schemaVersion: SCHEMA_VERSION,
+      archiveDate: new Date(),
+    },
+    creature,
+    properties,
+    experiences,
+    logs,
+  };
+
+  return archiveCreature;
+}
+
+export function archiveCreature(creatureId){
+  const archive = getArchiveObj(creatureId);
+  const buffer = Buffer.from(JSON.stringify(archive, null, 2));
+  ArchiveCreatureFiles.write(buffer, {
+    fileName: `${archive.creature.name || archive.creature._id}.json`,
+    type: 'application/json',
+    userId: archive.creature.owner,
+    meta: {
+      schemaVersion: SCHEMA_VERSION,
+      creatureId: archive.creature._id,
+      creatureName: archive.creature.name,
+    },
+  }, (error) => {
+    if (error){
+      throw error;
+    } else {
+      removeCreatureWork(creatureId);
+    }
+  }, true);
+}
+
+const archiveCreatureToFile = new ValidatedMethod({
+  name: 'Creatures.methods.archiveCreatureToFile',
+  validate: new SimpleSchema({
+    'creatureId': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  async run({creatureId}) {
+    assertOwnership(creatureId, this.userId);
+    if (Meteor.isServer){
+      archiveCreature(creatureId, this.userId);
+    } else {
+      removeCreatureWork(creatureId);
+    }
+  },
+});
+
+export default archiveCreatureToFile;

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

@@ -0,0 +1,3 @@
+import '/imports/api/creature/archive/methods/archiveCreatureToFile.js';
+import '/imports/api/creature/archive/methods/restoreCreatureFromFile.js';
+import '/imports/api/creature/archive/methods/removeArchiveCreature.js';

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

@@ -0,0 +1,40 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
+
+const removeArchiveCreature = new ValidatedMethod({
+  name: 'ArchiveCreatureFiles.methods.removeArchiveCreature',
+  validate: new SimpleSchema({
+    'fileId': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  async run({ fileId }) {
+    // fetch the file
+    const file = ArchiveCreatureFiles.findOne({ _id: fileId }).get();
+    if (!file) {
+      throw new Meteor.Error('File not found',
+        'The requested creature archive does not exist');
+    }
+    // Assert ownership
+    const userId = file?.userId;
+    if (!userId || userId !== this.userId) {
+      throw new Meteor.Error('Permission denied',
+        'You can only restore creatures you own');
+    }
+    //Remove the archive once the restore succeeded
+    ArchiveCreatureFiles.remove({ _id: fileId });
+    // Update the user's file storage limits
+    incrementFileStorageUsed(userId, -file.size);
+  },
+});
+
+export default removeArchiveCreature;

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

@@ -0,0 +1,104 @@
+import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION.js';
+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 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 ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles.js';
+import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed.js';
+import verifyArchiveSafety from '/imports/api/creature/archive/methods/verifyArchiveSafety.js';
+
+let migrateArchive;
+if (Meteor.isServer){
+  migrateArchive = require('/imports/migrations/server/migrateArchive.js').default;
+}
+
+function restoreCreature(archive, userId){
+  if (SCHEMA_VERSION < archive.meta.schemaVersion){
+    throw new Meteor.Error('Incompatible',
+      'The archive file is from a newer version. Update required to read.')
+  }
+
+  // Migrate and verify the archive meets the current schema
+  migrateArchive(archive);
+
+  // Asset that the archive is safe
+  verifyArchiveSafety(archive);
+
+  // Don't upload creatures twice
+  const existingCreature = Creatures.findOne(archive.creature._id, {
+    fields: { _id: 1 }
+  });
+  if (existingCreature) throw new Meteor.Error('Already exists',
+    'The creature you are trying to restore already exists.')
+  
+  // Ensure the user owns the restored creature
+  archive.creature.owner = userId;
+
+  // Insert the creature sub documents
+  // They still have their original _id's
+  Creatures.insert(archive.creature);
+  try {
+    // Add all the properties
+    if (archive.properties && archive.properties.length){
+      CreatureProperties.batchInsert(archive.properties);
+    }
+    if (archive.experiences && archive.experiences.length){
+      Experiences.batchInsert(archive.experiences);
+    }
+    if (archive.logs && archive.logs.length){
+      CreatureLogs.batchInsert(archive.logs);
+    }
+  } catch (e) {
+    // If the above fails, delete the inserted creature
+    removeCreatureWork(archive.creature._id);
+    throw e;
+  }
+}
+
+const restoreCreaturefromFile = new ValidatedMethod({
+  name: 'Creatures.methods.restoreCreaturefromFile',
+  validate: new SimpleSchema({
+    'fileId': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  async run({fileId}) {
+    // fetch the file
+    const file = ArchiveCreatureFiles.findOne({_id: fileId}).get();
+    if (!file){
+      throw new Meteor.Error('File not found',
+      'The requested creature archive does not exist');
+    }
+    // Assert ownership
+    const userId = file?.userId;
+    if (!userId || userId !== this.userId){
+      throw new Meteor.Error('Permission denied',
+      'You can only restore creatures you own');
+    }
+
+    assertHasCharactersSlots(this.userId);
+
+    if (Meteor.isServer){
+      // Read the file data
+      const archive = await ArchiveCreatureFiles.readJSONFile(file);
+      restoreCreature(archive, this.userId);
+    }
+    //Remove the archive once the restore succeeded
+    ArchiveCreatureFiles.remove({ _id: fileId });
+    // Update the user's file storage limits
+    incrementFileStorageUsed(userId, -file.size);
+  },
+});
+
+export default restoreCreaturefromFile;

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

@@ -0,0 +1,28 @@
+import { slice } from 'lodash';
+import PER_CREATURE_LOG_LIMIT from '/imports/api/creature/log/CreatureLogs.js';
+
+export default function verifyArchiveSafety({ meta, creature, properties, experiences, logs }){
+  const creatureId = creature._id;
+
+  // Check lengths of arrays
+  if (logs.length > PER_CREATURE_LOG_LIMIT) {
+    logs = slice(logs, 0, PER_CREATURE_LOG_LIMIT);
+  }
+
+  // Check that everything belongs to the right creature
+  logs.forEach(log => {
+    if (log.creatureId !== creatureId) {
+      throw new Meteor.Error('Malicious log', 'Log contains an entry for the wrong creature');
+    }
+  });
+  experiences.forEach(experience => {
+    if (experience.creatureId !== creatureId) {
+      throw new Meteor.Error('Malicious experience', 'Experiences contains an entry for the wrong creature');
+    }
+  });
+  properties.forEach(prop => {
+    if (prop.ancestors[0].id !== creatureId) {
+      throw new Meteor.Error('Malicious prop', 'Properties contains an entry for the wrong creature');
+    }
+  });
+}

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

@@ -1,287 +0,0 @@
-import { includes, cloneDeep } from 'lodash';
-
-// The computation memo is an in-memory data structure used only during the
-// computation process
-export default class ComputationMemo {
-  constructor(props, creature){
-    this.statsByVariableName = {};
-    this.extraStatsByVariableName = {};
-    this.statsById = {};
-    this.originalPropsById = {};
-    this.propsById = {};
-    this.skillsByAbility = {};
-    this.unassignedEffects = [];
-    this.classLevelsById = {};
-    this.classes = {};
-    this.togglesById = {};
-    this.toggleIds = new Set();
-    // Equipped items that might be used as ammo
-    this.equipmentById = {};
-    // Properties that have calculations, but don't impact other properties
-    this.endStepPropsById = {};
-    // First note all the ids of all the toggles
-    props.forEach((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.toggleIds.add(prop._id);
-      }
-    });
-    props.filter((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.addToggle(prop);
-      } else {
-        return true;
-      }
-    }).filter((prop) => {
-      if (
-        prop.type === 'attribute' ||
-        prop.type === 'skill'
-      ) {
-        // Add all the stats
-        this.addStat(prop);
-      } else if (
-        prop.type === 'item'
-      ) {
-        this.addEquipment(prop);
-      } else {
-        return true;
-      }
-    }).forEach((prop) => {
-      // Now add all effects and proficiencies
-      if (prop.type === 'effect'){
-        this.addEffect(prop);
-      } else if (prop.type === 'proficiency') {
-        this.addProficiency(prop);
-      } else if (prop.type === 'classLevel'){
-        this.addClassLevel(prop);
-      } else {
-        this.addEndStepProp(prop);
-      }
-    });
-    for (let name in creature.denormalizedStats){
-      if (!this.statsByVariableName[name]){
-        this.statsByVariableName[name] = {
-          variableName: name,
-          value: creature.denormalizedStats[name],
-          computationDetails: propDetailsByType.denormalizedStat(),
-        }
-      }
-    }
-  }
-  registerProperty(prop){
-    this.originalPropsById[prop._id] = cloneDeep(prop);
-    this.propsById[prop._id] = prop;
-    prop.computationDetails = propDetails(prop);
-    prop.ancestors.forEach(ancestor => {
-      if (this.toggleIds.has(ancestor.id)){
-        prop.computationDetails.toggleAncestors.push(ancestor.id);
-      }
-    });
-    return prop;
-  }
-  addToggle(prop){
-    prop = this.registerProperty(prop);
-    this.togglesById[prop._id] = prop;
-  }
-  addClassLevel(prop){
-    prop = this.registerProperty(prop);
-    this.classLevelsById[prop._id] = prop;
-  }
-  addStat(prop){
-    let variableName = prop.variableName;
-    if (!variableName) return;
-    let existingStat = this.statsByVariableName[variableName];
-    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,
-        });
-      }
-      if (prop.baseProficiency){
-        existingStat.computationDetails.proficiencies.push({
-          value: prop.baseProficiency,
-          stats: [variableName],
-          computationDetails: propDetailsByType.proficiency(),
-          type: 'proficiency',
-          statBase: true,
-        });
-      }
-    } else {
-      prop = this.registerProperty(prop);
-      this.statsById[prop._id] = prop;
-      this.statsByVariableName[variableName] = prop;
-      if (
-        prop.type === 'skill' &&
-        isSkillCheck(prop) &&
-        prop.ability
-      ){
-        this.addSkillToAbility(prop, prop.ability)
-      }
-    }
-  }
-  addSkillToAbility(prop, ability){
-    if (!this.skillsByAbility[ability]){
-      this.skillsByAbility[ability] = [];
-    }
-    this.skillsByAbility[ability].push(prop);
-  }
-  addEffect(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getEffectTargets(prop);
-    targets.forEach(target => {
-      if (target.computationDetails.effects){
-        target.computationDetails.effects.push(prop);
-      }
-    });
-    if (!targets.size){
-      this.unassignedEffects.push(prop);
-    }
-  }
-  getEffectTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach((statName) => {
-      let target = this.statsByVariableName[statName];
-      if (!target) return;
-      targets.add(target);
-      if (isSkillOperation(prop) && isAbility(target)){
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability effects to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addProficiency(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getProficiencyTargets(prop);
-    targets.forEach(target => {
-      target.computationDetails.proficiencies.push(prop);
-    });
-  }
-  getProficiencyTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach(statName => {
-      let target = this.statsByVariableName[statName];
-      if (!target) return;
-      targets.add(target);
-      if (isAbility(target)) {
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability proficiencies to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addEquipment(prop){
-    prop = this.registerProperty(prop);
-    this.equipmentById[prop._id] = prop;
-  }
-  addEndStepProp(prop){
-    prop = this.registerProperty(prop);
-    this.endStepPropsById[prop._id] = prop;
-  }
-}
-
-function isAbility(prop){
-  return prop.type === 'attribute' &&
-  prop.attributeType === 'ability'
-}
-
-function isSkillCheck(prop){
-  return includes(['skill', 'check', 'save', 'utility'], prop.skillType);
-}
-
-const skillOperations = [
-  'advantage',
-  'disadvantage',
-  'passiveAdd',
-  'fail',
-  'conditional',
-  'rollBonus',
-];
-
-function isSkillOperation(prop){
-  return skillOperations.includes(prop.operation);
-}
-
-function propDetails(prop){
-  return propDetailsByType[prop.type] && propDetailsByType[prop.type]() || {};
-}
-
-const propDetailsByType = {
-  toggle(){
-    return {
-      computed: false,
-      busyComputing: false,
-      toggleAncestors: [],
-      disabledByToggle: false,
-    };
-  },
-  attribute(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      toggleAncestors: [],
-      disabledByToggle: false,
-      idsOfSameName: [],
-    };
-  },
-  skill(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      proficiencies: [],
-      toggleAncestors: [],
-      disabledByToggle: false,
-      idsOfSameName: [],
-    };
-  },
-  effect(){
-    return {
-      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/EffectAggregator.js

@@ -1,88 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/evaluateCalculation.js';
-
-export default class EffectAggregator{
-  constructor(stat, memo){
-    delete this.baseValueErrors;
-    if (stat.baseValueCalculation){
-      let {value, errors} = evaluateCalculation(stat.baseValueCalculation, memo);
-      this.statBaseValue = value;
-      if (errors.length){
-        this.baseValueErrors = errors;
-      }
-      this.base = this.statBaseValue;
-    } else {
-      this.base = 0;
-    }
-    this.add = 0;
-    this.mul = 1;
-    this.min = Number.NEGATIVE_INFINITY;
-    this.max = Number.POSITIVE_INFINITY;
-    this.advantage = 0;
-    this.disadvantage = 0;
-    this.passiveAdd = 0;
-    this.fail = 0;
-    this.set = undefined;
-    this.conditional = [];
-    this.rollBonus = [];
-    this.hasNoEffects = true;
-  }
-  addEffect(effect){
-    let result = effect.result;
-    if (this.hasNoEffects) this.hasNoEffects = false;
-    switch(effect.operation){
-      case 'base':
-        // Take the largest base value
-        this.base = result > this.base ? result : this.base;
-        if (effect.statBase){
-          if (this.statBaseValue === undefined || result > this.statBaseValue){
-            this.statBaseValue = result;
-          }
-        }
-        break;
-      case 'add':
-        // Add all adds together
-        this.add += result;
-        break;
-      case 'mul':
-        // Multiply the muls together
-        this.mul *= result;
-        break;
-      case 'min':
-        // Take the largest min value
-        this.min = result > this.min ? result : this.min;
-        break;
-      case 'max':
-        // Take the smallest max value
-        this.max = result < this.max ? result : this.max;
-        break;
-      case 'set':
-        // Take the highest set value
-        this.set = this.set === undefined || result > this.set ? result : this.set;
-        break;
-      case 'advantage':
-        // Sum number of advantages
-        this.advantage++;
-        break;
-      case 'disadvantage':
-        // Sum number of disadvantages
-        this.disadvantage++;
-        break;
-      case 'passiveAdd':
-        // Add all passive adds together
-        this.passiveAdd += result;
-        break;
-      case 'fail':
-        // Sum number of fails
-        this.fail++;
-        break;
-      case 'conditional':
-        // Store array of conditionals
-        this.conditional.push(result);
-        break;
-      case 'rollBonus':
-        // Store array of roll bonuses
-        this.rollBonus.push(result);
-        break;
-    }
-  }
-}

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

@@ -1,98 +0,0 @@
-import math from '/imports/math.js';
-import bareSymbolSubtitutor from '/imports/api/creature/computation/utility/bareSymbolSubtitutor.js';
-
-export default function evaluateString(string, scope){
-  let errors = [];
-  if (!string){
-    errors.push('No string provided');
-    return {result: string, errors};
-  }
-
-  if (!scope) errors.push('No scope provided');
-
-  // Parse the string using mathjs
-  let calc;
-  try {
-    calc = math.parse(string);
-  } catch (e) {
-    errors.push(e);
-    return {result: string, errors};
-  }
-
-  // Replace all bare symbols with symbol.value
-  let transformedCalc = calc.transform(bareSymbolSubtitutor(scope));
-
-  // Evaluate the expression to a number or return with substitutions
-  try {
-    let result = transformedCalc.evaluate(scope);
-    return {result, errors};
-  } catch (e1){
-    errors.push(e1);
-    try {
-      let result = simplifyWithAccessors(transformedCalc, scope).toHTML();
-      return {result, errors};
-    } catch (e2){
-      errors.push(e2);
-      return {result: transformedCalc.toHTML(), errors};
-    }
-  }
-}
-
-function simplifyWithAccessors(calc, scope){
-  let noAccessorCalc = calc.transform(substituteAccessors(scope));
-  return math.simplify(noAccessorCalc);
-}
-
-// returns a function to replace all accessors with either their resolved value
-// or a symbol to simplify with
-function substituteAccessors(scope){
-  return function(node){
-    if (node.isAccessorNode){
-      try {
-        return evaluateAccessor(node, scope);
-      } catch (e) {
-        return replaceAccessorWithSymbol(node);
-      }
-    } else {
-      return node;
-    }
-  }
-}
-
-// Throws error if symbol is undefined in scope
-function evaluateAccessor(node, scope){
-  let value = node.evaluate(scope);
-  if (value === undefined){
-    throw 'Undefined symbol'
-  }
-  return new math.ConstantNode(value);
-}
-
-function replaceAccessorWithSymbol(node){
-  let symbolNode = new math.SymbolNode(node.toString());
-  return symbolNode;
-}
-
-/*
-function overrideSymbolNodeHTML(symbolNode){
-  let safeName = escape(symbolNode.name);
-  symbolNode.toHTML = function(){
-    console.log('running custom tohtml function')
-    return `<span class="math-symbol math-substitution-failed">${safeName}</span>`
-  }
-  return symbolNode;
-}
-
-// Escape special HTML characters
-// Copied directly from math.js source to help with overriding toHTML
-function escape (value) {
-  let text = String(value)
-  text = text.replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-
-  return text
-}
-*/

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

@@ -1,11 +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){
-	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/applyToggles.js

@@ -1,11 +0,0 @@
-import computeToggle from '/imports/api/creature/computation/computeToggle.js';
-
-export default function applyToggles(prop, memo){
-  prop.computationDetails.toggleAncestors.forEach(toggleId => {
-    let toggle = memo.togglesById[toggleId];
-    computeToggle(toggle, memo);
-    if (!toggle.toggleResult){
-      prop.computationDetails.disabledByToggle = true;
-    }
-  });
-}

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

@@ -1,125 +0,0 @@
-import computeStat from '/imports/api/creature/computation/computeStat.js';
-import applyToggles from '/imports/api/creature/computation/applyToggles.js';
-
-export default function combineStat(stat, aggregator, memo){
-  if (stat.type === 'attribute'){
-    combineAttribute(stat, aggregator);
-  } else if (stat.type === 'skill'){
-    combineSkill(stat, aggregator, memo);
-  } else if (stat.type === 'damageMultiplier'){
-    combineDamageMultiplier(stat, memo);
-  }
-}
-
-function getAggregatorResult(stat, aggregator){
-  let result = (aggregator.base + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) {
-    result = aggregator.min;
-  }
-  if (result > aggregator.max) {
-    result = aggregator.max;
-  }
-  if (aggregator.set !== undefined) {
-    result = aggregator.set;
-  }
-  if (!stat.decimal && Number.isFinite(result)){
-    result = Math.floor(result);
-  }
-  return result;
-}
-
-function combineAttribute(stat, aggregator){
-  stat.value = getAggregatorResult(stat, aggregator);
-  stat.baseValue = aggregator.statBaseValue;
-  stat.baseValueErrors = aggregator.baseValueErrors;
-  if (stat.attributeType === 'ability') {
-    stat.modifier = Math.floor((stat.value - 10) / 2);
-  }
-  stat.currentValue = stat.value - (stat.damage || 0);
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined ||
-    undefined
-}
-
-function combineSkill(stat, aggregator, memo){
-  // Skills are based on some ability Modifier
-  let ability = memo.statsByVariableName[stat.ability]
-  if (stat.ability && ability){
-    if (!ability.computationDetails.computed){
-      computeStat(ability, memo);
-    }
-    stat.abilityMod = ability.modifier;
-  }
-  // Combine all the child proficiencies
-  stat.proficiency = stat.baseProficiency || 0;
-  for (let i in stat.computationDetails.proficiencies){
-    let prof = stat.computationDetails.proficiencies[i];
-    applyToggles(prof, memo);
-    if (
-      !prof.computationDetails.disabledByToggle &&
-      prof.value > stat.proficiency
-    ){
-      stat.proficiency = prof.value;
-    }
-  }
-  // Get the character's proficiency bonus to apply
-  let profBonusStat = memo.statsByVariableName['proficiencyBonus'];
-  let profBonus = profBonusStat && profBonusStat.value;
-
-  if (typeof profBonus !== 'number' && memo.statsByVariableName['level']){
-    let level = memo.statsByVariableName['level'].value;
-    profBonus = Math.ceil(level / 4) + 1;
-  }
-  // Multiply the proficiency bonus by the actual proficiency
-  profBonus *= stat.proficiency;
-  // Base value
-  stat.baseValue = aggregator.statBaseValue;
-  stat.baseValueErrors = aggregator.baseValueErrors;
-  // Combine everything to get the final result
-  let result = (aggregator.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) {
-    result = aggregator.set;
-  }
-  if (Number.isFinite(result)){
-    result = Math.floor(result);
-  }
-  stat.value = result;
-  // Advantage/disadvantage
-  if (aggregator.advantage && !aggregator.disadvantage){
-    stat.advantage = 1;
-  } else if (aggregator.disadvantage && !aggregator.advantage){
-    stat.advantage = -1;
-  } else {
-    stat.advantage = 0;
-  }
-  // Passive bonus
-  stat.passiveBonus = aggregator.passiveAdd;
-  // conditional benefits
-  stat.conditionalBenefits = aggregator.conditional;
-  // Roll bonuses
-  stat.rollBonus = aggregator.rollBonus;
-  // Forced to fail
-  stat.fail = aggregator.fail;
-  // Rollbonus
-  stat.rollBonuses = aggregator.rollBonus;
-  // Hide
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined &&
-    stat.proficiency == 0 ||
-    undefined;
-}
-
-function combineDamageMultiplier(stat){
-  if (stat.immunityCount) return 0;
-  let result;
-  if (stat.ressistanceCount && !stat.vulnerabilityCount){
-    result = 0.5;
-  }  else if (!stat.ressistanceCount && stat.vulnerabilityCount){
-    result = 2;
-  } else {
-    result = 1;
-  }
-  stat.value = result;
-}

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

@@ -1,45 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/applyToggles.js';
-
-export default function computeEffect(effect, memo){
-  if (effect.computationDetails.computed) return;
-  if (effect.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    effect.computationDetails.computed = true;
-    effect.result = NaN;
-    effect.computationDetails.busyComputing = false;
-    effect.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', effect);
-    return;
-  }
-  // Before doing any work, mark this effect as busy
-  effect.computationDetails.busyComputing = true;
-
-  // Apply any toggles
-  applyToggles(effect, memo);
-
-  // Determine result of effect calculation
-  delete effect.errors;
-  if (!effect.calculation){
-    if(effect.operation === 'add' || effect.operation === 'base'){
-      effect.result = 0;
-    } else {
-      delete effect.result
-    }
-  } else if (Number.isFinite(+effect.calculation)){
-    effect.result = +effect.calculation;
-  } else if(effect.operation === 'conditional' || effect.operation === 'rollBonus'){
-    effect.result = effect.calculation;
-  } else if(_.contains(['advantage', 'disadvantage', 'fail'], effect.operation)){
-    effect.result = 1;
-  } else {
-    let {value, errors} = evaluateCalculation(effect.calculation, memo);
-    effect.result = value;
-    if (errors.length){
-      effect.errors = errors;
-    }
-  }
-  effect.computationDetails.computed = true;
-  effect.computationDetails.busyComputing = false;
-}

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

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

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

@@ -1,44 +0,0 @@
-import { forOwn, has } from 'lodash';
-
-export default function computeLevels(memo){
-  computeClassLevels(memo);
-  computeTotalLevel(memo);
-}
-
-function computeClassLevels(memo){
-  forOwn(memo.classLevelsById, classLevel => {
-    let name = classLevel.variableName;
-    let stat = memo.statsByVariableName[name];
-    if (!stat){
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    } else if (!has(stat, 'level')){
-      // Stat is overriden by an attribute
-      return;
-    } else if (stat.level < classLevel.level) {
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    }
-  });
-}
-
-function computeTotalLevel(memo){
-  let currentLevel = memo.statsByVariableName['level'];
-  if (!currentLevel){
-    currentLevel = {
-      value: 0,
-      computationDetails: {
-        builtIn: true,
-        computed: true,
-      }
-    };
-    memo.statsByVariableName['level'] = currentLevel;
-  }
-  // bail out if overriden by an attribute
-  if (!currentLevel.computationDetails.builtIn) return;
-  let level = 0;
-  for (let name in memo.classes){
-    level += memo.classes[name].level || 0;
-  }
-  memo.statsByVariableName['level'].value = level;
-}

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

@@ -1,27 +0,0 @@
-import { each, forOwn } from 'lodash';
-import computeLevels from '/imports/api/creature/computation/computeLevels.js';
-import computeStat from '/imports/api/creature/computation/computeStat.js';
-import computeEffect from '/imports/api/creature/computation/computeEffect.js';
-import computeToggle from '/imports/api/creature/computation/computeToggle.js';
-import computeEndStepProperty from '/imports/api/creature/computation/computeEndStepProperty.js';
-
-export default function computeMemo(memo){
-  // Compute level
-  computeLevels(memo);
-  // Compute all stats, even if they are overriden
-  forOwn(memo.statsById, stat => {
-    computeStat (stat, memo);
-  });
-  // Compute effects which didn't end up targeting a stat
-  each(memo.unassignedEffects, effect => {
-    computeEffect(effect, memo);
-  });
-  // Compute toggles which didn't already get computed by dependencies
-  forOwn(memo.togglesById, toggle => {
-    computeToggle(toggle, memo);
-  });
-  // Compute end step properties
-  forOwn(memo.endStepPropsById, prop => {
-    computeEndStepProperty(prop, memo);
-  });
-}

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

@@ -1,40 +0,0 @@
-import combineStat from '/imports/api/creature/computation/combineStat.js';
-import computeEffect from '/imports/api/creature/computation/computeEffect.js';
-import EffectAggregator from '/imports/api/creature/computation/EffectAggregator.js';
-import applyToggles from '/imports/api/creature/computation/applyToggles.js';
-import { each } from 'lodash';
-
-export default function computeStat(stat, memo){
-  // If the stat is already computed, skip it
-  if (stat.computationDetails.computed) return;
-  if (stat.computationDetails.busyComputing){
-    // Trying to compute this stat again while it is already computing.
-    // We must be in a dependency loop.
-    stat.computationDetails.computed = true;
-    stat.value = NaN;
-    stat.computationDetails.busyComputing = false;
-    stat.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', stat);
-    return;
-  }
-  // Before doing any work, mark this stat as busy
-  stat.computationDetails.busyComputing = true;
-  // Apply any toggles
-  applyToggles(stat, memo);
-
-  if (!stat.computationDetails.disabledByToggle){
-    // Compute and aggregate all the effects
-    let aggregator = new EffectAggregator(stat, memo)
-    each(stat.computationDetails.effects, (effect) => {
-      computeEffect(effect, memo);
-      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;
-  stat.computationDetails.busyComputing = false;
-}

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

@@ -1,37 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/evaluateCalculation.js';
-
-export default function computeToggle(toggle, memo){
-  if (toggle.computationDetails.computed) return;
-  if (toggle.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    toggle.computationDetails.computed = true;
-    toggle.result = false;
-    toggle.computationDetails.busyComputing = false;
-    toggle.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', toggle);
-    return;
-  }
-  // Before doing any work, mark this toggle as busy
-  toggle.computationDetails.busyComputing = true;
-
-  // Do work
-  delete toggle.errors;
-  if (toggle.enabled){
-    toggle.toggleResult = true;
-  } else if (toggle.disabled){
-    toggle.toggleResult = false;
-  } else if (!toggle.condition){
-    toggle.toggleResult = false;
-  } else if (Number.isFinite(+toggle.condition)){
-    toggle.toggleResult = !!+toggle.condition;
-  } else {
-    let {value, errors} = evaluateCalculation(toggle.condition, memo);
-    toggle.toggleResult = value;
-    if (errors.length){
-      toggle.errors = errors;
-    }
-  }
-  toggle.computationDetails.computed = true;
-  toggle.computationDetails.busyComputing = false;
-}

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

@@ -1,98 +0,0 @@
-import computeStat from '/imports/api/creature/computation/computeStat.js';
-import math from '/imports/math.js';
-
-/* Convert a calculation into a constant output and errors*/
-export default function evaluateCalculation(string, memo){
-  if (!string) return {errors: [], value: string};
-  let errors = [];
-  // Parse the string using mathjs
-  let calc;
-  try {
-    calc = math.parse(string);
-  } catch (e) {
-    errors.push({
-      type: 'parsing',
-      message: e.message || e
-    });
-    return {errors, value: string};
-  }
-  // Ensure all symbol nodes are defined and coputed
-  calc.traverse(node => {
-    if (node.isSymbolNode){
-      let stat = memo.statsByVariableName[node.name];
-      if (stat && !stat.computationDetails.computed){
-        computeStat(stat, memo);
-      }
-    }
-  });
-  // Replace all symbols with their subtitution
-  let substitutedCalc = calc.transform(
-    symbolSubtitutor(memo.statsByVariableName, errors)
-  );
-  // Evaluate the expression to a number or return with substitutions
-  try {
-    let value = substitutedCalc.evaluate(memo.statsByVariableName);
-    if (typeof value === 'object') value = value.toString();
-    return {errors, value};
-  } catch (e){
-    errors.push({
-      type: 'evaluation',
-      message: e.message || e
-    });
-    let value = substitutedCalc.toString();
-    return {errors, value};
-  }
-}
-
-// returns a function to replace all symbols with either their resolved value
-// or zero, keeping the errors
-function symbolSubtitutor(scope, errors){
-  return function(node){
-    // mark symbol nodes that are children of function nodes to be skipped
-    if (node.isFunctionNode){
-      let fn = node.fn;
-      if (fn && fn.isSymbolNode){
-        fn.skipReplacement = true;
-      }
-      return node;
-    } else if (node.isSymbolNode && node.skipReplacement !== true){
-      //bare symbols of name "stat", should search for stat.value
-      let stat = scope[node.name];
-      if (stat){
-        if (stat.value === undefined){
-          errors.push({
-            type: 'subsitution',
-            message: `${node.name} does not have a value, set to 0`
-          });
-          return new math.ConstantNode(0);
-        } else {
-          return new math.ConstantNode(stat.value);
-        }
-      } else {
-        try {
-          return new math.ConstantNode(node.evaluate(scope));
-        } catch (e) {
-          errors.push({
-            type: 'subsitution',
-            message: `${node.name} not found, set to 0`
-          });
-          return new math.ConstantNode(0);
-        }
-      }
-    } else if (node.isAccessorNode){
-      try {
-        let value = node.evaluate(scope);
-        if (value === undefined) throw 'Not found';
-        return new math.ConstantNode(value);
-      } catch (e) {
-        errors.push({
-          type: 'subsitution',
-          message: `${node.toString()} not found, set to 0`
-        });
-        return new math.ConstantNode(0);
-      }
-    } else {
-      return node;
-    }
-  }
-}

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

@@ -1,109 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
-import ComputationMemo from '/imports/api/creature/computation/ComputationMemo.js';
-import computeMemo from '/imports/api/creature/computation/computeMemo.js';
-import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
-import writeAlteredProperties from '/imports/api/creature/computation/writeAlteredProperties.js';
-import writeCreatureVariables from '/imports/api/creature/computation/writeCreatureVariables.js';
-import { recomputeDamageMultipliersById } from '/imports/api/creature/damageMultiplierDenormalise/recomputeDamageMultipliers.js';
-import Creatures from '/imports/api/creature/Creatures.js';
-
-export const recomputeCreature = new ValidatedMethod({
-
-  name: 'creatures.recomputeCreature',
-
-  validate: new SimpleSchema({
-    charId: { type: String }
-  }).validator(),
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({charId}) {
-    let creature = Creatures.findOne(charId);
-    // Permission
-    assertEditPermission(creature, this.userId);
-    // Work, call this direcly if you are already in a method that has checked
-    // for permission to edit a given character
-    recomputeCreatureById(charId);
-  },
-
-});
-
-const calculationPropertyTypes = [
-  'attribute',
-  'skill',
-  'effect',
-  'proficiency',
-  'classLevel',
-  'toggle',
-  'item',
-  // End step types
-  'action',
-  'attack',
-  'savingThrow',
-  'spellList',
-  'spell',
-];
-
-export function recomputeCreatureById(creatureId){
-  let creature = Creatures.findOne(creatureId);
-  recomputeCreatureByDoc(creature);
-}
-
-/**
- * This function is the heart of DiceCloud. It recomputes a creature's stats,
- * distilling down effects and proficiencies into the final stats that make up
- * a creature.
- *
- * Essentially this is a depth first tree traversal algorithm that computes
- * stats' dependencies before computing stats themselves, while detecting
- * dependency loops.
- *
- * At the moment it makes no effort to limit recomputation to just what was
- * changed.
- *
- * Attempting to implement dependency management to limit recomputation to just
- * change affected stats should only happen as a last resort, when this function
- * can no longer be performed more efficiently, and server resources can not be
- * expanded to meet demand.
- *
- * A brief overview:
- * - Fetch the stats of the creature and add them to
- *   an object for quick lookup
- * - Fetch the effects and proficiencies which apply to each stat and store them with the stat
- * - Fetch the class levels and store them as well
- * - Mark each stat and effect as uncomputed
- * - Iterate over each stat in order and compute it
- *   - If the stat is already computed, skip it
- *   - If the stat is busy being computed, we are in a dependency loop, make it NaN and mark computed
- *   - Mark the stat as busy computing
- *   - Iterate over each effect which applies to the attribute
- *     - If the effect is not computed compute it
- *       - If the effect relies on another attribute, get its computed value
- *       - Recurse if that attribute is uncomputed
- *     - apply the effect to the attribute
- *   - Conglomerate all the effects to compute the final stat values
- *   - Mark the stat as computed
- * - Write the computed results back to the database
- */
-export function recomputeCreatureByDoc(creature){
-  const creatureId = creature._id;
-  let props = getActiveProperties({
-    ancestorId: creatureId,
-    filter: {type: {$in: calculationPropertyTypes}},
-    includeUntoggled: true,
-    // TODO filter out expensive fields, particularly icon field
-  });
-  let computationMemo = new ComputationMemo(props, creature);
-  computeMemo(computationMemo);
-  writeAlteredProperties(computationMemo);
-  writeCreatureVariables(computationMemo, creatureId);
-  recomputeDamageMultipliersById(creatureId);
-  return computationMemo;
-}

app/imports/api/creature/computation/utility/bareSymbolSubtitutor.js

@@ -1,24 +0,0 @@
-import math from '/imports/math.js';
-
-export default function bareSymbolSubtitutor(scope){
-  return function(node, path){
-    if (!scope) return node;
-    if (node.isFunctionNode){
-      let fn = node.fn;
-      if (fn && fn.isSymbolNode){
-        fn.skipReplacement = true;
-      }
-      return node;
-    } else if (
-      node.isSymbolNode &&
-      path !== 'object' &&
-      node.skipReplacement !== true
-    ) {
-      let stat = scope[node.name];
-      if (!stat) return node;
-      return new math.ConstantNode(stat.value);
-    } else {
-      return node;
-    }
-  }
-}

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

@@ -1,127 +0,0 @@
-import { Meteor } from 'meteor/meteor'
-import { isEqual, forOwn } from 'lodash';
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
-// Schemas
-// Calculated props
-import { ComputedOnlySkillSchema } from '/imports/api/properties/Skills.js';
-import { ComputedOnlyAttributeSchema } from '/imports/api/properties/Attributes.js';
-import { ComputedOnlyEffectSchema } from '/imports/api/properties/Effects.js';
-import { ComputedOnlyToggleSchema } from '/imports/api/properties/Toggles.js';
-// End step props
-import { ComputedOnlyActionSchema } from '/imports/api/properties/Actions.js';
-import { ComputedOnlyAttackSchema } from '/imports/api/properties/Attacks.js';
-import { ComputedOnlySavingThrowSchema } from '/imports/api/properties/SavingThrows.js';
-import { ComputedOnlySpellListSchema } from '/imports/api/properties/SpellLists.js';
-import { ComputedOnlySpellSchema } from '/imports/api/properties/Spells.js';
-
-const schemasByType = {
-  'skill': ComputedOnlySkillSchema,
-  'attribute': ComputedOnlyAttributeSchema,
-  'effect': ComputedOnlyEffectSchema,
-  'toggle': ComputedOnlyToggleSchema,
-  'action': ComputedOnlyActionSchema,
-  'attack': ComputedOnlyAttackSchema,
-  'savingThrow': ComputedOnlySavingThrowSchema,
-  'spellList': ComputedOnlySpellListSchema,
-  'spell': ComputedOnlySpellSchema,
-};
-
-export default function writeAlteredProperties(memo){
-  let bulkWriteOperations = [];
-  // Loop through all properties on the memo
-  forOwn(memo.propsById, changed => {
-    let schema = schemasByType[changed.type];
-    if (!schema) return;
-    let extraIds = changed.computationDetails.idsOfSameName;
-    let ids;
-    if (extraIds && extraIds.length){
-      ids = [changed._id, ...extraIds];
-    } else {
-      ids = [changed._id];
-    }
-    ids.forEach(id => {
-      let op = undefined;
-      let original = memo.originalPropsById[id];
-      op = addChangedKeysToOp(op, schema.objectKeys(), original, changed);
-      if (op){
-        bulkWriteOperations.push(op);
-      }
-    });
-  });
-  bulkWriteProperties(bulkWriteOperations);
-}
-
-function addChangedKeysToOp(op, keys, original, changed) {
-  // Loop through all keys that can be changed by computation
-  // and compile an operation that sets all those keys
-  for (let key of keys){
-    if (!isEqual(original[key], changed[key])){
-      if (!op) op = newOperation(original._id, changed.type);
-      let value = changed[key];
-      if (value === undefined){
-        // Unset values that become undefined
-        addUnsetOp(op, key);
-      } else {
-        // Set values that changed to something else
-        addSetOp(op, key, value);
-      }
-    }
-  }
-  return op;
-}
-
-function newOperation(_id, type){
-  let newOp = {
-    updateOne: {
-      filter: {_id},
-      update: {},
-    }
-  };
-  if (Meteor.isClient){
-    newOp.type = type;
-  }
-  return newOp;
-}
-
-function addSetOp(op, key, value){
-  if (op.updateOne.update.$set){
-    op.updateOne.update.$set[key] = value;
-  } else {
-    op.updateOne.update.$set = {[key]: value};
-  }
-}
-
-function addUnsetOp(op, key){
-  if (op.updateOne.update.$unset){
-    op.updateOne.update.$unset[key] = 1;
-  } else {
-    op.updateOne.update.$unset = {[key]: 1};
-  }
-}
-
-function bulkWriteProperties(bulkWriteOps){
-  if (!bulkWriteOps.length) return;
-  if (Meteor.isServer){
-    CreatureProperties.rawCollection().bulkWrite(
-      bulkWriteOps,
-      {ordered : false},
-      function(e){
-        if (e) {
-          console.error('Bulk write failed: ');
-          console.error(e);
-        }
-      }
-    );
-  } else {
-    bulkWriteOps.forEach(op => {
-      let updateOneOrMany = op.updateOne || op.updateMany;
-      CreatureProperties.update(updateOneOrMany.filter, updateOneOrMany.update, {
-        // The server code is bypassing collection 2 validation, so do the same
-        // on the client
-        // include this if bypass is off:
-        // selector: {type: op.type}
-        bypassCollection2: true,
-      });
-    });
-  }
-}

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

@@ -1,35 +0,0 @@
-import { pick, forOwn } from 'lodash';
-import Creatures from '/imports/api/creature/Creatures.js';
-
-export default function writeCreatureVariables(memo, creatureId) {
-  const fields = [
-    'name',
-    'attributeType',
-    'baseValue',
-    'damage',
-    'decimal',
-    'reset',
-    'resetMultiplier',
-    'value',
-    'currentValue',
-    'modifier',
-    'ability',
-    'skillType',
-    'baseProficiency',
-    'abilityMod',
-    'advantage',
-    'passiveBonus',
-    'proficiency',
-    'conditionalBenefits',
-    'rollBonuses',
-    'fail',
-    'level',
-  ];
-
-  memo.creatureVariables = {};
-  forOwn(memo.statsByVariableName, (stat, variableName) => {
-    let condensedStat = pick(stat, fields);
-    memo.creatureVariables[variableName] = condensedStat;
-  });
-  Creatures.update(creatureId, {$set: {variables: memo.creatureVariables}});
-}

app/imports/api/creature/creatureComputation.test.js

@@ -1,97 +0,0 @@
-import {computeCreature} from "./recomputeCreature.js";
-import assert from "assert";
-
-const makeEffect = function(operation, value){
-  let effect = {computed: false, result: 0, operation}
-  if (_.isFinite(value)){
-    effect.value = +value;
-  } else {
-    effect.calculation = value;
-  }
-  return effect;
-}
-
-describe('computeCreature', function () {
-  it('computes an aritrary creature', function () {
-    let char = {
-      atts: {
-        attribute1: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          attributeType: "ability",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", 10),
-            makeEffect("add", 5),
-            makeEffect("mul", 2),
-          ],
-        },
-        attribute2: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", "attribute1"),
-            makeEffect("max", 2),
-          ],
-        },
-      },
-      skills: {
-        skill1: {
-          computed: false,
-          busyComputing: false,
-          type: "skill",
-          ability: "attribute1",
-          result: 0,
-          proficiency: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          advantage: 0,
-          disadvantage: 0,
-          passiveAdd: 0,
-          fail: 0,
-          conditional: 0,
-          effects: [],
-          proficiencies: [],
-        },
-      },
-      dms: {
-        dm1: {
-          computed: false,
-          busyComputing: false,
-          type: "damageMultiplier",
-          result: 0,
-          immunityCount: 0,
-          ressistanceCount: 0,
-          vulnerabilityCount: 0,
-          effects: [],
-        }
-      },
-      classes: {
-        Barbarian: {
-          level: 5,
-        },
-      },
-      level: 5,
-    };
-    char = computeCreature(char);
-    console.log(char);
-    assert(true);
-  });
-});

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

@@ -0,0 +1,39 @@
+import SimpleSchema from 'simpl-schema';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+
+let CreatureFolders = new Mongo.Collection('creatureFolders');
+
+let creatureFolderSchema = new SimpleSchema({
+  name: {
+    type: String,
+    trim: false,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  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

@@ -0,0 +1,112 @@
+import { Mongo } from 'meteor/mongo';
+import SimpleSchema from 'simpl-schema';
+import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
+import ChildSchema from '/imports/api/parenting/ChildSchema.js';
+import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
+import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex.js';
+import { storedIconsSchema } from '/imports/api/icons/Icons.js';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+
+let CreatureProperties = new Mongo.Collection('creatureProperties');
+
+let CreaturePropertySchema = new SimpleSchema({
+  _id: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+  },
+  _migrationError: {
+    type: String,
+    optional: true,
+  },
+  type: {
+    type: String,
+    allowedValues: Object.keys(propertySchemasIndex),
+  },
+  tags: {
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.tagCount,
+  },
+  'tags.$': {
+    type: String,
+    max: STORAGE_LIMITS.tagLength,
+  },
+  disabled: {
+    type: Boolean,
+    optional: true,
+  },
+  icon: {
+    type: storedIconsSchema,
+    optional: true,
+    max: STORAGE_LIMITS.icon,
+  },
+  // Reference to the library node that this property was copied from
+  libraryNodeId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    optional: true,
+  },
+});
+
+const DenormalisedOnlyCreaturePropertySchema = new SimpleSchema({
+  // Denormalised flag if this property is inactive on the sheet for any reason
+  // Including being disabled, or a decendent of a disabled property
+  inactive: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+    removeBeforeCompute: true,
+  },
+  // Denormalised flag if this property was made inactive by an inactive
+  // ancestor. True if this property has an inactive ancestor even if this
+  // property is itself inactive
+  deactivatedByAncestor: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+    removeBeforeCompute: true,
+  },
+  // Denormalised flag if this property was made inactive because of its own
+  // state
+  deactivatedBySelf: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+    removeBeforeCompute: true,
+  },
+  // 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,
+    removeBeforeCompute: true,
+  },
+  // When this is true on any property, the creature needs to be recomputed
+  dirty: {
+    type: Boolean,
+    // Default to true because new properties cause a recomputation
+    defaultValue: true,
+    optional: true,
+  },
+});
+
+CreaturePropertySchema.extend(DenormalisedOnlyCreaturePropertySchema);
+
+for (let key in propertySchemasIndex) {
+  let schema = new SimpleSchema({});
+  schema.extend(propertySchemasIndex[key]);
+  schema.extend(CreaturePropertySchema);
+  schema.extend(ColorSchema);
+  schema.extend(ChildSchema);
+  schema.extend(SoftRemovableSchema);
+  CreatureProperties.attachSchema(schema, {
+    selector: { type: key }
+  });
+}
+
+export default CreatureProperties;
+export {
+  DenormalisedOnlyCreaturePropertySchema,
+  CreaturePropertySchema,
+};

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

@@ -0,0 +1,5 @@
+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/adjustQuantity.js

@@ -0,0 +1,63 @@
+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 getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+
+const adjustQuantity = new ValidatedMethod({
+  name: 'creatureProperties.adjustQuantity',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id,
+    operation: {
+      type: String,
+      allowedValues: ['set', 'increment']
+    },
+    value: Number,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, operation, value }) {
+    // Permissions
+    let property = CreatureProperties.findOne(_id);
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Do work
+    adjustQuantityWork({ property, operation, value });
+  },
+});
+
+export function adjustQuantityWork({ property, operation, value }) {
+  // Check if property has quantity
+  let schema = CreatureProperties.simpleSchema(property);
+  if (!schema.allowsKey('quantity')) {
+    throw new Meteor.Error(
+      'Adjust quantity failed',
+      `Property of type "${property.type}" doesn't have a quantity`
+    );
+  }
+  if (operation === 'set') {
+    CreatureProperties.update(property._id, {
+      $set: { quantity: value, dirty: true }
+    }, {
+      selector: property
+    });
+  } else if (operation === 'increment') {
+    // value here is 'damage'
+    value = -value;
+    let currentQuantity = property.quantity;
+    if (currentQuantity + value < 0) value = -currentQuantity;
+    CreatureProperties.update(property._id, {
+      $inc: { quantity: value },
+      $set: { dirty: true }
+    }, {
+      selector: property
+    });
+  }
+}
+
+export default adjustQuantity;

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

@@ -0,0 +1,141 @@
+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 { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import ActionContext from '/imports/api/engine/actions/ActionContext.js';
+
+const damageProperty = new ValidatedMethod({
+  name: 'creatureProperties.damage',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id,
+    operation: {
+      type: String,
+      allowedValues: ['set', 'increment']
+    },
+    value: Number,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 20,
+    timeInterval: 5000,
+  },
+  run({ _id, operation, value }) {
+
+    // Get action context
+    let prop = CreatureProperties.findOne(_id);
+    if (!prop) throw new Meteor.Error(
+      'Damage property failed', 'Property doesn\'t exist'
+    );
+    const creatureId = prop.ancestors[0].id;
+    const actionContext = new ActionContext(creatureId, [creatureId], this);
+
+    // Check permissions
+    assertEditPermission(actionContext.creature, this.userId);
+
+    // Check if property can take damage
+    let schema = CreatureProperties.simpleSchema(prop);
+    if (!schema.allowsKey('damage')) {
+      throw new Meteor.Error(
+        'Damage property failed',
+        `Property of type "${prop.type}" can't be damaged`
+      );
+    }
+
+    // Replace the prop by its actionContext counterpart if possible
+    if (prop.variableName) {
+      const actionContextProp = actionContext.scope[prop.variableName];
+      if (actionContextProp?._id === prop._id) {
+        prop = actionContextProp;
+      }
+    }
+
+    const result = damagePropertyWork({ prop, operation, value, actionContext });
+
+    // Insert the log
+    actionContext.writeLog();
+    return result;
+  },
+});
+
+export function damagePropertyWork({ prop, operation, value, actionContext, logFunction }) {
+
+  // Save the value to the scope before applying the before triggers
+  if (operation === 'increment') {
+    if (value >= 0) {
+      actionContext.scope['$damage'] = value;
+    } else {
+      actionContext.scope['$healing'] = -value;
+    }
+  } else {
+    actionContext.scope['$set'] = value;
+  }
+
+  applyTriggers(actionContext.triggers?.damageProperty?.before, prop, actionContext);
+
+  // fetch the value from the scope after the before triggers, in case they changed them
+  if (operation === 'increment') {
+    if (value >= 0) {
+      value = actionContext.scope['$damage'];
+    } else {
+      value = -actionContext.scope['$healing'];
+    }
+  } else {
+    value = actionContext.scope['$set'];
+  }
+
+  let damage, newValue, increment;
+  if (operation === 'set') {
+    const total = prop.total || 0;
+    // Set represents what we want the value to be after damage
+    // So we need the actual damage to get to that value
+    damage = total - value;
+    // Damage can't exceed total value
+    if (damage > total && !prop.ignoreLowerLimit) damage = total;
+    // Damage must be positive
+    if (damage < 0 && !prop.ignoreUpperLimit) damage = 0;
+    newValue = prop.total - damage;
+    // Write the results
+    CreatureProperties.update(prop._id, {
+      $set: { damage, value: newValue, dirty: true }
+    }, {
+      selector: prop
+    });
+    // Also write it straight to the prop so that it is updated in the actionContext
+    prop.damage = damage;
+    prop.value = newValue;
+    logFunction?.(newValue);
+  } else if (operation === 'increment') {
+    let currentValue = prop.value || 0;
+    let currentDamage = prop.damage || 0;
+    increment = value;
+    // Can't increase damage above the remaining value
+    if (increment > currentValue && !prop.ignoreLowerLimit) increment = currentValue;
+    // Can't decrease damage below zero
+    if (-increment > currentDamage && !prop.ignoreUpperLimit) increment = -currentDamage;
+    damage = currentDamage + increment;
+    newValue = prop.total - damage;
+    // Write the results
+    CreatureProperties.update(prop._id, {
+      $inc: { damage: increment, value: -increment },
+      $set: { dirty: true },
+    }, {
+      selector: prop
+    });
+    // Also write it straight to the prop so that it is updated in the actionContext
+    prop.damage += increment;
+    prop.value -= increment;
+    logFunction?.(increment);
+  }
+
+  applyTriggers(actionContext.triggers?.damageProperty?.after, prop, actionContext);
+
+  if (operation === 'set') {
+    return damage;
+  } else if (operation === 'increment') {
+    return increment;
+  }
+}
+
+export default damageProperty;

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

@@ -0,0 +1,96 @@
+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 { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.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/client/ui/components/snackbars/SnackbarQueue.js'
+  ).snackbar
+}
+
+const DUPLICATE_CHILDREN_LIMIT = 50;
+
+const duplicateProperty = new ValidatedMethod({
+  name: 'creatureProperties.duplicate',
+  validate: new SimpleSchema({
+    _id: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    }
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    let property = CreatureProperties.findOne(_id);
+    let creature = getRootCreatureAncestor(property);
+
+    assertEditPermission(creature, this.userId);
+
+    // 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;
+
+    // Mark the sheet as needing recompute
+    property.dirty = true;
+
+    // Insert the properties
+    CreatureProperties.batchInsert([property, ...nodes]);
+
+    // Tree structure changed by inserts, reorder the tree
+    reorderDocs({
+      collection: CreatureProperties,
+      ancestorId: property.ancestors[0].id,
+    });
+
+    return propertyId;
+  },
+});
+
+export default duplicateProperty;

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

@@ -0,0 +1,51 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
+import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
+
+// Equipping or unequipping an item will also change its parent
+const equipItem = new ValidatedMethod({
+  name: 'creatureProperties.equip',
+  validate({ _id, equipped }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+    if (equipped !== true && equipped !== false) {
+      throw new Meteor.Error('No equipped', 'equipped is required to be true or false');
+    }
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, equipped }) {
+    let item = CreatureProperties.findOne(_id);
+    if (item.type !== 'item') throw new Meteor.Error('wrong type',
+      'Equip and unequip can only be performed on items');
+    let creature = getRootCreatureAncestor(item);
+    assertEditPermission(creature, this.userId);
+    CreatureProperties.update(_id, {
+      $set: { equipped, dirty: true },
+    }, {
+      selector: { type: 'item' },
+    });
+    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: {
+        id: _id,
+        collection: 'creatureProperties',
+      },
+      parentRef,
+      order: Number.MAX_SAFE_INTEGER,
+      skipRecompute: true,
+    });
+  },
+});
+
+export default equipItem;

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

@@ -0,0 +1,47 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+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';
+
+const flipToggle = new ValidatedMethod({
+  name: 'creatureProperties.flipToggle',
+  validate({ _id }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    // Permission
+    let property = CreatureProperties.findOne(_id, {
+      fields: { type: 1, ancestors: 1, enabled: 1, disabled: 1 }
+    });
+    if (property.type !== 'toggle') {
+      throw new Meteor.Error('wrong property',
+        'This method can only be applied to toggles');
+    }
+    if (!property.enabled && !property.disabled) {
+      throw new Meteor.Error('Computed toggle',
+        'Can\'t flip a toggle that is computed')
+    }
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Invert the current value, disabled is the canonical store of value
+    const currentValue = !property.disabled;
+    CreatureProperties.update(_id, {
+      $set: {
+        enabled: !currentValue,
+        disabled: currentValue,
+        dirty: true,
+      }
+    }, {
+      selector: { type: 'toggle' },
+    });
+  },
+});
+
+export default flipToggle;

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

@@ -0,0 +1,63 @@
+export default function getSlotFillFilter({slot, libraryIds}){
+  let filter = {
+    removed: {$ne: true},
+    $and: []
+  };
+  if (libraryIds){
+    filter['ancestors.id'] = {$in: libraryIds};
+  }
+  if (slot.slotType){
+    filter.$and.push({
+      $or: [{
+        type: slot.slotType
+      },{
+        type: 'slotFiller',
+        slotFillerType: slot.slotType,
+      }]
+    });
+  } else if (slot.type === 'class') {
+    filter.$and.push({
+      $or: [{
+        type: 'classLevel',
+      },{
+        type: 'slotFiller',
+        slotFillerType: 'classLevel',
+      }]
+    });
+    if (slot.variableName) { 
+      filter.variableName = slot.variableName;
+    }
+
+    // Only search for levels the class needs
+    if (slot.missingLevels && slot.missingLevels.length) {
+      filter.level = {$in: slot.missingLevels};
+    } else {
+      filter.level = (slot.level || 0) + 1;
+    }
+  }
+  let tagsOr = [];
+  let tagsNin = [];
+  if (slot.slotTags && slot.slotTags.length){
+    tagsOr.push({tags: {$all: slot.slotTags}});
+  }
+  if (slot.extraTags && slot.extraTags.length){
+    slot.extraTags.forEach(extra => {
+      if (!extra.tags || !extra.tags.length) return;
+      if (extra.operation === 'OR'){
+        tagsOr.push({tags: {$all: extra.tags}});
+      } else if (extra.operation === 'NOT'){
+        tagsNin.push(...extra.tags);
+      }
+    });
+  }
+  if (tagsOr.length){
+    filter.$or = tagsOr;
+  }
+  if (tagsNin.length){
+    filter.$and.push({tags: {$nin: tagsNin}});
+  }
+  if (!filter.$and.length){
+    delete filter.$and;
+  }
+  return filter;
+}

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

@@ -0,0 +1,13 @@
+import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
+import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
+import '/imports/api/creature/creatureProperties/methods/duplicateProperty.js';
+import '/imports/api/creature/creatureProperties/methods/equipItem.js';
+import '/imports/api/creature/creatureProperties/methods/insertProperty.js';
+import '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
+import '/imports/api/creature/creatureProperties/methods/pullFromProperty.js';
+import '/imports/api/creature/creatureProperties/methods/pushToProperty.js';
+import '/imports/api/creature/creatureProperties/methods/restoreProperty.js';
+import '/imports/api/creature/creatureProperties/methods/selectAmmoItem.js';
+import '/imports/api/creature/creatureProperties/methods/softRemoveProperty.js';
+import '/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js';
+import '/imports/api/creature/creatureProperties/methods/flipToggle.js';

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

@@ -0,0 +1,145 @@
+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 { 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: new SimpleSchema({
+    creatureProperty: {
+      type: Object,
+      blackbox: true,
+    },
+    parentRef: RefSchema,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ creatureProperty, parentRef }) {
+    // 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,
+    });
+  },
+});
+
+export function insertPropertyWork({ property, creature }) {
+  delete property._id;
+  property.dirty = true;
+  let _id = CreatureProperties.insert(property);
+  // Tree structure changed by insert, reorder the tree
+  reorderDocs({
+    collection: CreatureProperties,
+    ancestorId: creature._id,
+  });
+  return _id;
+}
+
+export default insertProperty;
+export { insertPropertyAsChildOfTag };

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

@@ -0,0 +1,245 @@
+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 LibraryNodes from '/imports/api/library/LibraryNodes.js';
+import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import {
+  setLineageOfDocs,
+  getAncestry,
+  renewDocIds
+} from '/imports/api/parenting/parenting.js';
+import { reorderDocs } from '/imports/api/parenting/order.js';
+import { setDocToLastOrder } from '/imports/api/parenting/order.js';
+import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
+
+const insertPropertyFromLibraryNode = new ValidatedMethod({
+  name: 'creatureProperties.insertPropertyFromLibraryNode',
+  validate: new SimpleSchema({
+    nodeIds: {
+      type: Array,
+      max: 20,
+    },
+    'nodeIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    parentRef: {
+      type: RefSchema,
+    },
+    order: {
+      type: Number,
+      optional: true,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ nodeIds, parentRef, order }) {
+    // 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);
+
+    // {libraryId: hasViewPermission}
+    //let libraryPermissionMemoir = {};
+    let node;
+    nodeIds.forEach(nodeId => {
+      // TODO: Check library view permission for each node before starting
+      node = insertPropertyFromNode(nodeId, ancestors, order);
+    });
+
+    // get one of the root inserted docs
+    let rootId = node._id;
+
+    // Tree structure changed by inserts, reorder the tree
+    reorderDocs({
+      collection: CreatureProperties,
+      ancestorId: rootCreature._id,
+    });
+    // Return the docId of the last property, the inserted root property
+    return rootId;
+  },
+});
+
+function insertPropertyFromNode(nodeId, ancestors, order) {
+  // Fetch the library node and its decendents, provided they have not been
+  // removed
+  // TODO: Check permission to read the library this node is in
+  let node = LibraryNodes.findOne({
+    _id: nodeId,
+    removed: { $ne: true },
+  });
+  if (!node) {
+    if (Meteor.isClient) return;
+    else {
+      throw new Meteor.Error(
+        'Insert property from library failed',
+        `No library document with id '${nodeId}' was found`
+      );
+    }
+  }
+  let oldParent = node.parent;
+  let nodes = LibraryNodes.find({
+    'ancestors.id': nodeId,
+    removed: { $ne: true },
+  }).fetch();
+
+  // Convert all references into actual nodes
+  nodes = reifyNodeReferences(nodes);
+
+  // The root node is first in the array of nodes
+  // It must get the first generated ID to prevent flickering
+  nodes = [node, ...nodes];
+
+  // set libraryNodeIds
+  storeLibraryNodeReferences(nodes);
+
+  // re-map all the ancestors
+  setLineageOfDocs({
+    docArray: nodes,
+    newAncestry: ancestors,
+    oldParent,
+  });
+
+  // Give the docs new IDs without breaking internal references
+  renewDocIds({
+    docArray: nodes,
+    collectionMap: { 'libraryNodes': 'creatureProperties' }
+  });
+
+  // Order the root node
+  if (order === undefined) {
+    setDocToLastOrder({
+      collection: CreatureProperties,
+      doc: node,
+    });
+  } else {
+    node.order = order;
+  }
+
+  // Mark all nodes as dirty
+  dirtyNodes(nodes);
+
+  // Insert the creature properties
+  CreatureProperties.batchInsert(nodes);
+  return node;
+}
+
+function storeLibraryNodeReferences(nodes) {
+  nodes.forEach(node => {
+    if (node.libraryNodeId) return;
+    node.libraryNodeId = node._id;
+  });
+}
+
+function dirtyNodes(nodes) {
+  nodes.forEach(node => {
+    node.dirty = true;
+  });
+}
+
+// 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 => {
+    // 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,
+    });
+
+    // Filter all the looped references
+    addedNodes = addedNodes.filter(addedNode => {
+      // Add all non-reference nodes
+      if (addedNode.type !== 'reference') {
+        return true;
+      }
+      // If this exact reference has already been resolved before, filter it out
+      if (visitedRefs.has(addedNode._id)) {
+        return false;
+      } else {
+        // Otherwise mark it as visited, and keep it
+        visitedRefs.add(addedNode._id);
+        return true;
+      }
+    });
+
+    // Before renewing Ids make sure the library node reference is stored
+    storeLibraryNodeReferences(addedNodes);
+
+    // Give the new referenced sub-tree new ids
+    // The referenced node must get the id of the ref node so that the
+    // descendants of the ref node keep their ancestry intact
+    renewDocIds({
+      docArray: addedNodes,
+      idMap: { [referencedNode._id]: node._id },
+    });
+
+    // 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/pullFromProperty.js

@@ -0,0 +1,32 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+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';
+
+const pullFromProperty = new ValidatedMethod({
+  name: 'creatureProperties.pull',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, itemId }) {
+    // Permissions
+    let property = CreatureProperties.findOne(_id);
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Do work
+    CreatureProperties.update(_id, {
+      $pull: { [path.join('.')]: { _id: itemId } },
+      $set: { dirty: true }
+    }, {
+      selector: { type: property.type },
+      getAutoValues: false,
+    });
+  }
+});
+
+export default pullFromProperty;

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

@@ -0,0 +1,49 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+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 { get } from 'lodash';
+
+const pushToProperty = new ValidatedMethod({
+  name: 'creatureProperties.push',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, value }) {
+    // Permissions
+    let property = CreatureProperties.findOne(_id);
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    let joinedPath = path.join('.');
+
+    // Respect maxCount
+    let schema = CreatureProperties.simpleSchema(property);
+    let maxCount = schema.get(joinedPath, 'maxCount');
+
+    if (Number.isFinite(maxCount)) {
+      let array = get(property, path);
+      let currentCount = array ? array.length : 0;
+      if (currentCount >= maxCount) {
+        throw new Meteor.Error(
+          'Array is full',
+          `Cannot have more than ${maxCount} values`
+        );
+      }
+    }
+
+    // Do work
+    CreatureProperties.update(_id, {
+      $push: { [joinedPath]: value },
+      $set: { dirty: true },
+    }, {
+      selector: { type: property.type },
+    });
+  }
+});
+
+export default pushToProperty;

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

@@ -0,0 +1,36 @@
+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 { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import { restore } from '/imports/api/parenting/softRemove.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+
+const restoreProperty = new ValidatedMethod({
+  name: 'creatureProperties.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    // Permissions
+    let property = CreatureProperties.findOne(_id);
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Do work
+    restore({
+      _id,
+      collection: CreatureProperties,
+      extraUpdates: {
+        $set: { dirty: true }
+      },
+    });
+  }
+});
+
+export default restoreProperty;

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

@@ -0,0 +1,46 @@
+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 getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+
+const selectAmmoItem = new ValidatedMethod({
+  name: 'creatureProperties.selectAmmoItem',
+  validate: new SimpleSchema({
+    actionId: SimpleSchema.RegEx.Id,
+    itemId: SimpleSchema.RegEx.Id,
+    itemConsumedIndex: Number,
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ actionId, itemId, itemConsumedIndex }) {
+    // Permissions
+    let action = CreatureProperties.findOne(actionId);
+    let rootCreature = getRootCreatureAncestor(action);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Check that this index has a document to edit
+    let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
+    if (!itemConsumed) {
+      throw new Meteor.Error('Resouce not found',
+        'Could not set ammo, because the ammo document was not found');
+    }
+    let itemToLink = CreatureProperties.findOne(itemId);
+    if (!itemToLink) {
+      throw new Meteor.Error('Item not found',
+        'Could not set ammo: the item was not found');
+    }
+    let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
+    CreatureProperties.update(actionId, {
+      $set: { [path]: itemId, dirty: true }
+    }, {
+      selector: action,
+    });
+  },
+});
+
+export default selectAmmoItem;

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

@@ -0,0 +1,30 @@
+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 { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import { softRemove } from '/imports/api/parenting/softRemove.js';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+
+const softRemoveProperty = new ValidatedMethod({
+  name: 'creatureProperties.softRemove',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    // Permissions
+    let property = CreatureProperties.findOne(_id);
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Do work
+    softRemove({ _id, collection: CreatureProperties });
+  }
+});
+
+export default softRemoveProperty;

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

@@ -0,0 +1,49 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+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';
+
+const updateCreatureProperty = new ValidatedMethod({
+  name: 'creatureProperties.update',
+  validate({ _id, path }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+    // We cannot change these fields with a simple update
+    switch (path[0]) {
+      case 'type':
+      case 'order':
+      case 'parent':
+      case 'ancestors':
+      case 'damage':
+        throw new Meteor.Error('Permission denied',
+          'This property can\'t be updated directly');
+    }
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, value }) {
+    // Permission
+    let property = CreatureProperties.findOne(_id, {
+      fields: { type: 1, ancestors: 1 }
+    });
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    let pathString = path.join('.');
+    let modifier;
+    // unset empty values
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 }, $set: { dirty: true } };
+    } else {
+      modifier = { $set: { [pathString]: value, dirty: true } };
+    }
+    CreatureProperties.update(_id, modifier, {
+      selector: { type: property.type },
+    });
+  },
+});
+
+export default updateCreatureProperty;

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

@@ -0,0 +1,12 @@
+import computeCreature from '/imports/api/engine/computeCreature.js';
+
+/**
+ * Recomputes all ancestor creatures of this property
+ */
+export default function recomputeCreaturesByProperty(property){
+  for (let ref of property.ancestors){
+    if (ref.collection === 'creatures') {
+      computeCreature.call(ref.id);
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+//set up the collection for creature variables
+let CreatureVariables = new Mongo.Collection('creatureVariables');
+
+// Unique index on _creatureId
+if (Meteor.isServer) {
+  CreatureVariables._ensureIndex({ _creatureId: 1 }, { unique: true })
+}
+
+/** No schema because the structure isn't known until compute time
+ * Expect documents to looke like:
+ * {
+ *   _id: "nE8Ngd6K4L4jSxLY2",
+ *   _creatureId: "nE8Ngd6K4L4jSxLY2", // indexed reference to the creature
+ *   explicitlyDefinedVariableName: {...some creatureProperty}
+ *   implicitVariableName: {value: 10},
+ *   undefinedVariableName: {},
+ * }
+ * Where top level fields that don't start with `_` are variables on the sheet
+**/
+
+export default CreatureVariables;

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

@@ -0,0 +1,203 @@
+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 STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+
+//set up the collection for creatures
+let Creatures = new Mongo.Collection('creatures');
+
+let CreatureSettingsSchema = new SimpleSchema({
+  //slowed down by carrying too much?
+  useVariantEncumbrance: {
+    type: Boolean,
+    optional: true,
+  },
+  //hide spellcasting tab
+  hideSpellcasting: {
+    type: Boolean,
+    optional: true,
+  },
+  //hide rest buttons
+  hideRestButtons: {
+    type: Boolean,
+    optional: true,
+  },
+  // Swap around the modifier and stat
+  swapStatAndModifier: {
+    type: Boolean,
+    optional: true,
+  },
+  // Hide all the unused stats
+  hideUnusedStats: {
+    type: Boolean,
+    optional: true,
+  },
+  // Show the tree tab
+  showTreeTab: {
+    type: Boolean,
+    optional: true,
+  },
+  // Hide the spells tab
+  hideSpellsTab: {
+    type: Boolean,
+    optional: true,
+  },
+  // Hide calculation errors
+  hideCalculationErrors: {
+    type: Boolean,
+    optional: true,
+  },
+  // How much each hitDice resets on a long rest
+  hitDiceResetMultiplier: {
+    type: Number,
+    optional: true,
+    min: 0,
+    max: 1,
+  },
+  discordWebhook: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.url,
+  },
+});
+
+let CreatureSchema = new SimpleSchema({
+  // Strings
+  name: {
+    type: String,
+    defaultValue: '',
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  alignment: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  gender: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  picture: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.url,
+  },
+  avatarPicture: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.url,
+  },
+
+  // Libraries
+  allowedLibraries: {
+    type: Array,
+    optional: true,
+    maxCount: 100,
+  },
+  'allowedLibraries.$': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+  },
+  allowedLibraryCollections: {
+    type: Array,
+    optional: true,
+    maxCount: 100,
+  },
+  'allowedLibraryCollections.$': {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+  },
+
+  // Mechanics
+  deathSave: {
+    type: deathSaveSchema,
+    defaultValue: {},
+  },
+  // Stats that are computed and denormalised outside of recomputation
+  denormalizedStats: {
+    type: Object,
+    defaultValue: {},
+  },
+  // Sum of all XP gained by this character
+  'denormalizedStats.xp': {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
+  // Sum of all levels granted by milestone XP
+  'denormalizedStats.milestoneLevels': {
+    type: SimpleSchema.Integer,
+    defaultValue: 0,
+  },
+  // Does the character need a recompute?
+  dirty: {
+    type: Boolean,
+    optional: true,
+  },
+  // Version of computation engine that was last used to compute this creature
+  computeVersion: {
+    type: String,
+    optional: true,
+  },
+  type: {
+    type: String,
+    defaultValue: 'pc',
+    allowedValues: ['pc', 'npc', 'monster'],
+  },
+  damageMultipliers: {
+    type: Object,
+    blackbox: true,
+    defaultValue: {}
+  },
+  variables: {
+    type: Object,
+    blackbox: true,
+    defaultValue: {}
+  },
+  computeErrors: {
+    type: Array,
+    optional: true,
+  },
+  'computeErrors.$': {
+    type: Object,
+  },
+  'computeErrors.$.type': {
+    type: String,
+  },
+  'computeErrors.$.details': {
+    type: Object,
+    blackbox: true,
+    optional: true,
+  },
+
+  // Tabletop
+  tabletop: {
+    type: String,
+    regEx: SimpleSchema.RegEx.id,
+    optional: true,
+  },
+  initiativeRoll: {
+    type: SimpleSchema.Integer,
+    optional: true,
+  },
+
+  // Settings
+  settings: {
+    type: CreatureSettingsSchema,
+    defaultValue: {},
+  },
+});
+
+CreatureSchema.extend(ColorSchema);
+CreatureSchema.extend(SharingSchema);
+
+Creatures.attachSchema(CreatureSchema);
+
+
+
+export default Creatures;
+export { CreatureSchema };
+
+import '/imports/api/engine/actions/doAction.js';

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,
@@ -24,6 +24,6 @@ export function assertEditPermission(creature, userId) {
 }
 
 export function assertViewPermission(creature, userId) {
-  creature = getCreature(creature, {owner: 1, writers: 1, public: 1});
+  creature = getCreature(creature, {owner: 1, readers:1, writers: 1, public: 1});
   viewPermission(creature, userId);
 }

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: {text: 'Choose a starting point for your character, this will define the basic setup of your character sheet. Without a base ruleset, your sheet will be empty.'},
+      slotTags: ['base'],
+      tags: [],
+      quantityExpected: {calculation: '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/getCreatureUrlName.js

@@ -0,0 +1,5 @@
+import getSlug from 'speakingurl';
+
+export default function getCreatureUrlName({name}){
+  return getSlug(name, {maintainCase: true}) || '-';
+}

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

@@ -0,0 +1,22 @@
+import { getUserTier } from '/imports/api/users/patreon/tiers.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+
+export default function assertHasCharactersSlots(userId) {
+  if (characterSlotsRemaining(userId) <= 0) {
+    throw new Meteor.Error('characterSlotLimit',
+      'No character slots left')
+  }
+}
+
+export function characterSlotsRemaining(userId) {
+  let tier = getUserTier(userId);
+  const currentCharacterCount = Creatures.find({
+    owner: userId,
+  }, {
+    fields: { _id: 1 },
+  }).count();
+  if (tier.characterSlots === -1) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return tier.characterSlots - currentCharacterCount;
+}

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

@@ -0,0 +1,90 @@
+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';
+import SimpleSchema from 'simpl-schema';
+import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
+
+const changeAllowedLibraries = new ValidatedMethod({
+  name: 'creatures.changeAllowedLibraries',
+  mixins: [RateLimiterMixin, simpleSchemaMixin],
+  schema: new SimpleSchema({
+    _id: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    allowedLibraries: {
+      type: Array,
+      optional: true,
+      maxCount: 100,
+    },
+    'allowedLibraries.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    allowedLibraryCollections: {
+      type: Array,
+      optional: true,
+      maxCount: 100,
+    },
+    'allowedLibraryCollections.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }),
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  run({ _id, allowedLibraries, allowedLibraryCollections }) {
+    let creature = Creatures.findOne(_id);
+    assertEditPermission(creature, this.userId);
+    let $set;
+    if (allowedLibraries) {
+      $set = { allowedLibraries }
+    }
+    if (allowedLibraryCollections) {
+      if (!$set) $set = {};
+      $set.allowedLibraryCollections = allowedLibraryCollections;
+    }
+    if (!$set) return;
+    Creatures.update(_id, { $set });
+  },
+});
+
+const toggleAllUserLibraries = new ValidatedMethod({
+  name: 'creatures.removeLibraryLimits',
+  mixins: [RateLimiterMixin, simpleSchemaMixin],
+  schema: new SimpleSchema({
+    _id: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    value: {
+      type: Boolean,
+    },
+  }),
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  run({ _id, value }) {
+    if (value) {
+      Creatures.update(_id, {
+        $unset: {
+          allowedLibraryCollections: 1,
+          allowedLibraries: 1,
+        },
+      });
+    } else {
+      Creatures.update(_id, {
+        $set: {
+          allowedLibraryCollections: [],
+          allowedLibraries: [],
+        },
+      });
+    }
+  },
+});
+
+export { changeAllowedLibraries, toggleAllUserLibraries };

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/updateCreature.js';
+import '/imports/api/creature/creatures/methods/changeAllowedLibraries.js';

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

@@ -0,0 +1,104 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import simpleSchemaMixin from '/imports/api/creature/mixins/simpleSchemaMixin.js';
+import Creatures, { CreatureSchema } from '/imports/api/creature/creatures/Creatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
+import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
+import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots.js';
+import getSlotFillFilter from '/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js';
+import getCreatureLibraryIds from '/imports/api/library/getCreatureLibraryIds.js';
+import LibraryNodes from '/imports/api/library/LibraryNodes.js';
+import { insertExperienceForCreature } from '/imports/api/creature/experience/Experiences.js';
+import SimpleSchema from 'simpl-schema';
+
+const insertCreature = new ValidatedMethod({
+  name: 'creatures.insertCreature',
+  mixins: [RateLimiterMixin, simpleSchemaMixin],
+  schema: CreatureSchema.pick(
+    'name',
+    'gender',
+    'alignment',
+    'allowedLibraries',
+    'allowedLibraryCollections',
+  ).extend({
+    'startingLevel': {
+      type: SimpleSchema.Integer,
+      min: 0,
+    },
+  }),
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+
+  run({ name, gender, alignment, startingLevel,
+    allowedLibraries, allowedLibraryCollections }) {
+    const userId = this.userId
+    if (!userId) {
+      throw new Meteor.Error('Creatures.methods.insert.denied',
+        'You need to be logged in to insert a creature');
+    }
+
+    assertHasCharactersSlots(userId);
+
+    // Create the creature document
+    let creatureId = Creatures.insert({
+      owner: userId,
+      name,
+      gender,
+      alignment,
+      allowedLibraries,
+      allowedLibraryCollections,
+    });
+
+    // Insert experience to get character to starting level
+    if (startingLevel) {
+      insertExperienceForCreature({
+        experience: {
+          name: 'Starting level',
+          levels: startingLevel,
+          creatureId
+        },
+        creatureId,
+        userId,
+      });
+    }
+
+    // Insert the default properties
+    // Not batchInsert because we want the properties cleaned by the schema
+    let baseId, rulesetSlot;
+    defaultCharacterProperties(creatureId).forEach(prop => {
+      let id = CreatureProperties.insert(prop);
+      if (prop.name === 'Ruleset') {
+        baseId = id;
+        rulesetSlot = prop;
+      }
+    });
+
+    // If the user only has a single ruleset subscribed, use it by default
+    if (Meteor.isServer) {
+      insertDefaultRuleset(creatureId, baseId, userId, rulesetSlot);
+    }
+
+    return creatureId;
+  },
+});
+
+// If the user only has a single ruleset subscribed, insert it by default
+function insertDefaultRuleset(creatureId, baseId, userId, slot) {
+  const libraryIds = getCreatureLibraryIds(creatureId, userId);
+  const filter = getSlotFillFilter({ slot, libraryIds });
+  const fillCursor = LibraryNodes.find(filter, { fields: { _id: 1 } });
+  const numRulesets = fillCursor.count();
+  if (numRulesets === 1) {
+    const ruleset = fillCursor.fetch()[0]
+    insertPropertyFromLibraryNode.call({
+      nodeIds: [ruleset._id],
+      parentRef: { id: baseId, collection: 'creatureProperties' },
+      order: 0.5,
+    });
+  }
+}
+
+export default insertCreature;

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

@@ -1,13 +1,17 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/Creatures.js';
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js'
-import { assertOwnership } from '/imports/api/creature/creaturePermissions.js';
+import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.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';
 
 function removeRelatedDocuments(creatureId){
+  CreatureVariables.remove({_creatureId: creatureId});
   CreatureProperties.remove({'ancestors.id': creatureId});
+  CreatureLogs.remove({creatureId});
   Experiences.remove({creatureId});
 }
 
@@ -26,10 +30,14 @@ const removeCreature = new ValidatedMethod({
   },
   run({charId}) {
     assertOwnership(charId, this.userId)
-    Creatures.remove(charId);
-		this.unblock();
-		removeRelatedDocuments(charId);
+    this.unblock();
+    removeCreatureWork(charId)
   },
 });
 
+export function removeCreatureWork(creatureId){
+  Creatures.remove(creatureId);
+  removeRelatedDocuments(creatureId);
+}
+
 export default removeCreature;

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

@@ -0,0 +1,170 @@
+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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
+import { union } from 'lodash';
+import ActionContext from '/imports/api/engine/actions/ActionContext.js';
+import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
+
+const restCreature = new ValidatedMethod({
+  name: 'creature.methods.rest',
+  validate: new SimpleSchema({
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    restType: {
+      type: String,
+      allowedValues: ['shortRest', 'longRest'],
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ creatureId, restType }) {
+    // Get action context
+    const actionContext = new ActionContext(creatureId, [creatureId], this);
+    // Check permissions
+    assertEditPermission(actionContext.creature, this.userId);
+
+    // Join, sort, and apply before triggers
+    const beforeTriggers = union(
+      actionContext.triggers.anyRest?.before, actionContext.triggers[restType]?.before
+    ).sort((a, b) => a.order - b.order);
+    applyTriggers(beforeTriggers, null, actionContext);
+
+    // Rest
+    actionContext.addLog({
+      name: restType === 'shortRest' ? 'Short rest' : 'Long rest',
+    });
+    doRestWork(restType, actionContext);
+
+    // Join, sort, and apply after triggers
+    const afterTriggers = union(
+      actionContext.triggers.anyRest?.after, actionContext.triggers[restType]?.after
+    ).sort((a, b) => a.order - b.order);
+    applyTriggers(afterTriggers, null, actionContext);
+
+    // Insert log
+    actionContext.writeLog();
+  },
+});
+
+function doRestWork(restType, actionContext) {
+  const creatureId = actionContext.creature._id;
+  // Long rests reset short rest properties as well
+  let resetFilter;
+  if (restType === 'shortRest') {
+    resetFilter = 'shortRest'
+  } else {
+    resetFilter = { $in: ['shortRest', 'longRest'] }
+  }
+  resetProperties(creatureId, resetFilter, actionContext);
+
+  // Reset half hit dice on a long rest, starting with the highest dice
+  if (restType === 'longRest') {
+    resetHitDice(creatureId, actionContext);
+  }
+}
+
+export function resetProperties(creatureId, resetFilter, actionContext) {
+  // Only apply to active properties
+  const filter = {
+    'ancestors.id': creatureId,
+    reset: resetFilter,
+    removed: { $ne: true },
+    inactive: { $ne: true },
+  };
+  // update all attribute's damage
+  const attributeFilter = {
+    ...filter,
+    type: 'attribute',
+    damage: { $nin: [0, undefined] },
+  }
+  CreatureProperties.find(attributeFilter).forEach(prop => {
+    damagePropertyWork({
+      prop,
+      operation: 'increment',
+      value: -prop.damage ?? 0,
+      actionContext,
+      logFunction(increment) {
+        actionContext.addLog({
+          name: prop.name,
+          value: increment < 0 ? `Restored ${-increment}` : `Removed ${-increment}`
+        });
+      }
+    });
+  });
+  // Update all action-like properties' usesUsed
+  const actionFilter = {
+    ...filter,
+    type: {
+      $in: ['action', 'spell']
+    },
+    usesUsed: { $nin: [0, undefined] },
+  };
+  CreatureProperties.find(actionFilter, {
+    fields: { name: 1, usesUsed: 1 }
+  }).forEach(prop => {
+    actionContext.addLog({
+      name: prop.name,
+      value: prop.usesUsed >= 0 ? `Restored ${prop.usesUsed} uses` : `Removed ${-prop.usesUsed} uses`
+    });
+  });
+  CreatureProperties.update(actionFilter, {
+    $set: {
+      usesUsed: 0,
+      dirty: true,
+    }
+  }, {
+    selector: { type: 'action' },
+    multi: true,
+  });
+}
+
+function resetHitDice(creatureId, actionContext) {
+  let hitDice = CreatureProperties.find({
+    'ancestors.id': creatureId,
+    type: 'attribute',
+    attributeType: 'hitDice',
+    removed: { $ne: true },
+    inactive: { $ne: true },
+  }).fetch();
+  // Use a collator to do sorting in natural order
+  let collator = new Intl.Collator('en', {
+    numeric: true, sensitivity: 'base'
+  });
+  // Get the hit dice in decending order of hitDiceSize
+  let compare = (a, b) => collator.compare(b.hitDiceSize, a.hitDiceSize)
+  hitDice.sort(compare);
+  // Get the total number of hit dice that can be recovered this rest
+  let totalHd = hitDice.reduce((sum, hd) => sum + (hd.total || 0), 0);
+  let resetMultiplier = actionContext.creature.settings.hitDiceResetMultiplier || 0.5;
+  let recoverableHd = Math.max(Math.floor(totalHd * resetMultiplier), 1);
+  // recover each hit dice in turn until the recoverable amount is used up
+  let amountToRecover;
+  hitDice.forEach(hd => {
+    if (!recoverableHd) return;
+    amountToRecover = Math.min(recoverableHd, hd.damage ?? 0);
+    if (!amountToRecover) return;
+    recoverableHd -= amountToRecover;
+    damagePropertyWork({
+      prop: hd,
+      operation: 'increment',
+      value: -amountToRecover,
+      actionContext,
+      logFunction(increment) {
+        actionContext.addLog({
+          name: hd.name,
+          value: increment < 0 ? `Restored ${-increment} hit dice` : `Removed ${increment} hit dice`
+        });
+      }
+    });
+  });
+}
+
+export default restCreature;

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/damageMultiplierDenormalise/recomputeDamageMultipliers.js

@@ -1,74 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/creature/creaturePermissions.js';
-import Creatures from '/imports/api/creature/Creatures.js';
-import getActiveProperties from '/imports/api/creature/getActiveProperties.js';
-
-export const recomputeDamageMultipliers = new ValidatedMethod({
-
-  name: 'creatures.recomputeDamageMultipliers',
-
-  validate: new SimpleSchema({
-    creatureId: { type: String }
-  }).validator(),
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({creatureId}) {
-    // Permission
-    assertEditPermission(creatureId, this.userId);
-    // Work, call this direcly if you are already in a method that has checked
-    // for permission to edit a given character
-    recomputeDamageMultipliersById(creatureId);
-  },
-
-});
-
-export function recomputeDamageMultipliersById(creatureId){
-  if (!creatureId) throw 'Creature ID is required';
-  let props = getActiveProperties({
-    ancestorId: creatureId,
-    filter: {type: 'damageMultiplier'},
-  });
-
-  // Count of how many weakness, resistances and immunities each damage type has
-  let multipliersByName = {};
-  props.forEach(dm => {
-    dm.damageTypes.forEach(damageType => {
-      if (!multipliersByName[damageType]){
-        multipliersByName[damageType] = {
-          weaknesses: 0,
-          resistances: 0,
-          immunities: 0,
-        };
-      }
-      if (dm.value === 0){
-        multipliersByName[damageType].immunities++;
-      } else if (dm.value === 0.5){
-        multipliersByName[damageType].resistances++;
-      } else if (dm.value === 2){
-        multipliersByName[damageType].weaknesses++;
-      }
-    });
-  });
-  // Make an Object with keys of all the damage types that have a resulting
-  // immunity, weakness, or resistance
-  let damageMultipliers = {};
-  for (let damageType in multipliersByName){
-    let multiplier = multipliersByName[damageType];
-    if (multiplier.immunities){
-      damageMultipliers[damageType] = 0;
-    } else if (multiplier.resistances && !multiplier.weaknesses){
-      damageMultipliers[damageType] = 0.5;
-    } else if (multiplier.weaknesses && !multiplier.resistances){
-      damageMultipliers[damageType] = 2;
-    }
-  }
-  // Store the Object on the creature document
-  Creatures.update(creatureId, {$set: {damageMultipliers}});
-}

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

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

app/imports/api/creature/getActiveProperties.js

@@ -1,61 +0,0 @@
-import Creatures from '/imports/api/creature/Creatures.js';
-import CreatureProperties from '/imports/api/creature/CreatureProperties.js';
-
-export default function getActiveProperties({
-  ancestorId,
-  filter = {},
-  options,
-  includeUntoggled = false
-}){
-  filter = getActivePropertyFilter({ancestorId, filter, includeUntoggled});
-  return CreatureProperties.find(filter, options).fetch();
-}
-
-export function getActivePropertyFilter({
-  ancestorId,
-  filter = {},
-  includeUntoggled = false
-}){
-  if (!ancestorId){
-    throw 'Ancestor Id is required to get active properties'
-  }
-  // First get ids of disabled properties, unequiped items, unapplied buffs
-  let disabledAncestorsFilter = {
-    'ancestors.id': ancestorId,
-    $or: [
-      {disabled: true}, // Everything can be disabled
-      {equipped: false}, // Items can be equipped
-      {applied: false}, // Buffs can be applied
-    ],
-  };
-  if (!includeUntoggled){
-    disabledAncestorsFilter.$or.push({toggleResult: false});
-  }
-  let disabledAncestorIds = CreatureProperties.find(disabledAncestorsFilter, {
-    fields: {_id: 1},
-  }).map(prop => prop._id);
-
-  // Then get the ids of creatures that are children of this creature
-  // to isolate their decendent properties
-  Creatures.find({
-    'ancestors.id': ancestorId,
-  }, {
-    fields: {_id: 1},
-  }).forEach(subCreature => {
-    disabledAncestorIds.push(subCreature._id);
-  });
-
-  // Get all the properties that are decendents of the ancestor of interest but
-  // aren't from the excluded decendents
-  filter['ancestors.id'] = {
-    $eq: ancestorId,
-    $nin: disabledAncestorIds,
-  };
-  // Get properties that aren't removed
-  filter.removed = {$ne: true};
-  // Don't include the disabled ancestors themselves either
-  filter._id = {
-    $nin: disabledAncestorIds,
-  }
-  return filter;
-}

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

@@ -1,37 +1,43 @@
 import SimpleSchema from 'simpl-schema';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 
 let ExperienceSchema = new SimpleSchema({
-	title: {
-		type: String,
-		optional: true,
-	},
-	// Potentially long description of the event
-	description: {
-		type: String,
-		optional: true,
-	},
-	// The real-world date that it occured
-	date: {
-		type: Date,
-		autoValue: function() {
-			// If the date isn't set, set it to now
-			if (!this.isSet) {
-				return new Date();
-			}
-		},
-	},
-	// The date in-world of this event
-	worldDate: {
-		type: String,
-		optional: true,
-	},
+  title: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  // Potentially long description of the event
+  description: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.description,
+  },
+  // The real-world date that it occured
+  date: {
+    type: Date,
+    autoValue: function () {
+      // If the date isn't set, set it to now
+      if (!this.isSet) {
+        return new Date();
+      }
+    },
+  },
+  // The date in-world of this event
+  worldDate: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
   // Tags to better find this entry later
   tags: {
     type: Array,
     defaultValue: [],
+    maxCount: STORAGE_LIMITS.tagCount,
   },
   'tags.$': {
     type: String,
+    max: STORAGE_LIMITS.tagLength,
   },
   // ID of the journal this entry belongs to
   journalId: {

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

@@ -0,0 +1,218 @@
+import SimpleSchema from 'simpl-schema';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureVariables from '/imports/api/creature/creatures/CreatureVariables.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/creatures/creaturePermissions.js';
+import { parse, prettifyParseError } from '/imports/parser/parser.js';
+import resolve, { toString } from '/imports/parser/resolve.js';
+const PER_CREATURE_LOG_LIMIT = 100;
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+
+if (Meteor.isServer) {
+  var sendWebhookAsCreature = require('/imports/server/discord/sendWebhook.js').sendWebhookAsCreature;
+}
+
+let CreatureLogs = new Mongo.Collection('creatureLogs');
+
+let CreatureLogSchema = new SimpleSchema({
+  content: {
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.logContentCount,
+  },
+  'content.$': {
+    type: LogContentSchema,
+  },
+  // The real-world date that it occured, usually sorted by date
+  date: {
+    type: Date,
+    autoValue: function () {
+      // If the date isn't set, set it to now
+      if (!this.isSet) {
+        return new Date();
+      }
+    },
+    index: 1,
+  },
+  creatureId: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    index: 1,
+  },
+  creatureName: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+});
+
+CreatureLogs.attachSchema(CreatureLogSchema);
+
+function removeOldLogs(creatureId) {
+  // Find the first log that is over the limit
+  let firstExpiredLog = CreatureLogs.find({
+    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,
+    date: { $lte: firstExpiredLog.date },
+  });
+}
+
+function logToMessageData(log) {
+  let embed = {
+    fields: [],
+  };
+  log.content.forEach(field => {
+    if (!field.name) field.name = '\u200b';
+    if (!field.value) field.value = '\u200b';
+    embed.fields.push(field);
+  });
+  return { embeds: [embed] };
+}
+
+function logWebhook({ log, creature }) {
+  if (Meteor.isServer) {
+    sendWebhookAsCreature({
+      creature,
+      data: logToMessageData(log),
+    });
+  }
+}
+
+const insertCreatureLog = new ValidatedMethod({
+  name: 'creatureLogs.methods.insert',
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  validate: new SimpleSchema({
+    log: CreatureLogSchema.omit('date'),
+  }).validator(),
+  run({ log }) {
+    const creatureId = log.creatureId;
+    const creature = Creatures.findOne(creatureId, {
+      fields: {
+        readers: 1,
+        writers: 1,
+        owner: 1,
+        'settings.discordWebhook': 1,
+        name: 1,
+        avatarPicture: 1,
+      }
+    });
+    assertEditPermission(creature, this.userId);
+    // Build the new log
+    let id = insertCreatureLogWork({ log, creature, method: this })
+    return id;
+  },
+});
+
+export function insertCreatureLogWork({ log, creature, method }) {
+  // Build the new log
+  if (typeof log === 'string') {
+    log = { content: [{ value: log }] };
+  }
+  if (!log.content?.length) return;
+  log.date = new Date();
+  // Insert it
+  let id = CreatureLogs.insert(log);
+  if (Meteor.isServer) {
+    method?.unblock();
+    removeOldLogs(creature._id);
+    logWebhook({ log, creature });
+  }
+  return id;
+}
+
+
+function equalIgnoringWhitespace(a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return a === b;
+  return a.replace(/\s/g, '') === b.replace(/\s/g, '');
+}
+
+const logRoll = new ValidatedMethod({
+  name: 'creatureLogs.methods.logForCreature',
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  validate: new SimpleSchema({
+    roll: {
+      type: String,
+    },
+    creatureId: {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+  }).validator(),
+  run({ roll, creatureId }) {
+    const creature = Creatures.findOne(creatureId, {
+      fields: {
+        readers: 1,
+        writers: 1,
+        owner: 1,
+        'settings.discordWebhook': 1,
+        name: 1,
+        avatarPicture: 1,
+      }
+    });
+    assertEditPermission(creature, this.userId);
+    const variables = CreatureVariables.findOne({ _creatureId: creatureId });
+    let logContent = []
+    let parsedResult = undefined;
+    try {
+      parsedResult = parse(roll);
+    } catch (e) {
+      let error = prettifyParseError(e);
+      logContent.push({ name: 'Parse Error', value: error });
+    }
+    if (parsedResult) try {
+      let {
+        result: compiled,
+        context
+      } = resolve('compile', parsedResult, variables);
+      const compiledString = toString(compiled);
+      if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
+        value: roll
+      });
+      logContent.push({
+        value: compiledString
+      });
+      let { result: rolled } = resolve('roll', compiled, variables, context);
+      let rolledString = toString(rolled);
+      if (rolledString !== compiledString) logContent.push({
+        value: rolledString
+      });
+      let { result } = resolve('reduce', rolled, variables, context);
+      let resultString = toString(result);
+      if (resultString !== rolledString) logContent.push({
+        value: resultString
+      });
+    } catch (e) {
+      console.error(e);
+      logContent = [{ name: 'Calculation error' }];
+    }
+    const log = {
+      content: logContent,
+      creatureId,
+      date: new Date(),
+    };
+
+    let id = insertCreatureLogWork({ log, creature, method: this });
+
+    return id;
+  },
+});
+
+export default CreatureLogs;
+export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT };

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

@@ -0,0 +1,51 @@
+import SimpleSchema from 'simpl-schema';
+import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
+import RollDetailsSchema from '/imports/api/properties/subSchemas/RollDetailsSchema.js';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+
+let LogContentSchema = new SimpleSchema({
+  // The name of the field, included in discord webhook message
+  name: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  // The details of the field, included in discord webhook message
+  // Markdown support
+  value: {
+    type: String,
+    optional: true,
+    max: STORAGE_LIMITS.summary,
+  },
+  // Inline with other content fields
+  inline: {
+    type: Boolean,
+    optional: true,
+  },
+  context: {
+    type: Object,
+    optional: true,
+  },
+  'context.errors':{
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.errorCount,
+  },
+  'context.errors.$': {
+    type: ErrorSchema,
+  },
+  'context.rolls': {
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.rollCount,
+  },
+  'context.rolls.$': {
+    type: RollDetailsSchema,
+  },
+  'context.doubleRolls': {
+    type: Boolean,
+    optional: true,
+  },
+});
+
+export default LogContentSchema;

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/mixins/recomputeCreatureMixin.js

@@ -1,4 +1,4 @@
-import { recomputeCreatureById } from '/imports/api/creature/computation/recomputeCreature.js';
+import computeCreature from '/imports/api/engine/computeCreature.js';
 
 export default function recomputeCreatureMixin(methodOptions){
   let runFunc = methodOptions.run;
@@ -10,7 +10,7 @@ export default function recomputeCreatureMixin(methodOptions){
     ) {
       return result;
     }
-    recomputeCreatureById(charId);
+    computeCreature(charId);
     return result;
   };
   return methodOptions;

app/imports/api/creature/restCreature.js

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

app/imports/api/docs/Docs.js

@@ -0,0 +1,324 @@
+import { Meteor } from 'meteor/meteor';
+import { Mongo } from 'meteor/mongo';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import SimpleSchema from 'simpl-schema';
+import { 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 STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+import { restore } from '/imports/api/parenting/softRemove.js';
+import { reorderDocs } from '/imports/api/parenting/order.js';
+import { getAncestry } from '/imports/api/parenting/parenting.js';
+
+const Docs = new Mongo.Collection('docs');
+
+const RefSchema = new SimpleSchema({
+  id: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+    index: 1
+  },
+  collection: {
+    type: String,
+    max: STORAGE_LIMITS.collectionName,
+  },
+  urlName: {
+    type: String,
+    regEx: /[a-z]+(?:[a-z]|-)+/,
+    min: 2,
+    max: STORAGE_LIMITS.variableName,
+    optional: true,
+  },
+  name: {
+    type: String,
+    max: STORAGE_LIMITS.description,
+    optional: true,
+  },
+});
+
+let ChildSchema = new SimpleSchema({
+  order: {
+    type: Number,
+  },
+  parent: {
+    type: RefSchema,
+    optional: true,
+  },
+  ancestors: {
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.ancestorCount,
+  },
+  'ancestors.$': {
+    type: RefSchema,
+  },
+});
+
+let DocSchema = new SimpleSchema({
+  _id: {
+    type: String,
+    regEx: SimpleSchema.RegEx.Id,
+  },
+  name: {
+    type: String,
+    max: STORAGE_LIMITS.description,
+  },
+  urlName: {
+    type: String,
+    regEx: /[a-z]+(?:[a-z]|-)+/,
+    min: 2,
+    max: STORAGE_LIMITS.variableName,
+  },
+  href: {
+    type: String,
+  },
+  description: {
+    type: String,
+    optional: true,
+  },
+  published: {
+    type: Boolean,
+    optional: true,
+  },
+  icon: {
+    type: storedIconsSchema,
+    optional: true,
+    max: STORAGE_LIMITS.icon,
+  },
+});
+
+let schema = new SimpleSchema({});
+schema.extend(DocSchema);
+schema.extend(ChildSchema);
+schema.extend(SoftRemovableSchema);
+Docs.attachSchema(schema);
+
+function assertDocsEditPermission(userId) {
+  if (!userId || typeof userId !== 'string') throw new Meteor.Error('No user id provided');
+  const user = Meteor.users.findOne(userId);
+  if (!user) throw new Meteor.Error('User does not exist');
+  if (!user?.roles?.includes?.('docsWriter')) throw ('Permission denied')
+}
+
+function getDocLink(doc, urlName) {
+  if (!urlName) urlName = doc.urlName;
+  const address = ['/docs'];
+  doc.ancestors?.forEach(a => {
+    address.push(a.urlName);
+  });
+  address.push(urlName);
+  return address.join('/');
+}
+
+function rebuildDocAncestors(docId) {
+  const newDoc = Docs.findOne(docId);
+  Docs.find({ 'ancestors.id': docId }).forEach(doc => {
+    doc.ancestors.forEach((a, i) => {
+      if (a.id === docId) {
+        Docs.update(doc._id, {
+          $set: {
+            [`ancestors.${i}`]: {
+              id: newDoc._id,
+              collection: 'docs',
+              urlName: newDoc.urlName,
+              name: newDoc.name,
+            }
+          }
+        });
+      }
+    });
+    doc = Docs.findOne(doc._id);
+    const newLink = getDocLink(doc);
+    if (doc.href !== newLink) {
+      Docs.update(doc._id, { $set: { href: newLink } })
+    }
+  });
+}
+
+// Add a means of seeding new servers with documentation
+if (Meteor.isClient) {
+  Docs.getJsonDocs = function () {
+    return JSON.stringify(Docs.find({}).fetch(), null, 2);
+  }
+} else if (Meteor.isServer) {
+  Meteor.startup(() => {
+    if (!Docs.findOne()) {
+      Assets.getText('docs/defaultDocs.json', (error, string) => {
+        const docs = JSON.parse(string)
+        docs.forEach(doc => Docs.insert(doc));
+      });
+    }
+  });
+}
+
+const insertDoc = new ValidatedMethod({
+  name: 'docs.insert',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ doc, parentRef }) {
+    delete doc._id;
+    assertDocsEditPermission(this.userId);
+    // get the new ancestry for the properties
+    if (parentRef) {
+      var { ancestors } = getAncestry({
+        parentRef,
+        inheritedFields: { name: 1, urlName: 1 },
+      });
+    }
+    doc.parent = parentRef;
+    doc.ancestors = ancestors;
+
+    const lastOrder = Docs.find({}, { sort: { order: -1 } }).fetch()[0]?.order || 0;
+    doc.order = lastOrder + 1;
+    doc.urlName = 'new-doc-' + (lastOrder + 1);
+
+    doc.href = getDocLink(doc);
+    if (Docs.findOne({ href: doc.href })) {
+      throw new Meteor.Error('Link collision', 'A document with the same URL already exists');
+    }
+
+    const docId = Docs.insert(doc);
+    reorderDocs({
+      collection: Docs,
+      ancestorId: 'root',
+    });
+    return docId;
+  },
+});
+
+const updateDoc = new ValidatedMethod({
+  name: 'docs.update',
+  validate({ _id, path }) {
+    if (!_id) return false;
+    // We cannot change these fields with a simple update
+    switch (path[0]) {
+      case '_is':
+        return false;
+    }
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, value }) {
+    assertDocsEditPermission(this.userId);
+    let pathString = path.join('.');
+    let modifier;
+    // unset empty values
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 } };
+    } else {
+      modifier = { $set: { [pathString]: value } };
+    }
+    if (pathString === 'urlName') {
+      const doc = Docs.findOne(_id);
+      const newLink = getDocLink(doc, value);
+      if (Docs.findOne({ href: newLink })) {
+        throw new Meteor.Error('Link collision', 'A document with the same URL already exists');
+      }
+      modifier.$set = modifier.$set || {};
+      modifier.$set.href = newLink;
+      rebuildDocAncestors(_id);
+    }
+    const updates = Docs.update(_id, modifier);
+    if (pathString === 'name' || pathString === 'urlName') {
+      rebuildDocAncestors(_id);
+    }
+    reorderDocs({
+      collection: Docs,
+      ancestorId: 'root',
+    });
+    return updates;
+  },
+});
+
+const pushToDoc = new ValidatedMethod({
+  name: 'docs.push',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, value }) {
+    assertDocsEditPermission(this.userId);
+    return Docs.update(_id, {
+      $push: { [path.join('.')]: value },
+    });
+  }
+});
+
+const pullFromDoc = new ValidatedMethod({
+  name: 'docs.pull',
+  validate: null,
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id, path, itemId }) {
+    assertDocsEditPermission(this.userId);
+    return Docs.update(_id, {
+      $pull: { [path.join('.')]: { _id: itemId } },
+    });
+  }
+});
+
+const softRemoveDoc = new ValidatedMethod({
+  name: 'docs.softRemove',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    assertDocsEditPermission(this.userId);
+    softRemove({ _id, collection: Docs });
+    reorderDocs({
+      collection: Docs,
+      ancestorId: 'root',
+    });
+  }
+});
+
+const restoreDoc = new ValidatedMethod({
+  name: 'docs.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    assertDocsEditPermission(this.userId);
+    restore({ _id, collection: Docs });
+    reorderDocs({
+      collection: Docs,
+      ancestorId: 'root',
+    });
+  }
+});
+
+export {
+  DocSchema,
+  insertDoc,
+  updateDoc,
+  pushToDoc,
+  pullFromDoc,
+  softRemoveDoc,
+  restoreDoc,
+};
+
+export default Docs;

app/imports/api/engine/actions/ActionContext.js

@@ -0,0 +1,78 @@
+import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
+import {
+  getCreature, getVariables, getPropertiesOfType
+} from '/imports/api/engine/loadCreatures.js';
+import { groupBy, remove } from 'lodash';
+
+export default class ActionContext{
+  constructor(creatureId, targetIds = [], method) {
+    // Get the creature
+    this.creature = getCreature(creatureId)
+
+    if (!this.creature) {
+      throw new Meteor.Error('No Creature', `No creature could be found with id: ${creatureId}`)
+    }
+    // Create a log
+    this.log = CreatureLogSchema.clean({
+      creatureId: creatureId,
+      creatureName: this.creature.name,
+    });
+
+    // Get the variables of the acting creature
+    this.creature.variables = getVariables(creatureId);
+    delete this.creature.variables._id;
+    delete this.creature.variables._creatureId;
+    // Alias as scope
+    this.scope = this.creature.variables;
+
+    // Get the targets and their variables
+    this.targets = [];
+    targetIds.forEach(targetId => {
+      let target;
+      if (targetId === creatureId) {
+        target = this.creature;
+      } else {
+        target = getCreature(targetId);
+        target.variables = getVariables(targetId);
+        delete target.variables._id;
+        delete target.variables._creatureId;
+      }
+      this.targets.push(target);
+    });
+
+    // Store a reference to the method for inserting the log
+    this.method = method;
+
+    // Get triggers
+    this.triggers = getPropertiesOfType(creatureId, 'trigger');
+    // Remove deleted or inactive triggers
+    remove(this.triggers, trigger => trigger.removed || trigger.inactive);
+    // Sort triggers by order
+    this.triggers.sort((a, b) => a.order - b.order);
+    // Group the triggers into triggers.<event>.<timing> or
+    // triggers.doActionProperty.<propertyType>.<timing>
+    this.triggers = groupBy(this.triggers, 'event');
+    for (let event in this.triggers) {
+      if (event === 'doActionProperty') {
+        this.triggers[event] = groupBy(this.triggers[event], 'actionPropertyType');
+        for (let propertyType in this.triggers[event]) {
+          this.triggers[event][propertyType] = groupBy(this.triggers[event][propertyType], 'timing');
+        }
+      } else {
+        this.triggers[event] = groupBy(this.triggers[event], 'timing');
+      }
+    }
+  }
+  addLog(content) {
+    if (content.name || content.value){
+      this.log.content.push(content);
+    }
+  }
+  writeLog() {
+    insertCreatureLogWork({
+      log: this.log,
+      creature: this.creature,
+      method: this.method,
+    });
+  }
+}

app/imports/api/engine/actions/applyProperty.js

@@ -0,0 +1,31 @@
+import action from './applyPropertyByType/applyAction.js';
+import adjustment from './applyPropertyByType/applyAdjustment.js';
+import branch from './applyPropertyByType/applyBranch.js';
+import buff from './applyPropertyByType/applyBuff.js';
+import buffRemover from './applyPropertyByType/applyBuffRemover.js';
+import damage from './applyPropertyByType/applyDamage.js';
+import folder from './applyPropertyByType/applyFolder.js';
+import note from './applyPropertyByType/applyNote.js';
+import roll from './applyPropertyByType/applyRoll.js';
+import savingThrow from './applyPropertyByType/applySavingThrow.js';
+import toggle from './applyPropertyByType/applyToggle.js';
+
+const applyPropertyByType = {
+  action,
+  adjustment,
+  branch,
+  buff,
+  buffRemover,
+  damage,
+  folder,
+  note,
+  roll,
+  savingThrow,
+  spell: action,
+  toggle,
+};
+
+export default function applyProperty(node, actionContext, ...rest) {
+  actionContext.scope[`#${node.node.type}`] = node.node;
+  applyPropertyByType[node.node.type]?.(node, actionContext, ...rest);
+}

app/imports/api/engine/actions/applyPropertyByType/applyAction.js

@@ -0,0 +1,306 @@
+import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
+import recalculateCalculation from './shared/recalculateCalculation.js';
+import rollDice from '/imports/parser/rollDice.js';
+import applyProperty from '../applyProperty.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { adjustQuantityWork } from '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
+import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
+import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import { resetProperties } from '/imports/api/creature/creatures/methods/restCreature.js';
+
+export default function applyAction(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+  if (prop.target === 'self') actionContext.targets = [actionContext.creature];
+  const targets = actionContext.targets;
+
+  // Log the name and summary
+  let content = { name: prop.name };
+  if (prop.summary?.text) {
+    recalculateInlineCalculations(prop.summary, actionContext);
+    content.value = prop.summary.value;
+  }
+  if (!prop.silent) actionContext.addLog(content);
+
+  // Spend the resources
+  const failed = spendResources(prop, actionContext);
+  if (failed) return;
+
+  const attack = prop.attackRoll || prop.attackRollBonus;
+
+  // Attack if there is an attack roll
+  if (attack && attack.calculation) {
+    if (targets.length) {
+      targets.forEach(target => {
+        applyAttackToTarget({ attack, target, actionContext });
+        // Apply the children, but only to the current target
+        actionContext.targets = [target];
+        applyChildren(node, actionContext);
+      });
+    } else {
+      applyAttackWithoutTarget({ attack, actionContext });
+      applyChildren(node, actionContext);
+    }
+  } else {
+    applyChildren(node, actionContext);
+  }
+  if (prop.actionType === 'event' && prop.variableName) {
+    resetProperties(actionContext.creature._id, prop.variableName, actionContext);
+  }
+}
+
+function applyAttackWithoutTarget({ attack, actionContext }) {
+  delete actionContext.scope['$attackHit'];
+  delete actionContext.scope['$attackMiss'];
+  delete actionContext.scope['$criticalHit'];
+  delete actionContext.scope['$criticalMiss'];
+  delete actionContext.scope['$attackRoll'];
+
+  recalculateCalculation(attack, actionContext);
+  const scope = actionContext.scope;
+  let {
+    resultPrefix,
+    result,
+    criticalHit,
+    criticalMiss,
+  } = rollAttack(attack, scope);
+  let name = criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit';
+  if (scope['$attackAdvantage'] === 1) {
+    name += ' (Advantage)';
+  } else if (scope['$attackAdvantage'] === -1) {
+    name += ' (Disadvantage)';
+  }
+  if (!criticalMiss) {
+    scope['$attackHit'] = { value: true }
+  }
+  if (!criticalHit) {
+    scope['$attackMiss'] = { value: true };
+  }
+
+  actionContext.addLog({
+    name,
+    value: `${resultPrefix}\n**${result}**`,
+    inline: true,
+  });
+}
+
+function applyAttackToTarget({ attack, target, actionContext }) {
+  const scope = actionContext.scope;
+  delete scope['$attackHit'];
+  delete scope['$attackMiss'];
+  delete scope['$criticalHit'];
+  delete scope['$criticalMiss'];
+  delete scope['$attackDiceRoll'];
+  delete scope['$attackRoll'];
+
+  recalculateCalculation(attack, actionContext);
+
+  let {
+    resultPrefix,
+    result,
+    criticalHit,
+    criticalMiss,
+  } = rollAttack(attack, scope);
+
+  if (target.variables.armor) {
+    const armor = target.variables.armor.value;
+
+    let name = criticalHit ? 'Critical Hit!' :
+      criticalMiss ? 'Critical Miss!' :
+        result > armor ? 'Hit!' : 'Miss!';
+    if (scope['$attackAdvantage'] === 1) {
+      name += ' (Advantage)';
+    } else if (scope['$attackAdvantage'] === -1) {
+      name += ' (Disadvantage)';
+    }
+
+    actionContext.addLog({
+      name,
+      value: `${resultPrefix}\n**${result}**`,
+      inline: true,
+    });
+    if (criticalMiss || result < armor) {
+      scope['$attackMiss'] = { value: true };
+    } else {
+      scope['$attackHit'] = { value: true };
+    }
+  } else {
+    actionContext.addLog({
+      name: 'Error',
+      value: 'Target has no `armor`',
+    });
+    actionContext.addLog({
+      name: criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit',
+      value: `${resultPrefix}\n**${result}**`,
+      inline: true,
+    });
+  }
+}
+
+function rollAttack(attack, scope) {
+  const rollModifierText = numberToSignedString(attack.value, true);
+  let value, resultPrefix;
+  if (scope['$attackAdvantage'] === 1) {
+    const [a, b] = rollDice(2, 20);
+    if (a >= b) {
+      value = a;
+      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
+    } else {
+      value = b;
+      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
+    }
+  } else if (scope['$attackAdvantage'] === -1) {
+    const [a, b] = rollDice(2, 20);
+    if (a <= b) {
+      value = a;
+      resultPrefix = `1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
+    } else {
+      value = b;
+      resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
+    }
+  } else {
+    value = rollDice(1, 20)[0];
+    resultPrefix = `1d20 [${value}] ${rollModifierText}`
+  }
+  scope['$attackDiceRoll'] = { value };
+  const result = value + attack.value;
+  scope['$attackRoll'] = { value: result };
+  const { criticalHit, criticalMiss } = applyCrits(value, scope);
+  return { resultPrefix, result, value, criticalHit, criticalMiss };
+}
+
+function applyCrits(value, scope) {
+  let criticalHitTarget = scope.criticalHitTarget?.value || 20;
+  let criticalHit = value >= criticalHitTarget;
+  let criticalMiss;
+  if (criticalHit) {
+    scope['$criticalHit'] = { value: true };
+  } else {
+    criticalMiss = value === 1;
+    if (criticalMiss) {
+      scope['$criticalMiss'] = { value: true };
+    }
+  }
+  return { criticalHit, criticalMiss };
+}
+
+function applyChildren(node, actionContext) {
+  applyNodeTriggers(node, 'after', actionContext);
+  node.children.forEach(child => applyProperty(child, actionContext));
+}
+
+function spendResources(prop, actionContext) {
+  // Check Uses
+  if (prop.usesLeft <= 0) {
+    if (!prop.silent) actionContext.addLog({
+      name: 'Error',
+      value: `${prop.name || 'action'} does not have enough uses left`,
+    });
+    return true;
+  }
+  // Resources
+  if (prop.insufficientResources) {
+    if (!prop.silent) actionContext.addLog({
+      name: 'Error',
+      value: 'This creature doesn\'t have sufficient resources to perform this action',
+    });
+    return true;
+  }
+  // Items
+  let itemQuantityAdjustments = [];
+  let spendLog = [];
+  let gainLog = [];
+  try {
+    prop.resources.itemsConsumed.forEach(itemConsumed => {
+      recalculateCalculation(itemConsumed.quantity, actionContext);
+      if (!itemConsumed.itemId) {
+        throw 'No ammo was selected for this prop';
+      }
+      let item = CreatureProperties.findOne(itemConsumed.itemId);
+      if (!item || item.ancestors[0].id !== prop.ancestors[0].id) {
+        throw 'The prop\'s ammo was not found on the creature';
+      }
+      if (!item.equipped) {
+        throw 'The selected ammo is not equipped';
+      }
+      if (
+        !itemConsumed.quantity.value ||
+        !isFinite(itemConsumed.quantity.value)
+      ) return;
+      itemQuantityAdjustments.push({
+        property: item,
+        operation: 'increment',
+        value: itemConsumed.quantity.value,
+      });
+      let logName = item.name;
+      if (itemConsumed.quantity.value > 1 || itemConsumed.quantity.value < -1) {
+        logName = item.plural || logName;
+      }
+      if (itemConsumed.quantity.value > 0) {
+        spendLog.push(logName + ': ' + itemConsumed.quantity.value);
+      } else if (itemConsumed.quantity.value < 0) {
+        gainLog.push(logName + ': ' + -itemConsumed.quantity.value);
+      }
+    });
+  } catch (e) {
+    actionContext.addLog({
+      name: 'Error',
+      value: e,
+    });
+    return true;
+  }
+  // No more errors should be thrown after this line
+  // Now that we have confirmed that there are no errors, do actual work
+  //Items
+  itemQuantityAdjustments.forEach(adjustQuantityWork);
+
+  // Use uses
+  if (prop.usesLeft) {
+    CreatureProperties.update(prop._id, {
+      $inc: { usesUsed: 1 }
+    }, {
+      selector: prop
+    });
+    if (!prop.silent) actionContext.addLog({
+      name: 'Uses left',
+      value: prop.usesLeft - 1,
+      inline: true,
+    });
+  }
+
+  // Damage stats
+  prop.resources.attributesConsumed.forEach(attConsumed => {
+    recalculateCalculation(attConsumed.quantity, actionContext);
+
+    if (!attConsumed.quantity?.value) return;
+    let stat = actionContext.scope[attConsumed.variableName];
+    if (!stat) {
+      spendLog.push(stat.name + ': ' + ' not found');
+      return;
+    }
+    damagePropertyWork({
+      prop: stat,
+      operation: 'increment',
+      value: attConsumed.quantity.value,
+      actionContext,
+    });
+    if (attConsumed.quantity.value > 0) {
+      spendLog.push(stat.name + ': ' + attConsumed.quantity.value);
+    } else if (attConsumed.quantity.value < 0) {
+      gainLog.push(stat.name + ': ' + -attConsumed.quantity.value);
+    }
+  });
+
+  // Log all the spending
+  if (gainLog.length && !prop.silent) actionContext.addLog({
+    name: 'Gained',
+    value: gainLog.join('\n'),
+    inline: true,
+  });
+  if (spendLog.length && !prop.silent) actionContext.addLog({
+    name: 'Spent',
+    value: spendLog.join('\n'),
+    inline: true,
+  });
+}

app/imports/api/engine/actions/applyPropertyByType/applyAdjustment.js

@@ -0,0 +1,61 @@
+import applyProperty from '../applyProperty.js';
+import recalculateCalculation from './shared/recalculateCalculation.js';
+import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyAdjustment(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+  const damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
+
+  if (!prop.amount) {
+    return applyChildren(node, actionContext);
+  }
+
+  // Evaluate the amount
+  recalculateCalculation(prop.amount, actionContext);
+
+  const value = +prop.amount.value;
+  if (!isFinite(value)) {
+    return applyChildren(node, actionContext);
+  }
+
+  if (damageTargets?.length) {
+    damageTargets.forEach(target => {
+      let stat = target.variables[prop.stat];
+      if (!stat?.type) {
+        if (!prop.silent) actionContext.addLog({
+          name: 'Error',
+          value: `Could not apply attribute damage, creature does not have \`${prop.stat}\` set`
+        });
+        return applyChildren(node, actionContext);
+      }
+      damagePropertyWork({
+        prop: stat,
+        operation: prop.operation,
+        value,
+        actionContext,
+      });
+      if (!prop.silent) actionContext.addLog({
+        name: 'Attribute damage',
+        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
+        ` ${value}`,
+        inline: true,
+      });
+    });
+  } else {
+    if (!prop.silent) actionContext.addLog({
+      name: 'Attribute damage',
+      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
+      ` ${value}`,
+      inline: true,
+    });
+  }
+
+  return applyChildren(node, actionContext);
+}
+
+function applyChildren(node, actionContext){
+  applyNodeTriggers(node, 'after', actionContext);
+  node.children.forEach(child => applyProperty(child, actionContext));
+}

app/imports/api/engine/actions/applyPropertyByType/applyBranch.js

@@ -0,0 +1,80 @@
+import applyProperty from '../applyProperty.js';
+import recalculateCalculation from './shared/recalculateCalculation.js';
+import rollDice from '/imports/parser/rollDice.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyBranch(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
+  const applyChildren = function(){
+    applyNodeTriggers(node, 'after', actionContext);
+    node.children.forEach(child => applyProperty(child, actionContext));
+  };
+  const scope = actionContext.scope;
+  const targets = actionContext.targets;
+  const prop = node.node;
+  switch(prop.branchType){
+    case 'if':
+      recalculateCalculation(prop.condition, actionContext);
+      if (prop.condition?.value) applyChildren();
+      break;
+    case 'index':
+      if (node.children.length){
+        recalculateCalculation(prop.condition, actionContext);
+        if (!isFinite(prop.condition?.value)) {
+          actionContext.addLog({
+            name: 'Branch Error',
+            value: 'Index did not resolve into a valid number'
+          });
+          break;
+        }
+        let index = Math.floor(prop.condition?.value);
+        if (index < 1) index = 1;
+        if (index > node.children.length) index = node.children.length;
+        applyNodeTriggers(node, 'after', actionContext);
+        applyProperty(node.children[index - 1], actionContext);
+      }
+      break;
+    case 'hit':
+      if (scope['$attackHit']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On hit**'});
+        applyChildren();
+      }
+      break;
+    case 'miss':
+      if (scope['$attackMiss']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On miss**'});
+        applyChildren();
+      }
+      break;
+    case 'failedSave':
+      if (scope['$saveFailed']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On failed save**'});
+        applyChildren();
+      }
+      break;
+    case 'successfulSave':
+      if (scope['$saveSucceeded']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On save**',});
+        applyChildren();
+      }
+      break;
+    case 'random':
+      if (node.children.length){
+        let index = rollDice(1, node.children.length)[0] - 1;
+        applyNodeTriggers(node, 'after', actionContext);
+        applyProperty(node.children[index], actionContext);
+      }
+      break;
+    case 'eachTarget':
+      if (targets.length) {
+        targets.forEach(target => {
+          applyNodeTriggers(node, 'after', actionContext);
+          actionContext.targets = [target]
+          node.children.forEach(child => applyProperty(child, actionContext));
+        });
+      } else {
+        applyChildren();
+      }
+      break;
+  }
+}

app/imports/api/engine/actions/applyPropertyByType/applyBuff.js

@@ -0,0 +1,177 @@
+import {
+  setLineageOfDocs,
+  renewDocIds
+} from '/imports/api/parenting/parenting.js';
+import { setDocToLastOrder } from '/imports/api/parenting/order.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex.js';
+import applyFnToKey from '/imports/api/engine/computation/utility/applyFnToKey.js';
+import { get } from 'lodash';
+import resolve, { map, toString } from '/imports/parser/resolve.js';
+import symbol from '/imports/parser/parseTree/symbol.js';
+import logErrors from './shared/logErrors.js';
+import { insertCreatureLog } from '/imports/api/creature/log/CreatureLogs.js';
+import cyrb53 from '/imports/api/engine/computation/utility/cyrb53.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
+import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
+
+export default function applyBuff(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+  let buffTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
+
+  // Then copy the decendants of the buff to the targets
+  let propList = [prop];
+  function addChildrenToPropList(children, { skipCrystalize } = {}) {
+    children.forEach(child => {
+      if (skipCrystalize) child.node._skipCrystalize = true;
+      propList.push(child.node);
+      // recursively add the child's children, but don't crystalize nested buffs
+      addChildrenToPropList(child.children, {
+        skipCrystalize: skipCrystalize || child.node.type === 'buff'
+      });
+    });
+  }
+  addChildrenToPropList(node.children);
+  if (!prop.skipCrystalization) {
+    crystalizeVariables({ propList, actionContext });
+  }
+
+  let oldParent = {
+    id: prop.parent.id,
+    collection: prop.parent.collection,
+  };
+  buffTargets.forEach(target => {
+    // Apply the buff
+    copyNodeListToTarget(propList, target, oldParent);
+
+    //Log the buff
+    let logValue = prop.description?.value
+    if (prop.description?.text) {
+      recalculateInlineCalculations(prop.description, actionContext);
+      logValue = prop.description?.value;
+    }
+    if ((prop.name || prop.description?.value) && !prop.silent) {
+      if (target._id === actionContext.creature._id) {
+        // Targeting self
+        actionContext.addLog({
+          name: prop.name,
+          value: logValue,
+        });
+      } else {
+        // Targeting other
+        insertCreatureLog.call({
+          log: {
+            creatureId: target._id,
+            content: [{
+              name: prop.name,
+              value: logValue,
+            }],
+          }
+        });
+      }
+    }
+  });
+  applyNodeTriggers(node, 'after', actionContext);
+
+  // Don't apply the children of the buff, they get copied to the target instead
+}
+
+function copyNodeListToTarget(propList, target, oldParent) {
+  let ancestry = [{ collection: 'creatures', id: target._id }];
+  setLineageOfDocs({
+    docArray: propList,
+    newAncestry: ancestry,
+    oldParent,
+  });
+  renewDocIds({
+    docArray: propList,
+  });
+  setDocToLastOrder({
+    collection: CreatureProperties,
+    doc: propList[0],
+  });
+  CreatureProperties.batchInsert(propList);
+}
+
+/**
+ * Replaces all variables with their resolved values
+ * except variables of the form `$target.thing.total` become `thing.total`
+ */
+function crystalizeVariables({ propList, actionContext }) {
+  propList.forEach(prop => {
+    if (prop._skipCrystalize) {
+      delete prop._skipCrystalize;
+      return;
+    }
+    // Iterate through all the calculations and crystalize them
+    computedSchemas[prop.type].computedFields().forEach(calcKey => {
+      applyFnToKey(prop, calcKey, (prop, key) => {
+        const calcObj = get(prop, key);
+        if (!calcObj?.parseNode) return;
+        calcObj.parseNode = map(calcObj.parseNode, node => {
+          // Skip nodes that aren't symbols or accessors
+          if (
+            node.parseType !== 'accessor' && node.parseType !== 'symbol'
+          ) return node;
+          // Handle variables
+          if (node.name === '$target') {
+            // strip $target
+            if (node.parseType === 'accessor') {
+              node.name = node.path.shift();
+              if (!node.path.length) {
+                return symbol.create({ name: node.name })
+              }
+            } else {
+              // Can't strip symbols
+              actionContext.addLog({
+                name: 'Error',
+                value: 'Variable `$target` should not be used without a property: $target.property',
+              });
+            }
+            return node;
+          } else {
+            // Resolve all other variables
+            const { result, context } = resolve('reduce', node, actionContext.scope);
+            logErrors(context.errors, actionContext);
+            return result;
+          }
+        });
+        calcObj.calculation = toString(calcObj.parseNode);
+        calcObj.hash = cyrb53(calcObj.calculation);
+      });
+    });
+    // For each key in the schema
+    computedSchemas[prop.type].inlineCalculationFields().forEach(calcKey => {
+      // That ends in .inlineCalculations
+      applyFnToKey(prop, calcKey, (prop, key) => {
+        const inlineCalcObj = get(prop, key);
+        if (!inlineCalcObj) return;
+
+        // If there is no text, skip
+        if (!inlineCalcObj.text) {
+          return;
+        }
+
+        // Replace all the existing calculations
+        let index = -1;
+        inlineCalcObj.text = inlineCalcObj.text.replace(INLINE_CALCULATION_REGEX, () => {
+          index += 1;
+          return `{${inlineCalcObj.inlineCalculations[index].calculation}}`;
+        });
+
+        // Set the value to the uncomputed string
+        inlineCalcObj.value = inlineCalcObj.text;
+
+        // Write a new hash
+        const inlineCalcHash = cyrb53(inlineCalcObj.text);
+        if (inlineCalcHash === inlineCalcObj.hash) {
+          // Skip if nothing changed
+          return;
+        }
+        inlineCalcObj.hash = inlineCalcHash;
+      });
+    });
+  });
+}

app/imports/api/engine/actions/applyPropertyByType/applyBuffRemover.js

@@ -0,0 +1,101 @@
+import { findLast, difference, intersection, filter } from 'lodash';
+import applyProperty from '../applyProperty.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import { getProperyAncestors, getPropertiesOfType } from '/imports/api/engine/loadCreatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import { softRemove } from '/imports/api/parenting/softRemove.js';
+import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
+
+export default function applyBuffRemover(node, actionContext) {
+  // Apply triggers
+  applyNodeTriggers(node, 'before', actionContext);
+
+  const prop = node.node;
+
+  // Log Name
+  if (prop.name && !prop.silent){
+    actionContext.addLog({ name: prop.name });
+  }
+
+  // Remove buffs
+  if (prop.targetParentBuff) {
+    // Remove nearest ancestor buff
+    const ancestors = getProperyAncestors(actionContext.creature._id, prop._id);
+    const nearestBuff = findLast(ancestors, ancestor => ancestor.type === 'buff');
+    if (!nearestBuff) {
+      actionContext.addLog({
+        name: 'Error',
+        value: 'Buff remover does not have a parent buff to remove',
+      });
+      return;
+    }
+    removeBuff(nearestBuff, actionContext, prop);
+  } else {
+    // Get all the buffs targeted by tags
+    const allBuffs = getPropertiesOfType(actionContext.creature._id, 'buff');
+    const targetedBuffs = filter(allBuffs, buff => {
+      if (buff.inactive) return false;
+      if (buffRemoverMatchTags(prop, buff)) return true;
+    });
+    // Remove the buffs
+    if (prop.removeAll) {
+      // Remove all matching buffs
+      targetedBuffs.forEach(buff => {
+        removeBuff(buff, actionContext, prop);
+      });
+    } else {
+      // Sort in reverse order
+      targetedBuffs.sort((a, b) => b.order - a.order);
+      // Remove the one with the highest order
+      const buff = targetedBuffs[0];
+      if (buff) {
+        removeBuff(buff, actionContext, prop);
+      }
+    }
+  }
+
+  // Apply triggers
+  applyNodeTriggers(node, 'after', actionContext);
+  // Apply children
+  node.children.forEach(child => applyProperty(child, actionContext));
+}
+
+function removeBuff(buff, actionContext, prop) {
+  if (!prop.silent) actionContext.addLog({
+    name: 'Removed',
+    value: `${buff.name || 'Buff'}`
+  });
+  softRemove({ _id: buff._id, collection: CreatureProperties });
+}
+
+function buffRemoverMatchTags(buffRemover, prop) {
+  let matched = false;
+  const propTags = getEffectivePropTags(prop);
+  // Check the target tags
+  if (
+    !buffRemover.targetTags?.length ||
+    difference(buffRemover.targetTags, propTags).length === 0
+  ) {
+    matched = true;
+  }
+  // Check the extra tags
+  buffRemover.extraTags?.forEach(extra => {
+    if (extra.operation === 'OR') {
+      if (matched) return;
+      if (
+        !extra.tags.length ||
+        difference(extra.tags, propTags).length === 0
+      ) {
+        matched = true;
+      }
+    } else if (extra.operation === 'NOT') {
+      if (
+        extra.tags.length &&
+        intersection(extra.tags, propTags)
+      ) {
+        return false;
+      }
+    }
+  });
+  return matched;
+}

app/imports/api/engine/actions/applyPropertyByType/applyDamage.js

@@ -0,0 +1,254 @@
+import { some, intersection, difference, remove, includes } from 'lodash';
+import applyProperty from '../applyProperty.js';
+import { insertCreatureLog } from '/imports/api/creature/log/CreatureLogs.js';
+import resolve, { Context, toString } from '/imports/parser/resolve.js';
+import logErrors from './shared/logErrors.js';
+import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
+import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
+import {
+  getPropertiesOfType
+} from '/imports/api/engine/loadCreatures.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
+
+export default function applyDamage(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
+  const applyChildren = function () {
+    applyNodeTriggers(node, 'after', actionContext);
+    node.children.forEach(child => applyProperty(child, actionContext));
+  };
+
+  const prop = node.node;
+  const scope = actionContext.scope;
+
+  // Skip if there is no parse node to work with
+  if (!prop.amount?.parseNode) return;
+
+  // Choose target
+  let damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
+  // Determine if the hit is critical
+  let criticalHit = scope['$criticalHit']?.value &&
+    prop.damageType !== 'healing' // Can't critically heal
+    ;
+  // Double the damage rolls if the hit is critical
+  let context = new Context({
+    options: { doubleRolls: criticalHit },
+  });
+
+  // Gather all the lines we need to log into an array
+  const logValue = [];
+  const logName = prop.damageType === 'healing' ? 'Healing' : 'Damage';
+
+  // roll the dice only and store that string
+  applyEffectsToCalculationParseNode(prop.amount, actionContext.log);
+  const { result: rolled } = resolve('roll', prop.amount.parseNode, scope, context);
+  if (rolled.parseType !== 'constant') {
+    logValue.push(toString(rolled));
+  }
+  logErrors(context.errors, actionContext);
+
+  // Reset the errors so we don't log the same errors twice
+  context.errors = [];
+
+  // Resolve the roll to a final value
+  const { result: reduced } = resolve('reduce', rolled, scope, context);
+  logErrors(context.errors, actionContext);
+
+  // Store the result
+  if (reduced.parseType === 'constant') {
+    prop.amount.value = reduced.value;
+  } else if (reduced.parseType === 'error') {
+    prop.amount.value = null;
+  } else {
+    prop.amount.value = toString(reduced);
+  }
+  let damage = +reduced.value;
+
+  // If we didn't end up with a constant of finite amount, give up
+  if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)) {
+    return applyChildren();
+  }
+
+  // Round the damage to a whole number
+  damage = Math.floor(damage);
+
+  // Convert extra damage into the stored type
+  if (prop.damageType === 'extra' && scope['$lastDamageType']) {
+    prop.damageType = scope['$lastDamageType'];
+  }
+  // Store current damage type
+  if (prop.damageType !== 'healing') {
+    scope['$lastDamageType'] = prop.damageType;
+  }
+
+  // Memoise the damage suffix for the log
+  let suffix = (criticalHit ? ' critical ' : ' ') +
+    prop.damageType +
+    (prop.damageType !== 'healing' ? ' damage ' : '');
+
+  if (damageTargets && damageTargets.length) {
+    // Iterate through all the targets
+    damageTargets.forEach(target => {
+
+      // Apply weaknesses/resistances/immunities
+      damage = applyDamageMultipliers({
+        target,
+        damage,
+        damageProp: prop,
+        logValue
+      });
+
+      actionContext.target = [target];
+      // Deal the damage to the target
+      let damageDealt = dealDamage({
+        target,
+        damageType: prop.damageType,
+        amount: damage,
+        actionContext
+      });
+
+      // Log the damage done
+      if (target._id === actionContext.creature._id) {
+        // Target is same as self, log damage as such
+        logValue.push(`**${damageDealt}** ${suffix}  to self`);
+      } else {
+        logValue.push(`Dealt **${damageDealt}** ${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,
+              value: `Recieved **${damageDealt}** ${suffix}`,
+            }],
+          }
+        });
+      }
+    });
+  } else {
+    // There are no targets, just log the result
+    logValue.push(`**${damage}** ${suffix}`);
+  }
+  if (!prop.silent) actionContext.addLog({
+    name: logName,
+    value: logValue.join('\n'),
+    inline: true,
+  });
+  return applyChildren();
+}
+
+function applyDamageMultipliers({ target, damage, damageProp, logValue }) {
+  const damageType = damageProp?.damageType;
+  if (!damageType) return damage;
+
+  const multiplier = target?.variables?.[damageType];
+  if (!multiplier) return damage;
+
+  const damageTypeText = damageType == 'healing' ? 'healing' : `${damageType} damage`;
+
+  if (
+    multiplier.immunity &&
+    some(multiplier.immunities, multiplierAppliesTo(damageProp, 'immunity'))
+  ) {
+    logValue.push(`Immune to ${damageTypeText}`);
+    return 0;
+  } else {
+    if (
+      multiplier.resistance &&
+      some(multiplier.resistances, multiplierAppliesTo(damageProp, 'resistance'))
+    ) {
+      logValue.push(`Resistant to ${damageTypeText}`);
+      damage = Math.floor(damage / 2);
+    }
+    if (
+      multiplier.vulnerability &&
+      some(multiplier.vulnerabilities, multiplierAppliesTo(damageProp, 'vulnerability'))
+    ) {
+      logValue.push(`Vulnerable to ${damageTypeText}`);
+      damage = Math.floor(damage * 2);
+    }
+  }
+  return damage;
+}
+
+function multiplierAppliesTo(damageProp, multiplierType) {
+  return multiplier => {
+    // Apply the default 'ignore x' tags
+    const effectiveTags = getEffectivePropTags(damageProp);
+    if (includes(effectiveTags, `ignore ${multiplierType}`)) return false;
+
+    const hasRequiredTags = difference(
+      multiplier.includeTags, effectiveTags
+    ).length === 0;
+
+    const hasNoExcludedTags = intersection(
+      multiplier.excludeTags, effectiveTags
+    ).length === 0;
+
+    return hasRequiredTags && hasNoExcludedTags;
+  }
+}
+
+function dealDamage({ target, damageType, amount, actionContext }) {
+  // Get all the health bars and do damage to them
+  let healthBars = getPropertiesOfType(target._id, 'attribute');
+
+  // Keep only the healthbars that can take damage/healing
+  remove(healthBars, (bar) =>
+    bar.attributeType !== 'healthBar' ||
+    bar.inactive ||
+    bar.removed ||
+    bar.overridden ||
+    (amount >= 0 && bar.healthBarNoDamage) ||
+    (amount < 0 && bar.healthBarNoHealing)
+  );
+
+  // Sort healthbars by damage/healing order or tree order as a fallback
+  healthBars.sort((a, b) => {
+    let diff;
+    if (amount >= 0) {
+      diff = a.healthBarDamageOrder - b.healthBarDamageOrder;
+    } else {
+      diff = a.healthBarHealingOrder - b.healthBarHealingOrder;
+    }
+    if (Number.isFinite(diff)) {
+      return diff;
+    } else {
+      return a.order - b.order;
+    }
+  });
+
+  // Deal the damage to each healthbar in order until all damage is done
+  const totalDamage = amount;
+  let damageLeft = totalDamage;
+  if (damageType === 'healing') damageLeft = -totalDamage;
+  healthBars.forEach(healthBar => {
+    if (damageLeft === 0) return;
+    // Replace the healthbar by the one in the action context if we can
+    // The damagePropertyWork function bashes the prop with the damage
+    // So we can use the new value in later action properties
+    if (healthBar.variableName) {
+      const targetHealthBar = target.variables[healthBar.variableName];
+      if (targetHealthBar?._id === healthBar._id) {
+        healthBar = targetHealthBar;
+      }
+    }
+    // Do the damage
+    let damageAdded = damagePropertyWork({
+      prop: healthBar,
+      operation: 'increment',
+      value: damageLeft,
+      actionContext
+    });
+    damageLeft -= damageAdded;
+    // Prevent overflow
+    if (
+      damageType === 'healing' ?
+        healthBar.healthBarNoHealingOverflow :
+        healthBar.healthBarNoDamageOverflow
+    ) {
+      damageLeft = 0;
+    }
+  });
+  return totalDamage;
+}

app/imports/api/engine/actions/applyPropertyByType/applyFolder.js

@@ -0,0 +1,11 @@
+import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
+import applyProperty from '../applyProperty.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyFolder(node, actionContext) {
+  // Apply triggers
+  applyNodeTriggers(node, 'before', actionContext);
+  applyNodeTriggers(node, 'after', actionContext);
+  // Apply children
+  node.children.forEach(child => applyProperty(child, actionContext));
+}

app/imports/api/engine/actions/applyPropertyByType/applyNote.js

@@ -0,0 +1,27 @@
+import recalculateInlineCalculations from './shared/recalculateInlineCalculations.js';
+import applyProperty from '../applyProperty.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyNote(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+
+  // Log Name, summary
+  let content = { name: prop.name };
+  if (prop.summary?.text){
+    recalculateInlineCalculations(prop.summary, actionContext);
+    content.value = prop.summary.value;
+  }
+  if (content.name || content.value){
+    actionContext.addLog(content);
+  }
+  // Log description
+  if (prop.description?.text){
+    recalculateInlineCalculations(prop.description, actionContext);
+    actionContext.addLog({value: prop.description.value});
+  }
+  // Apply triggers
+  applyNodeTriggers(node, 'after', actionContext);
+  // Apply children
+  node.children.forEach(child => applyProperty(child, actionContext));
+}

app/imports/api/engine/actions/applyPropertyByType/applyRoll.js

@@ -0,0 +1,61 @@
+import applyProperty from '../applyProperty.js';
+import logErrors from './shared/logErrors.js';
+import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
+import resolve, { toString } from '/imports/parser/resolve.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyRoll(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+
+  const applyChildren = function(){
+    applyNodeTriggers(node, 'after', actionContext);
+    node.children.forEach(child => applyProperty(child, actionContext));
+  };
+
+  if (prop.roll?.calculation){
+    const logValue = [];
+
+    // roll the dice only and store that string
+    applyEffectsToCalculationParseNode(prop.roll, actionContext);
+    const {result: rolled, context} = resolve('roll', prop.roll.parseNode, actionContext.scope);
+    if (rolled.parseType !== 'constant'){
+      logValue.push(toString(rolled));
+    }
+    logErrors(context.errors, actionContext);
+
+    // Reset the errors so we don't log the same errors twice
+    context.errors = [];
+
+    // Resolve the roll to a final value
+    const {result: reduced} = resolve('reduce', rolled, actionContext.scope, context);
+    logErrors(context.errors, actionContext);
+
+    // Store the result
+    if (reduced.parseType === 'constant'){
+      prop.roll.value = reduced.value;
+    } else if (reduced.parseType === 'error'){
+      prop.roll.value = null;
+    } else {
+      prop.roll.value = toString(reduced);
+    }
+
+    // If we didn't end up with a constant of finite amount, give up
+    if (reduced?.parseType !== 'constant' || !isFinite(reduced.value)){
+      return applyChildren();
+    }
+    const value = reduced.value;
+
+    actionContext.scope[prop.variableName] = value;
+    logValue.push(`**${value}**`);
+
+    if (!prop.silent){
+      actionContext.addLog({
+        name: prop.name,
+        value: logValue.join('\n'),
+        inline: true,
+      });
+    }
+  }
+  return applyChildren();
+}

app/imports/api/engine/actions/applyPropertyByType/applySavingThrow.js

@@ -0,0 +1,109 @@
+import rollDice from '/imports/parser/rollDice.js';
+import recalculateCalculation from './shared/recalculateCalculation.js';
+import applyProperty from '../applyProperty.js';
+import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import { applyUnresolvedEffects } from '/imports/api/engine/actions/doCheck.js';
+
+export default function applySavingThrow(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+
+  let saveTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
+
+  recalculateCalculation(prop.dc, actionContext);
+
+  const dc = (prop.dc?.value);
+  if (!isFinite(dc)) {
+    actionContext.addLog({
+      name: 'Error',
+      value: 'Saving throw requires a DC',
+    });
+    return node.children.forEach(child => applyProperty(child, actionContext));
+  }
+  if (!prop.silent) actionContext.addLog({
+    name: prop.name,
+    value: `DC **${dc}**`,
+    inline: true,
+  });
+  const scope = actionContext.scope;
+
+  // If there are no save targets, apply all children as if the save both
+  // succeeeded and failed
+  if (!saveTargets?.length) {
+    scope['$saveFailed'] = { value: true };
+    scope['$saveSucceeded'] = { value: true };
+    applyNodeTriggers(node, 'after', actionContext);
+    return node.children.forEach(child => applyProperty(child, actionContext));
+  }
+
+  // Each target makes the saving throw
+  saveTargets.forEach(target => {
+    delete scope['$saveFailed'];
+    delete scope['$saveSucceeded'];
+    delete scope['$saveDiceRoll'];
+    delete scope['$saveRoll'];
+
+    const applyChildren = function () {
+      applyNodeTriggers(node, 'after', actionContext);
+      actionContext.targets = [target]
+      node.children.forEach(child => applyProperty(child, actionContext));
+    };
+
+    const save = target.variables[prop.stat];
+
+    if (!save) {
+      actionContext.addLog({
+        name: 'Saving throw error',
+        value: 'No saving throw found: ' + prop.stat,
+      });
+      return applyChildren();
+    }
+
+    let rollModifierText = numberToSignedString(save.value, true);
+    let rollModifier = save.value
+    const { effectBonus, effectString } = applyUnresolvedEffects(save, scope)
+    rollModifierText += effectString;
+    rollModifier += effectBonus;
+
+    let value, values, resultPrefix;
+    if (save.advantage === 1) {
+      const [a, b] = rollDice(2, 20);
+      if (a >= b) {
+        value = a;
+        resultPrefix = `Advantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
+      } else {
+        value = b;
+        resultPrefix = `Advantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
+      }
+    } else if (save.advantage === -1) {
+      const [a, b] = rollDice(2, 20);
+      if (a <= b) {
+        value = a;
+        resultPrefix = `Disadvantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
+      } else {
+        value = b;
+        resultPrefix = `Disadvantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
+      }
+    } else {
+      values = rollDice(1, 20);
+      value = values[0];
+      resultPrefix = `1d20 [ ${value} ] ${rollModifierText}`
+    }
+    scope['$saveDiceRoll'] = { value };
+    const result = value + rollModifier || 0;
+    scope['$saveRoll'] = { value: result };
+    const saveSuccess = result >= dc;
+    if (saveSuccess) {
+      scope['$saveSucceeded'] = { value: true };
+    } else {
+      scope['$saveFailed'] = { value: true };
+    }
+    if (!prop.silent) actionContext.addLog({
+      name: saveSuccess ? 'Successful save' : 'Failed save',
+      value: resultPrefix + '\n**' + result + '**',
+      inline: true,
+    });
+    return applyChildren();
+  });
+}

app/imports/api/engine/actions/applyPropertyByType/applyToggle.js

@@ -0,0 +1,13 @@
+import applyProperty from '../applyProperty.js';
+import recalculateCalculation from './shared/recalculateCalculation.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+
+export default function applyToggle(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
+  const prop = node.node;
+  recalculateCalculation(prop.condition, actionContext);
+  if (prop.condition?.value) {
+    applyNodeTriggers(node, 'after', actionContext);
+    return node.children.forEach(child => applyProperty(child, actionContext));
+  }
+}

app/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js

@@ -0,0 +1,24 @@
+import operator from '/imports/parser/parseTree/operator.js';
+import { parse } from '/imports/parser/parser.js';
+import logErrors from './logErrors.js';
+
+export default function applyEffectsToCalculationParseNode(calcObj, actionContext){
+  if (!calcObj.effects) return;
+  calcObj.effects.forEach(effect => {
+    if (effect.operation !== 'add') return;
+    if (!effect.amount) return;
+    if (effect.amount.value === null) return;
+    let effectParseNode;
+    try {
+      effectParseNode = parse(effect.amount.value.toString());
+      calcObj.parseNode = operator.create({
+        left: calcObj.parseNode,
+        right: effectParseNode,
+        operator: '+',
+        fn: 'add'
+      });
+    } catch (e){
+      logErrors([e], actionContext)
+    }
+  });
+}