Bumped version

It was hiding behind FAB

.gitignore

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

app/.gitignore

@@ -3,6 +3,7 @@
 .demeteorized
 .cache
 .vscode
+fileStorage
 settings.json
 public/components
 public/_imports.html

app/.meteor/packages

@@ -3,29 +3,28 @@
 # 'meteor add' and 'meteor remove' will edit this file for you,
 # but you can also edit it by hand.
 
-accounts-password@2.2.0
-random@1.2.0
-underscore@1.0.10
+accounts-password@2.3.1
+random@1.2.1
+underscore@1.0.11
 dburles:mongo-collection-instances
 accounts-google@1.4.0
-email@2.2.0
+email@2.2.2
 meteor-base@1.5.1
 mobile-experience@1.1.0
-mongo@1.14.6
-session@1.2.0
-tracker@1.2.0
+mongo@1.16.1
+session@1.2.1
+tracker@1.2.1
 logging@1.3.1
 reload@1.3.1
-ejson@1.1.1
-check@1.3.1
-standard-minifier-js@2.8.0
+ejson@1.1.3
+check@1.3.2
+standard-minifier-js@2.8.1
 shell-server@0.5.0
-ecmascript@0.16.1
+ecmascript@0.16.3
 es5-shim@4.8.0
-percolate:synced-cron
-service-configuration@1.3.0
+service-configuration@1.3.1
 dynamic-import@0.7.2
-ddp-rate-limiter@1.1.0
+ddp-rate-limiter@1.1.1
 rate-limit@1.0.9
 mdg:validated-method
 static-html@1.3.2
@@ -38,7 +37,6 @@ simple:rest
 simple:rest-method-mixin
 mikowals:batch-insert
 peerlibrary:subscription-data
-seba:minifiers-autoprefixer
 zer0th:meteor-vuetify-loader
 akryum:vue-component
 akryum:vue-router2
@@ -47,3 +45,7 @@ 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@2.6.1
+METEOR@2.8.1

app/.meteor/versions

@@ -1,7 +1,7 @@
-accounts-base@2.2.1
+accounts-base@2.2.5
 accounts-google@1.4.0
-accounts-oauth@1.4.0
-accounts-password@2.2.0
+accounts-oauth@1.4.1
+accounts-password@2.3.1
 accounts-patreon@0.1.0
 akryum:npm-check@0.1.2
 akryum:vue-component@0.15.2
@@ -12,72 +12,76 @@ aldeed:collection2@3.5.0
 aldeed:schema-index@3.0.0
 allow-deny@1.1.1
 autoupdate@1.8.0
-babel-compiler@7.8.1
-babel-runtime@1.5.0
+babel-compiler@7.9.2
+babel-runtime@1.5.1
 base64@1.0.12
 binary-heap@1.0.11
-blaze-tools@1.1.2
+blaze-tools@1.1.3
 boilerplate-generator@1.7.1
-bozhao:link-accounts@2.4.0
+bozhao:link-accounts@2.6.1
 caching-compiler@1.2.2
 caching-html-compiler@1.2.1
 callback-hook@1.4.0
-check@1.3.1
+check@1.3.2
 coffeescript@2.4.1
 coffeescript-compiler@2.4.1
 dburles:mongo-collection-instances@0.3.6
-ddp@1.4.0
-ddp-client@2.5.0
+ddp@1.4.1
+ddp-client@2.6.1
 ddp-common@1.4.0
-ddp-rate-limiter@1.1.0
-ddp-server@2.5.0
-diff-sequence@1.1.1
+ddp-rate-limiter@1.1.1
+ddp-server@2.6.0
+diff-sequence@1.1.2
 dynamic-import@0.7.2
-ecmascript@0.16.1
+ecmascript@0.16.3
 ecmascript-runtime@0.8.0
 ecmascript-runtime-client@0.12.1
 ecmascript-runtime-server@0.11.0
-ejson@1.1.1
-email@2.2.0
+ejson@1.1.3
+email@2.2.2
 es5-shim@4.8.0
-fetch@0.1.1
-geojson-utils@1.0.10
-google-oauth@1.4.1
+fetch@0.1.2
+geojson-utils@1.0.11
+google-oauth@1.4.2
 hot-code-push@1.0.4
-html-tools@1.1.2
+html-tools@1.1.3
 htmljs@1.1.1
 http@2.0.0
 id-map@1.1.1
 inter-process-messaging@0.1.1
 lai:collection-extensions@0.3.0
 launch-screen@1.3.0
+littledata:synced-cron@1.5.1
+livedata@1.0.18
 localstorage@1.2.0
 logging@1.3.1
+mdg:meteor-apm-agent@3.5.1
 mdg:validated-method@1.2.0
-meteor@1.10.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.0
-minifier-js@2.7.3
-minimongo@1.8.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.7
-modules@0.18.0
-modules-runtime@0.12.0
-mongo@1.14.6
-mongo-decimal@0.1.2
+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.8
-npm-mongo@4.3.1
-oauth@2.1.1
+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.0
-ostrio:files@2.0.1
+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
@@ -89,21 +93,20 @@ peerlibrary:reactive-mongo@0.4.1
 peerlibrary:reactive-publish@0.10.0
 peerlibrary:server-autorun@0.8.0
 peerlibrary:subscription-data@0.8.0
-percolate:migrations@1.0.3
-percolate:synced-cron@1.3.2
-promise@0.12.0
+percolate:migrations@1.1.0
+promise@0.12.1
 raix:eventemitter@1.0.0
-random@1.2.0
+random@1.2.1
 rate-limit@1.0.9
-react-fast-refresh@0.2.2
-reactive-dict@1.3.0
-reactive-var@1.0.11
+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.1
 seba:minifiers-autoprefixer@2.0.1
-service-configuration@1.3.0
-session@1.2.0
+service-configuration@1.3.1
+session@1.2.1
 sha@1.0.9
 shell-server@0.5.0
 simple:json-routes@2.3.1
@@ -111,16 +114,16 @@ 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.4.0
-spacebars-compiler@1.3.0
-standard-minifier-js@2.8.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.1
+templating-tools@1.2.2
 tmeasday:check-npm-versions@1.0.2
-tracker@1.2.0
-typescript@4.4.1
-underscore@1.0.10
+tracker@1.2.1
+typescript@4.5.4
+underscore@1.0.11
 url@1.3.2
-webapp@1.13.1
-webapp-hashing@1.1.0
+webapp@1.13.2
+webapp-hashing@1.1.1
 zer0th:meteor-vuetify-loader@0.1.41

app/client/head.html

@@ -2,38 +2,38 @@
   <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,6 +1,6 @@
 import '/imports/api/simpleSchemaConfig.js';
-import '/imports/ui/vueSetup.js';
-import '/imports/ui/styles/stylesIndex.js';
+import '/imports/client/ui/vueSetup.js';
+import '/imports/client/ui/styles/stylesIndex.js';
 import '/imports/client/config.js';
 import '/imports/client/serviceWorker.js';
 

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

@@ -1,17 +1,58 @@
-import { createS3FilesCollection } from '/imports/api/files/s3FileStorage.js';
+
+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 ? '/DiceCloud/archiveCreatures/' : 'assets/app/archiveCreatures',
+  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)){
+    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/ArchivedCreatures.js

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

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

@@ -68,7 +68,7 @@ const archiveCreatureToFile = new ValidatedMethod({
   async run({creatureId}) {
     assertOwnership(creatureId, this.userId);
     if (Meteor.isServer){
-      archiveCreature(creatureId);
+      archiveCreature(creatureId, this.userId);
     } else {
       removeCreatureWork(creatureId);
     }

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

@@ -1,4 +1,3 @@
-// import '/imports/api/creature/archive/methods/archiveCreatures.js';
 import '/imports/api/creature/archive/methods/archiveCreatureToFile.js';
-import '/imports/api/creature/archive/methods/restoreCreatures.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

@@ -8,12 +8,16 @@ 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){
+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.')
@@ -22,6 +26,19 @@ function restoreCreature(archive){
   // 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);
@@ -69,13 +86,18 @@ const restoreCreaturefromFile = new ValidatedMethod({
       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);
+      restoreCreature(archive, this.userId);
     }
     //Remove the archive once the restore succeeded
-    ArchiveCreatureFiles.remove({_id: fileId});
+    ArchiveCreatureFiles.remove({ _id: fileId });
+    // Update the user's file storage limits
+    incrementFileStorageUsed(userId, -file.size);
   },
 });
 

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

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

app/imports/api/creature/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/creatureFolders/CreatureFolders.js

@@ -4,25 +4,25 @@ 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,
+  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,
+  },
+  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,

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

@@ -18,23 +18,23 @@ let CreaturePropertySchema = new SimpleSchema({
     type: String,
     optional: true,
   },
-	type: {
+  type: {
     type: String,
     allowedValues: Object.keys(propertySchemasIndex),
   },
-	tags: {
-		type: Array,
-		defaultValue: [],
+  tags: {
+    type: Array,
+    defaultValue: [],
     maxCount: STORAGE_LIMITS.tagCount,
-	},
-	'tags.$': {
-		type: String,
+  },
+  'tags.$': {
+    type: String,
     max: STORAGE_LIMITS.tagLength,
-	},
-	disabled: {
-		type: Boolean,
-		optional: true,
-	},
+  },
+  disabled: {
+    type: Boolean,
+    optional: true,
+  },
   icon: {
     type: storedIconsSchema,
     optional: true,
@@ -82,28 +82,31 @@ const DenormalisedOnlyCreaturePropertySchema = new SimpleSchema({
     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);
+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}
-	});
+  schema.extend(ChildSchema);
+  schema.extend(SoftRemovableSchema);
+  CreatureProperties.attachSchema(schema, {
+    selector: { type: key }
+  });
 }
 
-import '/imports/api/creature/creatureProperties/methods/index.js';
-//import '/imports/api/creature/actions/doAction.js';
-//import '/imports/api/creature/actions/castSpellWithSlot.js';
-
 export default CreatureProperties;
 export {
   DenormalisedOnlyCreaturePropertySchema,
-	CreaturePropertySchema,
+  CreaturePropertySchema,
 };

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

@@ -4,7 +4,6 @@ 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';
-import computeCreature from '/imports/api/engine/computeCreature.js';
 
 const adjustQuantity = new ValidatedMethod({
   name: 'creatureProperties.adjustQuantity',
@@ -21,43 +20,40 @@ const adjustQuantity = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, operation, value}) {
+  run({ _id, operation, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Do work
-    adjustQuantityWork({property, operation, value});
-
-    // Changing quantity does not change dependencies, but recomputing the
-    // inventory changes many deps at once, so recompute fully
-    computeCreature(rootCreature._id);
+    adjustQuantityWork({ property, operation, value });
   },
 });
 
-export function adjustQuantityWork({property, operation, value}){
+export function adjustQuantityWork({ property, operation, value }) {
   // Check if property has quantity
   let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')){
+  if (!schema.allowsKey('quantity')) {
     throw new Meteor.Error(
       'Adjust quantity failed',
       `Property of type "${property.type}" doesn't have a quantity`
     );
   }
-  if (operation === 'set'){
+  if (operation === 'set') {
     CreatureProperties.update(property._id, {
-      $set: {quantity: value}
+      $set: { quantity: value, dirty: true }
     }, {
       selector: property
     });
-  } else if (operation === 'increment'){
+  } 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}
+      $inc: { quantity: value },
+      $set: { dirty: true }
     }, {
       selector: property
     });

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

@@ -1,53 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-
-const damagePropertiesByName = new ValidatedMethod({
-  name: 'CreatureProperties.damagePropertiesByName',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    variableName: {
-      type: String,
-    },
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, variableName, operation, value}) {
-		// Check permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        variables: 1,
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-    CreatureProperties.find({
-      'ancestors.id': creatureId,
-      variableName,
-      removed: {$ne: false},
-      inactive: {$ne: true},
-    }).forEach(property => {
-      // Check if property can take damage
-      let schema = CreatureProperties.simpleSchema(property);
-      if (!schema.allowsKey('damage')) return;
-      // Damage the property
-      damagePropertyWork({property, operation, value});
-    });
-  }
-});
-
-export default damagePropertiesByName;

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

@@ -2,9 +2,9 @@ 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';
-import { computeCreatureDependencyGroup } from '/imports/api/engine/computeCreature.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',
@@ -21,60 +21,121 @@ const damageProperty = new ValidatedMethod({
     numRequests: 20,
     timeInterval: 5000,
   },
-  run({_id, operation, value}) {
-    // Check permissions
-		let property = CreatureProperties.findOne(_id);
-    if (!property) throw new Meteor.Error(
+  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'
     );
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(property);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${property.type}" can't be damaged`
-			);
-		}
-		let result = damagePropertyWork({property, operation, value});
-    // Dependencies can't be changed through damage, only recompute deps
-    computeCreatureDependencyGroup(property);
+    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({property, operation, value}){
-  let damage, newValue;
-  if (operation === 'set'){
-    const total = property.total || 0;
+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) damage = total;
+    if (damage > total && !prop.ignoreLowerLimit) damage = total;
     // Damage must be positive
-    if (damage < 0) damage = 0;
-    newValue = property.total - damage;
-  } else if (operation === 'increment'){
-    let currentValue = property.value || 0;
-    let currentDamage = property.damage || 0;
-    let increment = value;
+    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) increment = currentValue;
+    if (increment > currentValue && !prop.ignoreLowerLimit) increment = currentValue;
     // Can't decrease damage below zero
-    if (-increment > currentDamage) increment = -currentDamage;
+    if (-increment > currentDamage && !prop.ignoreUpperLimit) increment = -currentDamage;
     damage = currentDamage + increment;
-    newValue = property.total - damage;
+    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);
   }
 
-  // Write the results
-  CreatureProperties.update(property._id, {
-    $set: {damage, value: newValue}
-  }, {
-    selector: property
-  });
-  return damage;
+  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/dealDamage.js

@@ -1,72 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import computeCreature from '/imports/api/engine/computeCreature.js';
-
-const dealDamage = new ValidatedMethod({
-  name: 'creatureProperties.dealDamage',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    damageType: {
-      type: String,
-    },
-    amount: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, damageType, amount}) {
-    // permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-
-    const totalDamage = dealDamageWork({creature, damageType, amount})
-    computeCreature(creatureId);
-    return totalDamage;
-  },
-});
-
-export function dealDamageWork({creature, damageType, amount}){
-  // Get all the health bars and do damage to them
-  let healthBars = CreatureProperties.find({
-    'ancestors.id': creature._id,
-    type: 'attribute',
-    attributeType:'healthBar',
-    removed: {$ne: true},
-    inactive: {$ne: true},
-  }, {
-    sort: {order: -1},
-  });
-  //let multiplier = creature.damageMultipliers[damageType];
-  //if (multiplier === undefined) multiplier = 1;
-  //let totalDamage = Math.floor(amount * multiplier);
-  const totalDamage = amount;
-  let damageLeft = totalDamage;
-  if (damageType === 'healing') damageLeft = -totalDamage;
-  let propertyIds = [];
-  healthBars.forEach(healthBar => {
-    if (damageLeft === 0) return;
-    let damageAdded = damagePropertyWork({
-      property: healthBar,
-      operation: 'increment',
-      value: damageLeft,
-    });
-    damageLeft -= damageAdded;
-    propertyIds.push(healthBar._id);
-  });
-  return totalDamage;
-}
-
-export default dealDamage;

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

@@ -5,15 +5,14 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import {
-	setLineageOfDocs,
-	renewDocIds
+  setLineageOfDocs,
+  renewDocIds
 } from '/imports/api/parenting/parenting.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
-import computeCreature from '/imports/api/engine/computeCreature.js';
 var snackbar;
-if (Meteor.isClient){
+if (Meteor.isClient) {
   snackbar = require(
-    '/imports/ui/components/snackbars/SnackbarQueue.js'
+    '/imports/client/ui/components/snackbars/SnackbarQueue.js'
   ).snackbar
 }
 
@@ -32,7 +31,7 @@ const duplicateProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     let property = CreatureProperties.findOne(_id);
     let creature = getRootCreatureAncestor(property);
 
@@ -45,17 +44,17 @@ const duplicateProperty = new ValidatedMethod({
 
     // Get all the descendants
     let nodes = CreatureProperties.find({
-			'ancestors.id': _id,
-			removed: {$ne: true},
-		}, {
+      'ancestors.id': _id,
+      removed: { $ne: true },
+    }, {
       limit: DUPLICATE_CHILDREN_LIMIT + 1,
-      sort: {order: 1},
+      sort: { order: 1 },
     }).fetch();
 
     // Alert the user if the limit was hit
-    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
+    if (nodes.length > DUPLICATE_CHILDREN_LIMIT) {
       nodes.pop();
-      if (Meteor.isClient){
+      if (Meteor.isClient) {
         snackbar({
           text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
         });
@@ -64,22 +63,25 @@ const duplicateProperty = new ValidatedMethod({
 
     // re-map all the ancestors
     setLineageOfDocs({
-			docArray: nodes,
-			newAncestry : [
+      docArray: nodes,
+      newAncestry: [
         ...property.ancestors,
-        {id: propertyId, collection: 'creatureProperties'}
+        { id: propertyId, collection: 'creatureProperties' }
       ],
-			oldParent : {id: _id, collection: 'creatureProperties'},
-		});
+      oldParent: { id: _id, collection: 'creatureProperties' },
+    });
 
     // Give the docs new IDs without breaking internal references
-    renewDocIds({docArray: nodes});
+    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]);
+    CreatureProperties.batchInsert([property, ...nodes]);
 
     // Tree structure changed by inserts, reorder the tree
     reorderDocs({
@@ -87,9 +89,6 @@ const duplicateProperty = new ValidatedMethod({
       ancestorId: property.ancestors[0].id,
     });
 
-    // Inserting a creature property invalidates dependencies: full recompute
-    computeCreature(creature._id);
-
     return propertyId;
   },
 });

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

@@ -4,15 +4,14 @@ 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 computeCreature from '/imports/api/engine/computeCreature.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');
+  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');
     }
@@ -22,20 +21,20 @@ const equipItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, equipped}) {
+  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');
+      'Equip and unequip can only be performed on items');
     let creature = getRootCreatureAncestor(item);
     assertEditPermission(creature, this.userId);
     CreatureProperties.update(_id, {
-      $set: {equipped},
+      $set: { equipped, dirty: true },
     }, {
-			selector: {type: 'item'},
-		});
+      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'};
+    if (!parentRef) parentRef = { id: creature._id, collection: 'creatures' };
 
     organizeDoc.call({
       docRef: {
@@ -46,8 +45,6 @@ const equipItem = new ValidatedMethod({
       order: Number.MAX_SAFE_INTEGER,
       skipRecompute: true,
     });
-
-    computeCreature(creature._id);
   },
 });
 

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

@@ -3,28 +3,27 @@ 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 computeCreature from '/imports/api/engine/computeCreature.js';
 
 const flipToggle = new ValidatedMethod({
   name: 'creatureProperties.flipToggle',
-  validate({_id}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  validate({ _id }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
   },
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     // Permission
     let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1, enabled: 1, disabled: 1}
+      fields: { type: 1, ancestors: 1, enabled: 1, disabled: 1 }
     });
-    if (property.type !== 'toggle'){
+    if (property.type !== 'toggle') {
       throw new Meteor.Error('wrong property',
         'This method can only be applied to toggles');
     }
-    if (!property.enabled && !property.disabled){
+    if (!property.enabled && !property.disabled) {
       throw new Meteor.Error('Computed toggle',
         'Can\'t flip a toggle that is computed')
     }
@@ -33,15 +32,15 @@ const flipToggle = new ValidatedMethod({
 
     // Invert the current value, disabled is the canonical store of value
     const currentValue = !property.disabled;
-		CreatureProperties.update(_id, {$set: {
-      enabled: !currentValue,
-      disabled: currentValue,
-    }}, {
-			selector: {type: 'toggle'},
-		});
-
-    // Updating a toggle is likely to change the whole tree, do a full recompute
-    computeCreature(rootCreature._id);
+    CreatureProperties.update(_id, {
+      $set: {
+        enabled: !currentValue,
+        disabled: currentValue,
+        dirty: true,
+      }
+    }, {
+      selector: { type: 'toggle' },
+    });
   },
 });
 

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

@@ -15,9 +15,28 @@ export default function getSlotFillFilter({slot, libraryIds}){
         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 tagsNor = [];
+  let tagsNin = [];
   if (slot.slotTags && slot.slotTags.length){
     tagsOr.push({tags: {$all: slot.slotTags}});
   }
@@ -27,15 +46,15 @@ export default function getSlotFillFilter({slot, libraryIds}){
       if (extra.operation === 'OR'){
         tagsOr.push({tags: {$all: extra.tags}});
       } else if (extra.operation === 'NOT'){
-        tagsNor.push({tags: {$all: extra.tags}});
+        tagsNin.push(...extra.tags);
       }
     });
   }
   if (tagsOr.length){
-    filter.$and.push({$or: tagsOr});
+    filter.$or = tagsOr;
   }
-  if (tagsNor.length){
-    filter.$and.push({$nor: tagsNor});
+  if (tagsNin.length){
+    filter.$and.push({tags: {$nin: tagsNin}});
   }
   if (!filter.$and.length){
     delete filter.$and;

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

@@ -1,7 +1,5 @@
 import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
 import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import '/imports/api/creature/creatureProperties/methods/dealDamage.js';
 import '/imports/api/creature/creatureProperties/methods/duplicateProperty.js';
 import '/imports/api/creature/creatureProperties/methods/equipItem.js';
 import '/imports/api/creature/creatureProperties/methods/insertProperty.js';

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

@@ -5,7 +5,6 @@ import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/ge
 import SimpleSchema from 'simpl-schema';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import { reorderDocs } from '/imports/api/parenting/order.js';
-import computeCreature from '/imports/api/engine/computeCreature.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';
@@ -13,7 +12,7 @@ import { getHighestOrder } from '/imports/api/parenting/order.js';
 
 const insertProperty = new ValidatedMethod({
   name: 'creatureProperties.insert',
-	validate: new SimpleSchema({
+  validate: new SimpleSchema({
     creatureProperty: {
       type: Object,
       blackbox: true,
@@ -25,25 +24,25 @@ const insertProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, parentRef}) {
+  run({ creatureProperty, parentRef }) {
     // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
-		// Check permission to edit
+    // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     creatureProperty.parent = parentRef;
     creatureProperty.ancestors = ancestors;
 
-		return insertPropertyWork({
+    return insertPropertyWork({
       property: creatureProperty,
       creature: rootCreature,
     });
@@ -76,31 +75,31 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, creatureId, tag, tagDefaultName}) {
+  run({ creatureProperty, creatureId, tag, tagDefaultName }) {
     let parentRef = getParentRefByTag(creatureId, tag);
 
-    if (!parentRef){
+    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'};
+      parentRef = { id: creatureId, collection: 'creatures' };
     }
 
     // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
     // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     // Add the folder first if we need to
-    if (insertFolderFirst){
+    if (insertFolderFirst) {
       let order = getHighestOrder({
         collection: CreatureProperties,
         ancestorId: parentRef.id,
@@ -114,7 +113,7 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
         order,
       });
       // Make the folder our new parent
-      let newParentRef = {id, collection: 'creatureProperties'};
+      let newParentRef = { id, collection: 'creatureProperties' };
       ancestors = [parentRef, newParentRef];
       parentRef = newParentRef;
       creatureProperty.order = order + 1;
@@ -123,23 +122,22 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     creatureProperty.parent = parentRef;
     creatureProperty.ancestors = ancestors;
 
-		return insertPropertyWork({
+    return insertPropertyWork({
       property: creatureProperty,
       creature: rootCreature,
     });
   },
 });
 
-export function insertPropertyWork({property, creature}){
+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,
   });
-  // Inserting a creature property invalidates dependencies: full recompute
-  computeCreature(creature._id);
   return _id;
 }
 

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

@@ -5,60 +5,59 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 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 computeCreature from '/imports/api/engine/computeCreature.js';
 import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
 import {
-	setLineageOfDocs,
-	getAncestry,
-	renewDocIds
+  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({
+  name: 'creatureProperties.insertPropertyFromLibraryNode',
+  validate: new SimpleSchema({
     nodeIds: {
       type: Array,
       max: 20,
     },
-		'nodeIds.$': {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-		parentRef: {
-			type: RefSchema,
-		},
+    'nodeIds.$': {
+      type: String,
+      regEx: SimpleSchema.RegEx.Id,
+    },
+    parentRef: {
+      type: RefSchema,
+    },
     order: {
       type: Number,
       optional: true,
     },
-	}).validator(),
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({nodeIds, parentRef, order}) {
-		// get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+  run({ nodeIds, parentRef, order }) {
+    // get the new ancestry for the properties
+    let { parentDoc, ancestors } = getAncestry({ parentRef });
 
-		// Check permission to edit
+    // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
     // {libraryId: hasViewPermission}
     //let libraryPermissionMemoir = {};
     let node;
-		nodeIds.forEach(nodeId => {
+    nodeIds.forEach(nodeId => {
       // TODO: Check library view permission for each node before starting
       node = insertPropertyFromNode(nodeId, ancestors, order);
     });
@@ -71,21 +70,18 @@ const insertPropertyFromLibraryNode = new ValidatedMethod({
       collection: CreatureProperties,
       ancestorId: rootCreature._id,
     });
-
-		// Inserting a creature property invalidates dependencies: full recompute
-    computeCreature(rootCreature._id);
-		// Return the docId of the last property, the inserted root property
-		return rootId;
-	},
+    // Return the docId of the last property, the inserted root property
+    return rootId;
+  },
 });
 
-function insertPropertyFromNode(nodeId, ancestors, order){
+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},
+    removed: { $ne: true },
   });
   if (!node) {
     if (Meteor.isClient) return;
@@ -99,7 +95,7 @@ function insertPropertyFromNode(nodeId, ancestors, order){
   let oldParent = node.parent;
   let nodes = LibraryNodes.find({
     'ancestors.id': nodeId,
-    removed: {$ne: true},
+    removed: { $ne: true },
   }).fetch();
 
   // Convert all references into actual nodes
@@ -122,11 +118,11 @@ function insertPropertyFromNode(nodeId, ancestors, order){
   // Give the docs new IDs without breaking internal references
   renewDocIds({
     docArray: nodes,
-    collectionMap: {'libraryNodes': 'creatureProperties'}
+    collectionMap: { 'libraryNodes': 'creatureProperties' }
   });
 
   // Order the root node
-  if (order === undefined){
+  if (order === undefined) {
     setDocToLastOrder({
       collection: CreatureProperties,
       doc: node,
@@ -135,22 +131,30 @@ function insertPropertyFromNode(nodeId, ancestors, order){
     node.order = order;
   }
 
+  // Mark all nodes as dirty
+  dirtyNodes(nodes);
+
   // Insert the creature properties
   CreatureProperties.batchInsert(nodes);
   return node;
 }
 
-
-function storeLibraryNodeReferences(nodes){
+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){
+function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0) {
   depth += 1;
   // New nodes added this function
   let newNodes = [];
@@ -161,9 +165,9 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
     if (node.type !== 'reference') return true;
 
     // We have gone too deep, keep the reference node as an error
-    if (depth >= 10){
+    if (depth >= 10) {
       if (Meteor.isClient) console.warn('Reference depth limit exceeded');
-      node.cache = {error: 'Reference depth limit exceeded'};
+      node.cache = { error: 'Reference depth limit exceeded' };
       return true;
     }
 
@@ -173,17 +177,17 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
       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()};
+    } 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},
+      removed: { $ne: true },
     }, {
-      sort: {order: 1},
+      sort: { order: 1 },
     }).fetch();
 
     // We are adding the referenced node and its descendants
@@ -191,20 +195,20 @@ function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
 
     // 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,
-		});
+    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'){
+      if (addedNode.type !== 'reference') {
         return true;
       }
       // If this exact reference has already been resolved before, filter it out
-      if (visitedRefs.has(addedNode._id)){
+      if (visitedRefs.has(addedNode._id)) {
         return false;
       } else {
         // Otherwise mark it as visited, and keep it

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

@@ -3,34 +3,30 @@ 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 computeCreature from '/imports/api/engine/computeCreature.js';
 
 const pullFromProperty = new ValidatedMethod({
-	name: 'creatureProperties.pull',
-	validate: null,
+  name: 'creatureProperties.pull',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, itemId}){
+  run({ _id, path, itemId }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-		CreatureProperties.update(_id, {
-			$pull: {[path.join('.')]: {_id: itemId}},
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-
-    // TODO figure out if this method can change deps or not
-    computeCreature(rootCreature._id);
-    // recomputePropertyDependencies(property);
-	}
+    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

@@ -3,20 +3,19 @@ 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 computeCreature from '/imports/api/engine/computeCreature.js';
 import { get } from 'lodash';
 
 const pushToProperty = new ValidatedMethod({
-	name: 'creatureProperties.push',
-	validate: null,
+  name: 'creatureProperties.push',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, value}){
+  run({ _id, path, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
@@ -26,10 +25,10 @@ const pushToProperty = new ValidatedMethod({
     let schema = CreatureProperties.simpleSchema(property);
     let maxCount = schema.get(joinedPath, 'maxCount');
 
-    if (Number.isFinite(maxCount)){
+    if (Number.isFinite(maxCount)) {
       let array = get(property, path);
       let currentCount = array ? array.length : 0;
-      if (currentCount >= maxCount){
+      if (currentCount >= maxCount) {
         throw new Meteor.Error(
           'Array is full',
           `Cannot have more than ${maxCount} values`
@@ -38,15 +37,13 @@ const pushToProperty = new ValidatedMethod({
     }
 
     // Do work
-		CreatureProperties.update(_id, {
-			$push: {[joinedPath]: value},
-		}, {
-			selector: {type: property.type},
-		});
-
-    // TODO figure out if this method can change deps or not
-    computeCreature(rootCreature._id);
-	}
+    CreatureProperties.update(_id, {
+      $push: { [joinedPath]: value },
+      $set: { dirty: true },
+    }, {
+      selector: { type: property.type },
+    });
+  }
 });
 
 export default pushToProperty;

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

@@ -5,30 +5,32 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 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';
-import computeCreature from '/imports/api/engine/computeCreature.js';
 
 const restoreProperty = new ValidatedMethod({
-	name: 'creatureProperties.restore',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'creatureProperties.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id}){
+  run({ _id }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-    restore({_id, collection: CreatureProperties});
-
-    // Changes dependency tree by restoring children
-    computeCreature(rootCreature._id);
-	}
+    restore({
+      _id,
+      collection: CreatureProperties,
+      extraUpdates: {
+        $set: { dirty: true }
+      },
+    });
+  }
 });
 
 export default restoreProperty;

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

@@ -4,7 +4,6 @@ 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';
-import computeCreature from '/imports/api/engine/computeCreature.js';
 
 const selectAmmoItem = new ValidatedMethod({
   name: 'creatureProperties.selectAmmoItem',
@@ -18,34 +17,29 @@ const selectAmmoItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({actionId, itemId, itemConsumedIndex}) {
+  run({ actionId, itemId, itemConsumedIndex }) {
     // Permissions
-		let action = CreatureProperties.findOne(actionId);
+    let action = CreatureProperties.findOne(actionId);
     let rootCreature = getRootCreatureAncestor(action);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Check that this index has a document to edit
     let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed){
+    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){
+    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}
+      $set: { [path]: itemId, dirty: true }
     }, {
       selector: action,
     });
-
-    // Changing the linked item does change the dependency tree
-    // TODO: We can predict exactly which deps will be affected instead of
-    //       recomputing the entire creature
-    computeCreature(rootCreature._id);
   },
 });
 

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

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

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

@@ -3,32 +3,31 @@ 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 computeCreature from '/imports/api/engine/computeCreature.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':
+  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');
-		}
+      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}) {
+  run({ _id, path, value }) {
     // Permission
     let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1}
+      fields: { type: 1, ancestors: 1 }
     });
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
@@ -36,18 +35,14 @@ const updateCreatureProperty = new ValidatedMethod({
     let pathString = path.join('.');
     let modifier;
     // unset empty values
-    if (value === null || value === undefined){
-      modifier = {$unset: {[pathString]: 1}};
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 }, $set: { dirty: true } };
     } else {
-      modifier = {$set: {[pathString]: value}};
+      modifier = { $set: { [pathString]: value, dirty: true } };
     }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
-
-    // Updating a property is likely to change dependencies, do a full recompute
-    // denormalised stats might change, so fetch the creature again
-    computeCreature(rootCreature._id);
+    CreatureProperties.update(_id, modifier, {
+      selector: { type: property.type },
+    });
   },
 });
 

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

@@ -4,9 +4,9 @@ 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);
-		}
-	}
+  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

@@ -8,21 +8,26 @@ import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 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,
-	},
+  //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,
@@ -38,6 +43,11 @@ let CreatureSettingsSchema = new SimpleSchema({
     type: Boolean,
     optional: true,
   },
+  // Hide calculation errors
+  hideCalculationErrors: {
+    type: Boolean,
+    optional: true,
+  },
   // How much each hitDice resets on a long rest
   hitDiceResetMultiplier: {
     type: Number,
@@ -53,73 +63,99 @@ let CreatureSettingsSchema = new SimpleSchema({
 });
 
 let CreatureSchema = new SimpleSchema({
-	// Strings
-	name: {
-		type: String,
-		defaultValue: '',
-		optional: true,
+  // Strings
+  name: {
+    type: String,
+    defaultValue: '',
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	alignment: {
-		type: String,
-		optional: true,
+  },
+  alignment: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	gender: {
-		type: String,
-		optional: true,
+  },
+  gender: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	picture: {
-		type: String,
-		optional: true,
+  },
+  picture: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.url,
-	},
+  },
   avatarPicture: {
     type: String,
     optional: true,
     max: STORAGE_LIMITS.url,
   },
-	// Mechanics
-	deathSave: {
-		type: deathSaveSchema,
-		defaultValue: {},
-	},
+
+  // 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,
-	},
+  '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,
+    type: String,
     optional: true,
-	},
-	type: {
-		type: String,
-		defaultValue: 'pc',
-		allowedValues: ['pc', 'npc', 'monster'],
-	},
+  },
+  type: {
+    type: String,
+    defaultValue: 'pc',
+    allowedValues: ['pc', 'npc', 'monster'],
+  },
   damageMultipliers: {
     type: Object,
-		blackbox: true,
-		defaultValue: {}
+    blackbox: true,
+    defaultValue: {}
+  },
+  variables: {
+    type: Object,
+    blackbox: true,
+    defaultValue: {}
   },
-	variables: {
-		type: Object,
-		blackbox: true,
-		defaultValue: {}
-	},
   computeErrors: {
     type: Array,
     optional: true,
@@ -130,9 +166,10 @@ let CreatureSchema = new SimpleSchema({
   'computeErrors.$.type': {
     type: String,
   },
-  'computeErrors.$.details' : {
+  'computeErrors.$.details': {
     type: Object,
     blackbox: true,
+    optional: true,
   },
 
   // Tabletop
@@ -146,11 +183,11 @@ let CreatureSchema = new SimpleSchema({
     optional: true,
   },
 
-	// Settings
-	settings: {
-		type: CreatureSettingsSchema,
-		defaultValue: {},
-	},
+  // Settings
+  settings: {
+    type: CreatureSettingsSchema,
+    defaultValue: {},
+  },
 });
 
 CreatureSchema.extend(ColorSchema);
@@ -159,8 +196,8 @@ CreatureSchema.extend(SharingSchema);
 Creatures.attachSchema(CreatureSchema);
 
 
-import '/imports/api/creature/creatures/methods/index.js';
-import '/imports/api/engine/actions/doAction.js';
 
 export default Creatures;
 export { CreatureSchema };
+
+import '/imports/api/engine/actions/doAction.js';

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

@@ -10,7 +10,7 @@ export default function defaultCharacterProperties(creatureId){
     {
       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, your sheet will be empty.'},
+      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'},

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

@@ -2,3 +2,4 @@ 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

@@ -1,70 +1,104 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
+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 { getUserTier } from '/imports/api/users/patreon/tiers.js';
 import defaultCharacterProperties from '/imports/api/creature/creatures/defaultCharacterProperties.js';
 import insertPropertyFromLibraryNode from '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
+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',
-
-  validate: null,
-
-  mixins: [RateLimiterMixin],
+  mixins: [RateLimiterMixin, simpleSchemaMixin],
+  schema: CreatureSchema.pick(
+    'name',
+    'gender',
+    'alignment',
+    'allowedLibraries',
+    'allowedLibraryCollections',
+  ).extend({
+    'startingLevel': {
+      type: SimpleSchema.Integer,
+      min: 0,
+    },
+  }),
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
 
-  run() {
-    if (!this.userId) {
+  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');
-    }
-    let tier = getUserTier(this.userId);
-
-    let currentCharacterCount = Creatures.find({
-      owner: this.userId,
-    }, {
-      fields: {_id: 1},
-    }).count();
-
-    if (
-      tier.characterSlots !== -1 &&
-      currentCharacterCount >= tier.characterSlots
-    ){
-      throw new Meteor.Error('Creatures.methods.insert.denied',
-      `You are already at your limit of ${tier.characterSlots} characters`)
+        'You need to be logged in to insert a creature');
     }
 
-		// Create the creature document
+    assertHasCharactersSlots(userId);
+
+    // Create the creature document
     let creatureId = Creatures.insert({
-			owner: this.userId,
-		});
-
-    // Insert the default properties
-    // Not batchInsert because we want the properties cleaned by the schema
-    let baseId;
-    defaultCharacterProperties(creatureId).forEach(prop => {
-      let id = CreatureProperties.insert(prop);
-      if (prop.name === 'Ruleset'){
-        baseId = id;
-      }
+      owner: userId,
+      name,
+      gender,
+      alignment,
+      allowedLibraries,
+      allowedLibraryCollections,
     });
 
-    if (Meteor.isServer){
-      // Insert the 5e ruleset as the default base
-      insertPropertyFromLibraryNode.call({
-        nodeIds: ['iHbhfcg3AL5isSWbw'],
-        parentRef: {id: baseId, collection: 'creatureProperties'},
-        order: 0.5,
+    // Insert experience to get character to starting level
+    if (startingLevel) {
+      insertExperienceForCreature({
+        experience: {
+          name: 'Starting level',
+          levels: startingLevel,
+          creatureId
+        },
+        creatureId,
+        userId,
       });
     }
 
-		return creatureId;
+    // 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

@@ -3,11 +3,13 @@ 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 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});

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

@@ -1,13 +1,15 @@
 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 { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import computeCreature from '/imports/api/engine/computeCreature.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.longRest',
+  name: 'creature.methods.rest',
   validate: new SimpleSchema({
     creatureId: {
       type: String,
@@ -23,94 +25,146 @@ const restCreature = new ValidatedMethod({
     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);
+  run({ creatureId, restType }) {
+    // Get action context
+    const actionContext = new ActionContext(creatureId, [creatureId], this);
+    // Check permissions
+    assertEditPermission(actionContext.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 = {
-      'ancestors.id': creatureId,
-      reset: resetFilter,
-      removed: {$ne: true},
-      inactive: {$ne: true},
-    };
-    // update all attribute's damage
-    filter.type = 'attribute';
-    CreatureProperties.update(filter, {
-      $set: {damage: 0}
-    }, {
-      selector: {type: 'attribute'},
-      multi: true,
+    // 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',
     });
-    // 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 = CreatureProperties.find({
-        'ancestors.id': creatureId,
-        type: 'attribute',
-        attributeType: 'hitDice',
-        removed: {$ne: true},
-        inactive: {$ne: true},
-      }, {
-        fields: {
-          hitDiceSize: 1,
-          damage: 1,
-          value: 1,
-        }
-      }).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.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'},
-        });
-      });
-    }
-    computeCreature(creatureId);
+    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

@@ -1,14 +1,14 @@
 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 { 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 = [
+  validate({ _id, path }) {
+    if (!_id) return false;
+    // Allowed fields
+    let allowedFields = [
       'name',
       'alignment',
       'gender',
@@ -17,26 +17,26 @@ const updateCreature = new ValidatedMethod({
       'color',
       'settings',
     ];
-		if (!allowedFields.includes(path[0])){
-			throw new Meteor.Error('Creatures.methods.update.denied',
-      'This field can\'t be updated using this method');
-		}
+    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);
+  run({ _id, path, value }) {
+    let creature = Creatures.findOne(_id);
     assertEditPermission(creature, this.userId);
-    if (value === undefined || value === null){
+    if (value === undefined || value === null) {
       Creatures.update(_id, {
-        $unset: {[path.join('.')]: 1},
+        $unset: { [path.join('.')]: 1 },
       });
     } else {
       Creatures.update(_id, {
-        $set: {[path.join('.')]: value},
+        $set: { [path.join('.')]: value },
       });
     }
   },

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

@@ -3,23 +3,22 @@ import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import computeCreature from '/imports/api/engine/computeCreature.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,
+  name: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	// The amount of XP this experience gives
-	xp: {
-		type: SimpleSchema.Integer,
-		optional: true,
+  },
+  // The amount of XP this experience gives
+  xp: {
+    type: SimpleSchema.Integer,
+    optional: true,
     min: 0,
-	},
+  },
   // Setting levels instead of value grants whole levels
   levels: {
     type: SimpleSchema.Integer,
@@ -27,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,
@@ -47,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);
-  computeCreature(creatureId);
   return id;
 };
 
@@ -85,15 +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');
+        '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;
@@ -113,29 +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');
+        '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);
-    computeCreature(creatureId);
     return numRemoved;
   },
 });
@@ -153,11 +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');
+        'You need to be logged in to recompute a creature\'s experiences');
     }
     assertEditPermission(creatureId, userId);
 
@@ -166,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
-    }});
-    computeCreature(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/journal/JournalEntry.js

@@ -2,33 +2,33 @@ import SimpleSchema from 'simpl-schema';
 import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
 
 let ExperienceSchema = new SimpleSchema({
-	title: {
-		type: String,
-		optional: true,
+  title: {
+    type: String,
+    optional: true,
     max: STORAGE_LIMITS.name,
-	},
-	// Potentially long description of the event
-	description: {
-		type: String,
-		optional: true,
+  },
+  // 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,
+  },
+  // 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,

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

@@ -1,15 +1,16 @@
 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 { 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){
+if (Meteor.isServer) {
   var sendWebhookAsCreature = require('/imports/server/discord/sendWebhook.js').sendWebhookAsCreature;
 }
 
@@ -24,17 +25,17 @@ let CreatureLogSchema = new SimpleSchema({
   '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();
-			}
-		},
+  // 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,
@@ -49,23 +50,23 @@ let CreatureLogSchema = new SimpleSchema({
 
 CreatureLogs.attachSchema(CreatureLogSchema);
 
-function removeOldLogs(creatureId){
+function removeOldLogs(creatureId) {
   // Find the first log that is over the limit
   let firstExpiredLog = CreatureLogs.find({
     creatureId
   }, {
-    sort: {date: -1},
+    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},
+    date: { $lte: firstExpiredLog.date },
   });
 }
 
-function logToMessageData(log){
+function logToMessageData(log) {
   let embed = {
     fields: [],
   };
@@ -77,8 +78,8 @@ function logToMessageData(log){
   return { embeds: [embed] };
 }
 
-function logWebhook({log, creature}){
-  if (Meteor.isServer){
+function logWebhook({ log, creature }) {
+  if (Meteor.isServer) {
     sendWebhookAsCreature({
       creature,
       data: logToMessageData(log),
@@ -93,47 +94,49 @@ const insertCreatureLog = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-	validate: new SimpleSchema({
-		log: CreatureLogSchema.omit('date'),
-	}).validator(),
-  run({log}){
+  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,
-    }});
+    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})
+    let id = insertCreatureLogWork({ log, creature, method: this })
     return id;
   },
 });
 
-export function insertCreatureLogWork({log, creature, method}){
+export function insertCreatureLogWork({ log, creature, method }) {
   // Build the new log
-  if (typeof log === 'string'){
-    log = {content: [{value: 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){
+  if (Meteor.isServer) {
     method?.unblock();
     removeOldLogs(creature._id);
-    logWebhook({log, creature});
+    logWebhook({ log, creature });
   }
   return id;
 }
 
 
-function equalIgnoringWhitespace(a, b){
+function equalIgnoringWhitespace(a, b) {
   if (typeof a !== 'string' || typeof b !== 'string') return a === b;
-  return a.replace(/\s/g,'') === b.replace(/\s/g, '');
+  return a.replace(/\s/g, '') === b.replace(/\s/g, '');
 }
 
 const logRoll = new ValidatedMethod({
@@ -143,39 +146,41 @@ const logRoll = new ValidatedMethod({
     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: {
-      variables: 1,
-      readers: 1,
-      writers: 1,
-      owner: 1,
-      'settings.discordWebhook': 1,
-      name: 1,
-      avatarPicture: 1,
-    }});
+  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){
+    } catch (e) {
       let error = prettifyParseError(e);
-      logContent.push({name: 'Parse Error', value: error});
+      logContent.push({ name: 'Parse Error', value: error });
     }
     if (parsedResult) try {
       let {
         result: compiled,
         context
-      } = resolve('compile', parsedResult, creature.variables);
+      } = resolve('compile', parsedResult, variables);
       const compiledString = toString(compiled);
       if (!equalIgnoringWhitespace(compiledString, roll)) logContent.push({
         value: roll
@@ -183,19 +188,19 @@ const logRoll = new ValidatedMethod({
       logContent.push({
         value: compiledString
       });
-      let {result: rolled} = resolve('roll', compiled, creature.variables, context);
+      let { result: rolled } = resolve('roll', compiled, variables, context);
       let rolledString = toString(rolled);
       if (rolledString !== compiledString) logContent.push({
         value: rolledString
       });
-      let {result} = resolve('reduce', rolled, creature.variables, context);
+      let { result } = resolve('reduce', rolled, variables, context);
       let resultString = toString(result);
       if (resultString !== rolledString) logContent.push({
         value: resultString
       });
-    } catch (e){
+    } catch (e) {
       console.error(e);
-      logContent = [{name: 'Calculation error'}];
+      logContent = [{ name: 'Calculation error' }];
     }
     const log = {
       content: logContent,
@@ -203,11 +208,11 @@ const logRoll = new ValidatedMethod({
       date: new Date(),
     };
 
-    let id = insertCreatureLogWork({log, creature, method: this});
+    let id = insertCreatureLogWork({ log, creature, method: this });
 
     return id;
   },
 });
 
 export default CreatureLogs;
-export { CreatureLogSchema, insertCreatureLog, logRoll};
+export { CreatureLogSchema, insertCreatureLog, logRoll, PER_CREATURE_LOG_LIMIT };

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

@@ -2,7 +2,9 @@ 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';
@@ -13,7 +15,9 @@ const applyPropertyByType = {
   adjustment,
   branch,
   buff,
+  buffRemover,
   damage,
+  folder,
   note,
   roll,
   savingThrow,
@@ -21,7 +25,7 @@ const applyPropertyByType = {
   toggle,
 };
 
-export default function applyProperty(node, opts, ...rest){
-  opts.scope[`#${node.node.type}`] = node.node;
-  return applyPropertyByType[node.node.type]?.(node, opts, ...rest);
+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

@@ -5,54 +5,60 @@ 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/ui/utility/numberToSignedString.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, {creature, targets, scope, log}){
+export default function applyAction(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
-  if (prop.target === 'self') targets = [creature];
+  if (prop.target === 'self') actionContext.targets = [actionContext.creature];
+  const targets = actionContext.targets;
 
-  // Log the name and description
+  // Log the name and summary
   let content = { name: prop.name };
-  if (prop.description?.text){
-    recalculateInlineCalculations(prop.description, scope, log);
-    content.value = prop.description.value;
-  }
-  if (content.name || content.value){
-    log.content.push(content);
+  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, log, scope});
+  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){
+  if (attack && attack.calculation) {
+    if (targets.length) {
       targets.forEach(target => {
-        applyAttackToTarget({attack, target, scope, log});
+        applyAttackToTarget({ attack, target, actionContext });
         // Apply the children, but only to the current target
-        applyChildren(node, {targets: [target], scope, log});
+        actionContext.targets = [target];
+        applyChildren(node, actionContext);
       });
     } else {
-      applyAttackWithoutTarget({attack, scope, log});
-      applyChildren(node, {creature, targets, scope, log});
+      applyAttackWithoutTarget({ attack, actionContext });
+      applyChildren(node, actionContext);
     }
   } else {
-    applyChildren(node, {creature, targets, scope, log});
+    applyChildren(node, actionContext);
+  }
+  if (prop.actionType === 'event' && prop.variableName) {
+    resetProperties(actionContext.creature._id, prop.variableName, actionContext);
   }
 }
 
-function applyAttackWithoutTarget({attack, scope, log}){
-  delete scope['$attackHit'];
-  delete scope['$attackMiss'];
-  delete scope['$criticalHit'];
-  delete scope['$criticalMiss'];
-  delete scope['$attackRoll'];
-
-  recalculateCalculation(attack, scope, log);
+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,
@@ -60,19 +66,27 @@ function applyAttackWithoutTarget({attack, scope, log}){
     criticalMiss,
   } = rollAttack(attack, scope);
   let name = criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit';
-  if (scope['$attackAdvantage'] === 1){
+  if (scope['$attackAdvantage'] === 1) {
     name += ' (Advantage)';
-  } else if(scope['$attackAdvantage'] === -1){
+  } else if (scope['$attackAdvantage'] === -1) {
     name += ' (Disadvantage)';
   }
-  log.content.push({
+  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, scope, log}){
+function applyAttackToTarget({ attack, target, actionContext }) {
+  const scope = actionContext.scope;
   delete scope['$attackHit'];
   delete scope['$attackMiss'];
   delete scope['$criticalHit'];
@@ -80,7 +94,7 @@ function applyAttackToTarget({attack, target, scope, log}){
   delete scope['$attackDiceRoll'];
   delete scope['$attackRoll'];
 
-  recalculateCalculation(attack, scope, log);
+  recalculateCalculation(attack, actionContext);
 
   let {
     resultPrefix,
@@ -89,34 +103,34 @@ function applyAttackToTarget({attack, target, scope, log}){
     criticalMiss,
   } = rollAttack(attack, scope);
 
-  if (target.variables.armor){
+  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){
+        result > armor ? 'Hit!' : 'Miss!';
+    if (scope['$attackAdvantage'] === 1) {
       name += ' (Advantage)';
-    } else if(scope['$attackAdvantage'] === -1){
+    } else if (scope['$attackAdvantage'] === -1) {
       name += ' (Disadvantage)';
     }
 
-    log.content.push({
+    actionContext.addLog({
       name,
       value: `${resultPrefix}\n**${result}**`,
       inline: true,
     });
-    if ((result > armor) || (criticalHit)){
-      scope['$attackHit'] = true;
+    if (criticalMiss || result < armor) {
+      scope['$attackMiss'] = { value: true };
     } else {
-      scope['$attackMiss'] = true;
+      scope['$attackHit'] = { value: true };
     }
   } else {
-    log.content.push({
+    actionContext.addLog({
       name: 'Error',
-      value:'Target has no `armor`',
+      value: 'Target has no `armor`',
     });
-    log.content.push({
+    actionContext.addLog({
       name: criticalHit ? 'Critical Hit!' : criticalMiss ? 'Critical Miss!' : 'To Hit',
       value: `${resultPrefix}\n**${result}**`,
       inline: true,
@@ -124,10 +138,10 @@ function applyAttackToTarget({attack, target, scope, log}){
   }
 }
 
-function rollAttack(attack, scope){
+function rollAttack(attack, scope) {
   const rollModifierText = numberToSignedString(attack.value, true);
   let value, resultPrefix;
-  if (attack.advantage === 1 || scope['$attackAdvantage']){
+  if (scope['$attackAdvantage'] === 1) {
     const [a, b] = rollDice(2, 20);
     if (a >= b) {
       value = a;
@@ -136,7 +150,7 @@ function rollAttack(attack, scope){
       value = b;
       resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
     }
-  } else if (attack.advantage === -1 || scope['$attackDisadvantage']){
+  } else if (scope['$attackAdvantage'] === -1) {
     const [a, b] = rollDice(2, 20);
     if (a <= b) {
       value = a;
@@ -149,48 +163,45 @@ function rollAttack(attack, scope){
     value = rollDice(1, 20)[0];
     resultPrefix = `1d20 [${value}] ${rollModifierText}`
   }
-  scope['$attackRoll'] = {value};
+  scope['$attackDiceRoll'] = { value };
   const result = value + attack.value;
-  const {criticalHit, criticalMiss} = applyCrits(value, scope);
-  return {resultPrefix, result, value, criticalHit, criticalMiss};
+  scope['$attackRoll'] = { value: result };
+  const { criticalHit, criticalMiss } = applyCrits(value, scope);
+  return { resultPrefix, result, value, criticalHit, criticalMiss };
 }
 
-function applyCrits(value, scope){
+function applyCrits(value, scope) {
   let criticalHitTarget = scope.criticalHitTarget?.value || 20;
   let criticalHit = value >= criticalHitTarget;
   let criticalMiss;
-  if (criticalHit){
-    scope['$criticalHit'] = {value: true};
-    scope['$attackHit'] = {value: true};
+  if (criticalHit) {
+    scope['$criticalHit'] = { value: true };
   } else {
     criticalMiss = value === 1;
-    if (criticalMiss){
-      scope['$criticalMiss'] = 1;
-      scope['$attackMiss'] = {value: true};
-    } else {
-      // Untargeted attacks hit by default
-      scope['$attackHit'] = {value: true}
+    if (criticalMiss) {
+      scope['$criticalMiss'] = { value: true };
     }
   }
-  return {criticalHit, criticalMiss};
+  return { criticalHit, criticalMiss };
 }
 
-function applyChildren(node, args){
-  node.children.forEach(child => applyProperty(child, args));
+function applyChildren(node, actionContext) {
+  applyNodeTriggers(node, 'after', actionContext);
+  node.children.forEach(child => applyProperty(child, actionContext));
 }
 
-function spendResources({prop, log, scope}){
+function spendResources(prop, actionContext) {
   // Check Uses
-  if (prop.usesLeft <= 0){
-    log.content.push({
+  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){
-    log.content.push({
+  if (prop.insufficientResources) {
+    if (!prop.silent) actionContext.addLog({
       name: 'Error',
       value: 'This creature doesn\'t have sufficient resources to perform this action',
     });
@@ -202,15 +213,15 @@ function spendResources({prop, log, scope}){
   let gainLog = [];
   try {
     prop.resources.itemsConsumed.forEach(itemConsumed => {
-      recalculateCalculation(itemConsumed.quantity, scope, log);
-      if (!itemConsumed.itemId){
+      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){
+      if (!item || item.ancestors[0].id !== prop.ancestors[0].id) {
         throw 'The prop\'s ammo was not found on the creature';
       }
-      if (!item.equipped){
+      if (!item.equipped) {
         throw 'The selected ammo is not equipped';
       }
       if (
@@ -223,17 +234,17 @@ function spendResources({prop, log, scope}){
         value: itemConsumed.quantity.value,
       });
       let logName = item.name;
-      if (itemConsumed.quantity.value > 1 || itemConsumed.quantity.value < -1){
+      if (itemConsumed.quantity.value > 1 || itemConsumed.quantity.value < -1) {
         logName = item.plural || logName;
       }
-      if (itemConsumed.quantity.value > 0){
+      if (itemConsumed.quantity.value > 0) {
         spendLog.push(logName + ': ' + itemConsumed.quantity.value);
-      } else if (itemConsumed.quantity.value < 0){
+      } else if (itemConsumed.quantity.value < 0) {
         gainLog.push(logName + ': ' + -itemConsumed.quantity.value);
       }
     });
-  } catch (e){
-    log.content.push({
+  } catch (e) {
+    actionContext.addLog({
       name: 'Error',
       value: e,
     });
@@ -245,13 +256,13 @@ function spendResources({prop, log, scope}){
   itemQuantityAdjustments.forEach(adjustQuantityWork);
 
   // Use uses
-  if (prop.usesLeft){
+  if (prop.usesLeft) {
     CreatureProperties.update(prop._id, {
-      $inc: {usesUsed: 1}
+      $inc: { usesUsed: 1 }
     }, {
       selector: prop
     });
-    log.content.push({
+    if (!prop.silent) actionContext.addLog({
       name: 'Uses left',
       value: prop.usesLeft - 1,
       inline: true,
@@ -260,33 +271,34 @@ function spendResources({prop, log, scope}){
 
   // Damage stats
   prop.resources.attributesConsumed.forEach(attConsumed => {
-    recalculateCalculation(attConsumed.quantity, scope, log);
+    recalculateCalculation(attConsumed.quantity, actionContext);
 
     if (!attConsumed.quantity?.value) return;
-    let stat = scope[attConsumed.variableName];
-    if (!stat){
+    let stat = actionContext.scope[attConsumed.variableName];
+    if (!stat) {
       spendLog.push(stat.name + ': ' + ' not found');
       return;
     }
     damagePropertyWork({
-      property: stat,
+      prop: stat,
       operation: 'increment',
       value: attConsumed.quantity.value,
+      actionContext,
     });
-    if (attConsumed.quantity.value > 0){
+    if (attConsumed.quantity.value > 0) {
       spendLog.push(stat.name + ': ' + attConsumed.quantity.value);
-    } else if (attConsumed.quantity.value < 0){
+    } else if (attConsumed.quantity.value < 0) {
       gainLog.push(stat.name + ': ' + -attConsumed.quantity.value);
     }
   });
 
   // Log all the spending
-  if (gainLog.length) log.content.push({
+  if (gainLog.length && !prop.silent) actionContext.addLog({
     name: 'Gained',
     value: gainLog.join('\n'),
     inline: true,
   });
-  if (spendLog.length) log.content.push({
+  if (spendLog.length && !prop.silent) actionContext.addLog({
     name: 'Spent',
     value: spendLog.join('\n'),
     inline: true,

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

@@ -1,41 +1,42 @@
 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, {
-  creature, targets, scope, log
-}){
+export default function applyAdjustment(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
-  const damageTargets = prop.target === 'self' ? [creature] : targets;
+  const damageTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
 
   if (!prop.amount) {
-    return applyChildren(node, {creature, targets, scope, log});
+    return applyChildren(node, actionContext);
   }
 
   // Evaluate the amount
-  recalculateCalculation(prop.amount, scope, log);
+  recalculateCalculation(prop.amount, actionContext);
 
   const value = +prop.amount.value;
   if (!isFinite(value)) {
-    return applyChildren(node, {creature, targets, scope, log});
+    return applyChildren(node, actionContext);
   }
 
   if (damageTargets?.length) {
     damageTargets.forEach(target => {
       let stat = target.variables[prop.stat];
       if (!stat?.type) {
-        log.content.push({
+        if (!prop.silent) actionContext.addLog({
           name: 'Error',
           value: `Could not apply attribute damage, creature does not have \`${prop.stat}\` set`
         });
-        return applyChildren(node, {creature, targets, scope, log});
+        return applyChildren(node, actionContext);
       }
       damagePropertyWork({
-        property: stat,
+        prop: stat,
         operation: prop.operation,
-        value: value,
+        value,
+        actionContext,
       });
-      log.content.push({
+      if (!prop.silent) actionContext.addLog({
         name: 'Attribute damage',
         value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
         ` ${value}`,
@@ -43,7 +44,7 @@ export default function applyAdjustment(node, {
       });
     });
   } else {
-    log.content.push({
+    if (!prop.silent) actionContext.addLog({
       name: 'Attribute damage',
       value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
       ` ${value}`,
@@ -51,9 +52,10 @@ export default function applyAdjustment(node, {
     });
   }
 
-  return applyChildren(node, {creature, targets, scope, log});
+  return applyChildren(node, actionContext);
 }
 
-function applyChildren(node, args){
-  node.children.forEach(child => applyProperty(child, args));
+function applyChildren(node, actionContext){
+  applyNodeTriggers(node, 'after', actionContext);
+  node.children.forEach(child => applyProperty(child, actionContext));
 }

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

@@ -1,47 +1,76 @@
 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, {
-  creature, targets, scope, log
-}){
+export default function applyBranch(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
   const applyChildren = function(){
-    node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+    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, scope, log);
+      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) applyChildren();
+      if (scope['$attackHit']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On hit**'});
+        applyChildren();
+      }
       break;
     case 'miss':
-      if (scope['$attackMiss']?.value) applyChildren();
+      if (scope['$attackMiss']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On miss**'});
+        applyChildren();
+      }
       break;
     case 'failedSave':
-      if (scope['$saveFailed']?.value) applyChildren();
+      if (scope['$saveFailed']?.value){
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On failed save**'});
+        applyChildren();
+      }
       break;
     case 'successfulSave':
-      if (scope['$saveSucceeded']?.value) applyChildren();
+      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;
-        applyProperty(node.children[index], {
-          creature, targets, scope, log
-        });
+        applyNodeTriggers(node, 'after', actionContext);
+        applyProperty(node.children[index], actionContext);
       }
       break;
     case 'eachTarget':
-      if (targets.length){
+      if (targets.length) {
         targets.forEach(target => {
-          node.children.forEach(child => applyProperty(child, {
-            creature, targets: [target], scope, log
-          }));
+          applyNodeTriggers(node, 'after', actionContext);
+          actionContext.targets = [target]
+          node.children.forEach(child => applyProperty(child, actionContext));
         });
       } else {
         applyChildren();

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

@@ -1,8 +1,8 @@
 import {
-	setLineageOfDocs,
-	renewDocIds
+  setLineageOfDocs,
+  renewDocIds
 } from '/imports/api/parenting/parenting.js';
-import {setDocToLastOrder} from '/imports/api/parenting/order.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';
@@ -10,36 +10,76 @@ 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, {creature, targets, scope, log}){
+export default function applyBuff(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
-  let buffTargets = prop.target === 'self' ? [creature] : targets;
+  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){
+  function addChildrenToPropList(children, { skipCrystalize } = {}) {
     children.forEach(child => {
+      if (skipCrystalize) child.node._skipCrystalize = true;
       propList.push(child.node);
-      addChildrenToPropList(child.children);
+      // recursively add the child's children, but don't crystalize nested buffs
+      addChildrenToPropList(child.children, {
+        skipCrystalize: skipCrystalize || child.node.type === 'buff'
+      });
     });
   }
   addChildrenToPropList(node.children);
-  crystalizeVariables({propList, scope, log});
+  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}];
+function copyNodeListToTarget(propList, target, oldParent) {
+  let ancestry = [{ collection: 'creatures', id: target._id }];
   setLineageOfDocs({
     docArray: propList,
     newAncestry: ancestry,
@@ -59,9 +99,14 @@ function copyNodeListToTarget(propList, target, oldParent){
  * Replaces all variables with their resolved values
  * except variables of the form `$target.thing.total` become `thing.total`
  */
-function crystalizeVariables({propList, scope, log}){
+function crystalizeVariables({ propList, actionContext }) {
   propList.forEach(prop => {
-    computedSchemas[prop.type].computedFields().forEach( calcKey => {
+    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;
@@ -71,16 +116,16 @@ function crystalizeVariables({propList, scope, log}){
             node.parseType !== 'accessor' && node.parseType !== 'symbol'
           ) return node;
           // Handle variables
-          if (node.name === '$target'){
+          if (node.name === '$target') {
             // strip $target
-            if (node.parseType === 'accessor'){
+            if (node.parseType === 'accessor') {
               node.name = node.path.shift();
-              if (!node.path.length){
-                return symbol.create({name: node.name})
+              if (!node.path.length) {
+                return symbol.create({ name: node.name })
               }
             } else {
               // Can't strip symbols
-              log.content.push({
+              actionContext.addLog({
                 name: 'Error',
                 value: 'Variable `$target` should not be used without a property: $target.property',
               });
@@ -88,8 +133,8 @@ function crystalizeVariables({propList, scope, log}){
             return node;
           } else {
             // Resolve all other variables
-            const {result, context} = resolve('reduce', node, scope);
-            logErrors(context.errors, log);
+            const { result, context } = resolve('reduce', node, actionContext.scope);
+            logErrors(context.errors, actionContext);
             return result;
           }
         });
@@ -97,5 +142,36 @@ function crystalizeVariables({propList, scope, log}){
         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

@@ -1,92 +1,114 @@
+import { some, intersection, difference, remove, includes } from 'lodash';
 import applyProperty from '../applyProperty.js';
-import { dealDamageWork } from '/imports/api/creature/creatureProperties/methods/dealDamage.js';
-import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.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, {
-  creature, targets, scope, log
-}){
-  const applyChildren = function(){
-    node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+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;
+  if (!prop.amount?.parseNode) return;
 
   // Choose target
-
-  let damageTargets = prop.target === 'self' ? [creature] : targets;
+  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},
+    options: { doubleRolls: criticalHit },
   });
 
   // Gather all the lines we need to log into an array
   const logValue = [];
   const logName = prop.damageType === 'healing' ? 'Healing' : 'Damage';
 
-  // Compile the dice roll and store that string first
-  // const {result: compiled} = resolve('compiled', prop.amount.parseNode, scope, context);
-  // logValue.push(toString(compiled));
-  // logErrors(context.errors, log);
-
   // roll the dice only and store that string
-  applyEffectsToCalculationParseNode(prop.amount, log);
-  const {result: rolled} = resolve('roll', prop.amount.parseNode, scope, context);
-  logValue.push(toString(rolled));
-  logErrors(context.errors, log);
+  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, log);
+  const { result: reduced } = resolve('reduce', rolled, scope, context);
+  logErrors(context.errors, actionContext);
 
   // Store the result
-  if (reduced.parseType === 'constant'){
+  if (reduced.parseType === 'constant') {
     prop.amount.value = reduced.value;
-  } else if (reduced.parseType === 'error'){
+  } else if (reduced.parseType === 'error') {
     prop.amount.value = null;
   } else {
     prop.amount.value = toString(reduced);
   }
-
-  const damage = +reduced.value;
+  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)){
+  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 ': '');
+    (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 = dealDamageWork({
-        creature: target,
+      let damageDealt = dealDamage({
+        target,
         damageType: prop.damageType,
         amount: damage,
+        actionContext
       });
 
       // Log the damage done
-      if (target._id === creature._id){
+      if (target._id === actionContext.creature._id) {
         // Target is same as self, log damage as such
         logValue.push(`**${damageDealt}** ${suffix}  to self`);
       } else {
@@ -107,10 +129,126 @@ export default function applyDamage(node, {
     // There are no targets, just log the result
     logValue.push(`**${damage}** ${suffix}`);
   }
-  log.content.push({
+  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

@@ -1,25 +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, {creature, targets, scope, log}){
+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, scope, log);
+    recalculateInlineCalculations(prop.summary, actionContext);
     content.value = prop.summary.value;
   }
   if (content.name || content.value){
-    log.content.push(content);
+    actionContext.addLog(content);
   }
   // Log description
   if (prop.description?.text){
-    recalculateInlineCalculations(prop.description, scope, log);
-    log.content.push({value: prop.description.value});
+    recalculateInlineCalculations(prop.description, actionContext);
+    actionContext.addLog({value: prop.description.value});
   }
+  // Apply triggers
+  applyNodeTriggers(node, 'after', actionContext);
   // Apply children
-  node.children.forEach(child => applyProperty(child, {
-    creature, targets, scope, log
-  }));
+  node.children.forEach(child => applyProperty(child, actionContext));
 }

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

@@ -1,22 +1,61 @@
 import applyProperty from '../applyProperty.js';
-import recalculateCalculation from './shared/recalculateCalculation.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, {creature, targets, scope, log}){
+export default function applyRoll(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
 
-  if (prop.roll?.calculation){
-    recalculateCalculation(prop.roll, scope, log);
+  const applyChildren = function(){
+    applyNodeTriggers(node, 'after', actionContext);
+    node.children.forEach(child => applyProperty(child, actionContext));
+  };
 
-    if (isFinite(prop.roll.value)){
-      scope[prop.variableName] = prop.roll.value;
+  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,
+      });
     }
-    log.content.push({
-      name: prop.name,
-      value: prop.variableName + ' = ' + prop.roll.calculation + ' = ' + prop.roll.value,
-      inline: true,
-    });
   }
-  return node.children.forEach(child => applyProperty(child, {
-    creature, targets, scope, log
-  }));
+  return applyChildren();
 }

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

@@ -1,91 +1,107 @@
 import rollDice from '/imports/parser/rollDice.js';
 import recalculateCalculation from './shared/recalculateCalculation.js';
 import applyProperty from '../applyProperty.js';
-import numberToSignedString from '/imports/ui/utility/numberToSignedString.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, {creature, targets, scope, log}){
+export default function applySavingThrow(node, actionContext) {
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
 
-  let saveTargets = prop.target === 'self' ? [creature] : targets;
+  let saveTargets = prop.target === 'self' ? [actionContext.creature] : actionContext.targets;
 
-  recalculateCalculation(prop.dc, scope, log);
+  recalculateCalculation(prop.dc, actionContext);
 
   const dc = (prop.dc?.value);
-  if (!isFinite(dc)){
-    log.content.push({
+  if (!isFinite(dc)) {
+    actionContext.addLog({
       name: 'Error',
       value: 'Saving throw requires a DC',
     });
-    return node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+    return node.children.forEach(child => applyProperty(child, actionContext));
   }
-  log.content.push({
+  if (!prop.silent) actionContext.addLog({
     name: prop.name,
-    value: ' DC ' + dc,
+    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(){
-      node.children.forEach(child => applyProperty(child, {
-        creature, targets: [target], scope, log
-      }));
+    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){
-      log.content.push({
+    if (!save) {
+      actionContext.addLog({
         name: 'Saving throw error',
         value: 'No saving throw found: ' + prop.stat,
       });
       return applyChildren();
     }
 
-    const rollModifierText = numberToSignedString(save.value, true);
+    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){
+    if (save.advantage === 1) {
       const [a, b] = rollDice(2, 20);
       if (a >= b) {
         value = a;
-        resultPrefix = `Advantage: 1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
+        resultPrefix = `Advantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
       } else {
         value = b;
-        resultPrefix = `Advantage: 1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
+        resultPrefix = `Advantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
       }
-    } else if (save.advantage === -1){
+    } else if (save.advantage === -1) {
       const [a, b] = rollDice(2, 20);
       if (a <= b) {
         value = a;
-        resultPrefix = `Disadvantage: 1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText} = `;
+        resultPrefix = `Disadvantage\n1d20 [ ${a}, ~~${b}~~ ] ${rollModifierText}`;
       } else {
         value = b;
-        resultPrefix = `Disadvantage: 1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
+        resultPrefix = `Disadvantage\n1d20 [ ~~${a}~~, ${b} ] ${rollModifierText}`;
       }
     } else {
       values = rollDice(1, 20);
       value = values[0];
-      resultPrefix = `1d20 [ ${value} ] ${rollModifierText} = `
+      resultPrefix = `1d20 [ ${value} ] ${rollModifierText}`
     }
-    scope['$saveDiceRoll'] = {value};
-    const result = value + save.value || 0;
-    scope['$saveRoll'] = {value: result};
+    scope['$saveDiceRoll'] = { value };
+    const result = value + rollModifier || 0;
+    scope['$saveRoll'] = { value: result };
     const saveSuccess = result >= dc;
-    if (saveSuccess){
-      scope['$saveSucceeded'] = {value: true};
+    if (saveSuccess) {
+      scope['$saveSucceeded'] = { value: true };
     } else {
-      scope['$saveFailed'] = {value: true};
+      scope['$saveFailed'] = { value: true };
     }
-    log.content.push({
-      name: 'Save',
-      value: resultPrefix + result + (saveSuccess ? 'Passed' : 'Failed'),
+    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

@@ -1,14 +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, {
-  creature, targets, scope, log
-}){
+export default function applyToggle(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
-  recalculateCalculation(prop.condition, scope, log);
+  recalculateCalculation(prop.condition, actionContext);
   if (prop.condition?.value) {
-    return node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+    applyNodeTriggers(node, 'after', actionContext);
+    return node.children.forEach(child => applyProperty(child, actionContext));
   }
 }

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

@@ -2,7 +2,7 @@ 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, log){
+export default function applyEffectsToCalculationParseNode(calcObj, actionContext){
   if (!calcObj.effects) return;
   calcObj.effects.forEach(effect => {
     if (effect.operation !== 'add') return;
@@ -18,7 +18,7 @@ export default function applyEffectsToCalculationParseNode(calcObj, log){
         fn: 'add'
       });
     } catch (e){
-      logErrors([e], log)
+      logErrors([e], actionContext)
     }
   });
 }

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

@@ -1,7 +1,7 @@
-export default function logErrors(errors, log){
+export default function logErrors(errors, actionContext){
   errors?.forEach(error => {
     if (error.type !== 'info'){
-      log.content.push({name: 'Error', value: error.message});
+      actionContext.addLog({name: 'Error', value: error.message});
     }
   });
 }

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

@@ -2,10 +2,10 @@ import evaluateCalculation from '/imports/api/engine/computation/utility/evaluat
 import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
 import logErrors from './logErrors.js';
 
-export default function recalculateCalculation(calc, scope, log, context){
+export default function recalculateCalculation(calc, actionContext, context){
   if (!calc?.parseNode) return;
   calc._parseLevel = 'reduce';
-  applyEffectsToCalculationParseNode(calc, log);
-  evaluateCalculation(calc, scope, context);
-  logErrors(calc.errors, log);
+  applyEffectsToCalculationParseNode(calc, actionContext);
+  evaluateCalculation(calc, actionContext.scope, context);
+  logErrors(calc.errors, actionContext);
 }

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

@@ -1,12 +1,12 @@
 import embedInlineCalculations from '/imports/api/engine/computation/utility/embedInlineCalculations.js';
 import recalculateCalculation from './recalculateCalculation.js'
 
-export default function recalculateInlineCalculations(inlineCalcObj, scope, log){
+export default function recalculateInlineCalculations(inlineCalcObj, actionContext){
   // Skip if there are no calculations
   if (!inlineCalcObj?.inlineCalculations?.length) return;
   // Recalculate each calculation with the current scope
   inlineCalcObj.inlineCalculations.forEach(calc => {
-    recalculateCalculation(calc, scope, log);
+    recalculateCalculation(calc, actionContext);
   });
   // Embed the new calculated values
   embedInlineCalculations(inlineCalcObj);

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

@@ -0,0 +1,111 @@
+import recalculateCalculation from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateCalculation.js';
+import recalculateInlineCalculations from '/imports/api/engine/actions/applyPropertyByType/shared/recalculateInlineCalculations.js';
+import { getPropertyDecendants } from '/imports/api/engine/loadCreatures.js';
+import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
+import applyProperty from '/imports/api/engine/actions/applyProperty.js';
+import { difference, intersection } from 'lodash';
+import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
+
+export function applyNodeTriggers(node, timing, actionContext) {
+  const prop = node.node;
+  const type = prop.type;
+  const triggers = actionContext.triggers?.doActionProperty?.[type]?.[timing];
+  if (triggers) {
+    triggers.forEach(trigger => {
+      applyTrigger(trigger, prop, actionContext);
+    });
+  }
+}
+
+export function applyTriggers(triggers = [], prop, actionContext) {
+  // Apply the triggers
+  triggers.forEach(trigger => {
+    applyTrigger(trigger, prop, actionContext)
+  });
+}
+
+export function applyTrigger(trigger, prop, actionContext) {
+  // If there is a prop we are applying the trigger from,
+  // don't fire if the tags don't match
+  if (prop && !triggerMatchTags(trigger, prop)) {
+    return;
+  }
+
+  // Prevent trigger from firing if it's inactive
+  if (trigger.inactive) {
+    return;
+  }
+  
+  // Prevent triggers from firing if their condition is false
+  if (trigger.condition?.parseNode) {
+    recalculateCalculation(trigger.condition, actionContext);
+    if (!trigger.condition.value) return;
+  }
+
+  // Prevent triggers from firing themselves in a loop
+  if (trigger.firing) {
+    /*
+    log.content.push({
+      name: trigger.name || 'Trigger',
+      value: 'Trigger can\'t fire itself',
+      inline: true,
+    });
+    */
+    return;
+  }
+  trigger.firing = true;
+
+  // Fire the trigger
+  const content = {
+    name: trigger.name || 'Trigger',
+    value: trigger.description,
+    inline: false,
+  }
+  if (trigger.description?.text){
+    recalculateInlineCalculations(trigger.description, actionContext);
+    content.value = trigger.description.value;
+  }
+  if(!trigger.silent) actionContext.addLog(content);
+
+  // Get all the trigger's properties and apply them
+  const properties = getPropertyDecendants(actionContext.creature._id, trigger._id);
+  properties.sort((a, b) => a.order - b.order);
+  const propertyForest = nodeArrayToTree(properties);
+  propertyForest.forEach(node => {
+    applyProperty(node, actionContext);
+  });
+
+  trigger.firing = false;
+}
+
+function triggerMatchTags(trigger, prop) {
+  let matched = false;
+  const propTags = getEffectivePropTags(prop);
+  // Check the target tags
+  if (
+    !trigger.targetTags?.length ||
+    difference(trigger.targetTags, propTags).length === 0
+  ) {
+    matched = true;
+  }
+  // Check the extra tags
+  trigger.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/doAction.js

@@ -1,14 +1,15 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
 import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
+import {
+  getProperyAncestors, getPropertyDecendants
+} from '/imports/api/engine/loadCreatures.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import applyProperty from './applyProperty.js';
-import computeCreature from '/imports/api/engine/computeCreature.js';
+import ActionContext from '/imports/api/engine/actions/ActionContext.js';
 
 const doAction = new ValidatedMethod({
   name: 'creatureProperties.doAction',
@@ -35,51 +36,33 @@ const doAction = new ValidatedMethod({
     numRequests: 10,
     timeInterval: 5000,
   },
-  run({actionId, targetIds = [], scope}) {
+  run({ actionId, targetIds = [], scope }) {
+    // Get action context
     let action = CreatureProperties.findOne(actionId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(action);
+    const creatureId = action.ancestors[0].id;
+    const actionContext = new ActionContext(creatureId, targetIds, this);
 
-    assertEditPermission(creature, this.userId);
-
-    // Get all the targets and make sure we can edit them
-    let targets = [];
-    targetIds.forEach(targetId => {
-      let target = Creatures.findOne(targetId);
+    // Check permissions
+    assertEditPermission(actionContext.creature, this.userId);
+    actionContext.targets.forEach(target => {
       assertEditPermission(target, this.userId);
-      targets.push(target);
     });
 
-    // Fetch all the action's ancestor creatureProperties
-    const ancestorIds = [];
-    action.ancestors.forEach(ref => {
-      if (ref.collection === 'creatureProperties') {
-        ancestorIds.push(ref.id);
-      }
-    });
+    const ancestors = getProperyAncestors(creatureId, action._id);
+    ancestors.sort((a, b) => a.order - b.order);
 
-    // Get cursor of ancestors
-    const ancestors = CreatureProperties.find({
-      _id: {$in: ancestorIds},
-    }, {
-      sort: {order: 1},
-    });
-
-    // Get cursor of the properties
-    const properties = CreatureProperties.find({
-      $or: [{_id: action._id}, {'ancestors.id': action._id}],
-      removed: {$ne: true},
-    }, {
-      sort: {order: 1},
-    });
+    const properties = getPropertyDecendants(creatureId, action._id);
+    properties.push(action);
+    properties.sort((a, b) => a.order - b.order);
 
     // Do the action
-    doActionWork({creature, targets, properties, ancestors, method: this, methodScope: scope});
+    doActionWork({ properties, ancestors, actionContext, methodScope: scope });
 
     // Recompute all involved creatures
-    computeCreature(creature._id);
-    targets.forEach(target => {
-      computeCreature(target._id);
+    Creatures.update({
+      _id: { $in: [creatureId, ...targetIds] }
+    }, {
+      $set: { dirty: true },
     });
   },
 });
@@ -87,41 +70,28 @@ const doAction = new ValidatedMethod({
 export default doAction;
 
 export function doActionWork({
-  creature, targets, properties, ancestors, method, methodScope = {}, log
-}){
+  properties, ancestors, actionContext, methodScope = {},
+}) {
   // get the docs
   const ancestorScope = getAncestorScope(ancestors);
   const propertyForest = nodeArrayToTree(properties);
-  if (propertyForest.length !== 1){
+  if (propertyForest.length !== 1) {
     throw new Meteor.Error(`The action has ${propertyForest.length} top level properties, expected 1`);
   }
 
-  // Create the log
-  if (!log) log = CreatureLogSchema.clean({
-    creatureId: creature._id,
-    creatureName: creature.name,
-  });
+  // Include the ancestry and method scope in the context scope
+  Object.assign(actionContext.scope, ancestorScope, methodScope);
 
   // Apply the top level property, it is responsible for applying its children
   // recursively
-  const scope = {
-    ...creature.variables,
-    ...ancestorScope,
-    ...methodScope
-  }
-  applyProperty(propertyForest[0], {
-    creature,
-    targets,
-    scope,
-    log,
-  });
+  applyProperty(propertyForest[0], actionContext);
 
   // Insert the log
-  insertCreatureLogWork({log, creature, method});
+  actionContext.writeLog();
 }
 
 // Assumes ancestors are in tree order already
-function getAncestorScope(ancestors){
+function getAncestorScope(ancestors) {
   let scope = {};
   ancestors.forEach(prop => {
     scope[`#${prop.type}`] = prop;

app/imports/api/engine/actions/doAction.test.js

@@ -1,11 +1,53 @@
 import '/imports/api/simpleSchemaConfig.js';
 //import testTypes from './testTypes/index.js';
 import { doActionWork } from './doAction.js';
-import createAction from './tests/createAction.testFn.js';
+import { CreatureLogSchema } from '/imports/api/creature/log/CreatureLogs.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import Creatures from '/imports/api/creature/creatures/Creatures.js';
+
+function cleanProp(prop){
+  let schema = CreatureProperties.simpleSchema(prop);
+  return schema.clean(prop);
+}
+
+function cleanCreature(creature){
+  let schema = Creatures.simpleSchema(creature);
+  return schema.clean(creature);
+}
+
+// Fake ActionContext to test actions with
+const creatureId = 'actionTestCreatureId';
+const creatureName = 'Action Test Creature';
+const testActionContext = {
+  creature: cleanCreature({
+    _id: creatureId,
+  }),
+  log: CreatureLogSchema.clean({
+    creatureId: creatureId,
+    creatureName: creatureName,
+  }),
+  scope: {},
+  addLog(content) {
+    if (content.name || content.value){
+      this.log.content.push(content);
+    }
+  },
+  writeLog: () => { },
+}
+
+const action = cleanProp({
+  type: 'action',
+});
+const actionAncestors = [];
 
 describe('Do Action', function(){
   it('Does an empty action', function(){
-    doActionWork(createAction({properties: [{type: 'action'}]}));
+    doActionWork({
+      properties: [action],
+      ancestors: actionAncestors,
+      actionContext: testActionContext,
+      methodScope: {},
+    });
   });
   //testTypes.forEach(test => it(test.text, test.fn));
 });

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

@@ -1,14 +1,15 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import {
+  getProperyAncestors, getPropertyDecendants
+} from '/imports/api/engine/loadCreatures.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
 import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
 import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
 import { doActionWork } from '/imports/api/engine/actions/doAction.js';
-import computeCreature from '/imports/api/engine/computeCreature.js';
-import { CreatureLogSchema } from '/imports/api/creature/log/CreatureLogs.js';
+import ActionContext from '/imports/api/engine/actions/ActionContext.js';
 
 const doAction = new ValidatedMethod({
   name: 'creatureProperties.doCastSpell',
@@ -19,6 +20,10 @@ const doAction = new ValidatedMethod({
       regEx: SimpleSchema.RegEx.Id,
       optional: true,
     },
+    ritual: {
+      type: Boolean,
+      optional: true,
+    },
     targetIds: {
       type: Array,
       defaultValue: [],
@@ -40,101 +45,90 @@ const doAction = new ValidatedMethod({
     numRequests: 10,
     timeInterval: 5000,
   },
-  run({spellId, slotId, targetIds = [], scope = {}}) {
+  run({ spellId, slotId, ritual, targetIds = [], scope = {} }) {
+    // Get action context
     let spell = CreatureProperties.findOne(spellId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(spell);
+    const creatureId = spell.ancestors[0].id;
+    const actionContext = new ActionContext(creatureId, targetIds, this);
 
-    assertEditPermission(creature, this.userId);
-
-    // Get all the targets and make sure we can edit them
-    let targets = [];
-    targetIds.forEach(targetId => {
-      let target = Creatures.findOne(targetId);
+    // Check permissions
+    assertEditPermission(actionContext.creature, this.userId);
+    actionContext.targets.forEach(target => {
       assertEditPermission(target, this.userId);
-      targets.push(target);
     });
 
-    // Fetch all the action's ancestor creatureProperties
-    const ancestorIds = [];
-    spell.ancestors.forEach(ref => {
-      if (ref.collection === 'creatureProperties') {
-        ancestorIds.push(ref.id);
-      }
-    });
+    const ancestors = getProperyAncestors(creatureId, spell._id);
+    ancestors.sort((a, b) => a.order - b.order);
 
-    // Get cursor of ancestors
-    const ancestors = CreatureProperties.find({
-      _id: {$in: ancestorIds},
-    }, {
-      sort: {order: 1},
-    });
-
-    // Get cursor of the properties
-    const properties = CreatureProperties.find({
-      $or: [{_id: spell._id}, {'ancestors.id': spell._id}],
-      removed: {$ne: true},
-    }, {
-      sort: {order: 1},
-    });
+    const properties = getPropertyDecendants(creatureId, spell._id);
+    properties.push(spell);
+    properties.sort((a, b) => a.order - b.order);
 
     // Spend the appropriate slot
     let slotLevel = spell.level || 0;
     let slot;
-    if (slotId && !spell.castWithoutSpellSlots){
+
+    // If a spell requires a slot, make sure a slot is spent
+    if (spell.level && !spell.castWithoutSpellSlots && !(ritual && spell.ritual)) {
       slot = CreatureProperties.findOne(slotId);
-      if (!slot){
+      if (!slot) {
         throw new Meteor.Error('No slot',
           'Slot not found to cast spell');
       }
-      if (!slot.value){
+      if (!slot.value) {
         throw new Meteor.Error('No slot',
           'Slot depleted');
       }
-      if (slot.attributeType !== 'spellSlot'){
+      if (slot.attributeType !== 'spellSlot') {
         throw new Meteor.Error('Not a slot',
           'The given property is not a valid spell slot');
       }
-      if (!slot.spellSlotLevel?.value){
+      if (!slot.spellSlotLevel?.value) {
         throw new Meteor.Error('No slot level',
           'Slot does not have a spell slot level');
       }
-      if (slot.spellSlotLevel.value < spell.level){
+      if (slot.spellSlotLevel.value < spell.level) {
         throw new Meteor.Error('Slot too small',
           'Slot is not large enough to cast spell');
       }
       slotLevel = slot.spellSlotLevel.value;
       damagePropertyWork({
-        property: slot,
+        prop: slot,
         operation: 'increment',
         value: 1,
+        actionContext,
       });
     }
 
-    scope['slotLevel'] = slotLevel;
-
     // Post the slot level spent to the log
-    const log = CreatureLogSchema.clean({
-      creatureId: creature._id,
-      creatureName: creature.name,
-    });
-    if (slot?.spellSlotLevel?.value){
-      log.content.push({
+    if (slot?.spellSlotLevel?.value) {
+      actionContext.addLog({
         name: `Casting using a level ${slotLevel} spell slot`
       });
     } else if (slotLevel) {
-      log.content.push({
-        name: `Casting at level ${slotLevel}`
-      });
+      if (ritual) {
+        actionContext.addLog({
+          name: `Ritual casting at level ${slotLevel}`
+        });
+      } else {
+        actionContext.addLog({
+          name: `Casting at level ${slotLevel}`
+        });
+      }
     }
 
-    // Do the action
-    doActionWork({creature, targets, properties, ancestors, method: this, methodScope: scope, log});
+    actionContext.scope['slotLevel'] = slotLevel;
 
-    // Recompute all involved creatures
-    computeCreature(creature._id);
-    targets.forEach(target => {
-      computeCreature(target._id);
+    // Do the action
+    doActionWork({
+      properties, ancestors, actionContext, methodScope: scope,
+    });
+
+    // Force the characters involved to recalculate
+    Creatures.update({
+      _id: { $in: [creatureId, ...targetIds] }
+    }, {
+      $set: { dirty: true },
     });
   },
 });

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

@@ -1,13 +1,13 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
 import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
 import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import computeCreature from '/imports/api/engine/computeCreature.js';
 import rollDice from '/imports/parser/rollDice.js';
-import numberToSignedString from '/imports/ui/utility/numberToSignedString.js';
+import numberToSignedString from '/imports/api/utility/numberToSignedString.js';
+import { applyTriggers } from '/imports/api/engine/actions/applyTriggers.js';
+import ActionContext from '/imports/api/engine/actions/ActionContext.js';
+import evaluateCalculation from '/imports/api/engine/computation/utility/evaluateCalculation.js';
 
 const doCheck = new ValidatedMethod({
   name: 'creatureProperties.doCheck',
@@ -23,53 +23,49 @@ const doCheck = new ValidatedMethod({
     numRequests: 10,
     timeInterval: 5000,
   },
-  run({propId, scope}) {
+  run({ propId, scope }) {
     const prop = CreatureProperties.findOne(propId);
-    const creature = getRootCreatureAncestor(prop);
+    const creatureId = prop.ancestors[0].id;
+    const actionContext = new ActionContext(creatureId, [creatureId], this);
+    Object.assign(actionContext.scope, scope);
+    actionContext.scope[`#${prop.type}`] = prop;
 
     // Check permissions
-    assertEditPermission(creature, this.userId);
+    assertEditPermission(actionContext.creature, this.userId);
 
     // Do the check
-    doCheckWork({creature, prop, method: this, methodScope: scope});
-
-    // Recompute all involved creatures
-    computeCreature(creature._id);
+    doCheckWork({ prop, actionContext });
   },
 });
 
 export default doCheck;
 
-export function doCheckWork({
-  creature, prop, method, methodScope = {}
-}){
-  // Create the log
-  let log = CreatureLogSchema.clean({
-    creatureId: creature._id,
-    creatureName: creature.name,
-  });
+export function doCheckWork({ prop, actionContext }) {
 
-  rollCheck({prop, log, methodScope});
+  applyTriggers(actionContext.triggers.check?.before, prop, actionContext);
+  rollCheck(prop, actionContext);
+  applyTriggers(actionContext.triggers.check?.after, prop, actionContext);
 
   // Insert the log
-  insertCreatureLogWork({log, creature, method});
+  actionContext.writeLog();
 }
 
-function rollCheck({prop, log, methodScope}){
+function rollCheck(prop, actionContext) {
+  const scope = actionContext.scope;
   // get the modifier for the roll
   let rollModifier;
   let logName = `${prop.name} check`;
-  if (prop.type === 'skill'){
+  if (prop.type === 'skill') {
     rollModifier = prop.value;
-    if (prop.skillType === 'save'){
-      if (prop.name.match(/save/i)){
+    if (prop.skillType === 'save') {
+      if (prop.name.match(/save/i)) {
         logName = prop.name;
       } else {
         logName = prop.name ? `${prop.name} save` : 'Saving Throw';
       }
     }
-  } else if (prop.type === 'attribute'){
-    if (prop.attributeType === 'ability'){
+  } else if (prop.type === 'attribute') {
+    if (prop.attributeType === 'ability') {
       rollModifier = prop.modifier;
     } else {
       rollModifier = prop.value;
@@ -78,10 +74,14 @@ function rollCheck({prop, log, methodScope}){
     throw (`${prop.type} not supported for checks`);
   }
 
-  const rollModifierText = numberToSignedString(rollModifier, true);
+  let rollModifierText = numberToSignedString(rollModifier, true);
+
+  const { effectBonus, effectString } = applyUnresolvedEffects(prop, scope)
+  rollModifierText += effectString;
+  rollModifier += effectBonus;
 
   let value, values, resultPrefix;
-  if (methodScope['$checkAdvantage'] === 1){
+  if (scope['$checkAdvantage'] === 1) {
     logName += ' (Advantage)';
     const [a, b] = rollDice(2, 20);
     if (a >= b) {
@@ -91,7 +91,7 @@ function rollCheck({prop, log, methodScope}){
       value = b;
       resultPrefix = `1d20 [ ~~${a}~~, ${b} ] ${rollModifierText} = `;
     }
-  } else if (methodScope['$checkAdvantage'] === -1){
+  } else if (scope['$checkAdvantage'] === -1) {
     logName += ' (Disadvantage)';
     const [a, b] = rollDice(2, 20);
     if (a <= b) {
@@ -107,8 +107,29 @@ function rollCheck({prop, log, methodScope}){
     resultPrefix = `1d20 [ ${value} ] ${rollModifierText} = `
   }
   const result = (value + rollModifier) || 0;
-  log.content.push({
+  scope['$checkDiceRoll'] = value;
+  scope['$checkRoll'] = result;
+  scope['$checkModifier'] = rollModifier;
+  actionContext.addLog({
     name: logName,
     value: `${resultPrefix} **${result}**`,
   });
 }
+
+export function applyUnresolvedEffects(prop, scope) {
+  let effectBonus = 0;
+  let effectString = '';
+  if (!prop.effects) {
+    return { effectBonus, effectString };
+  }
+  prop.effects.forEach(effect => {
+    if (!effect.amount?.parseNode) return;
+    if (effect.operation !== 'add') return;
+    effect.amount._parseLevel = 'reduce';
+    evaluateCalculation(effect.amount, scope);
+    if (typeof effect.amount?.value !== 'number') return;
+    effectBonus += effect.amount.value;
+    effectString += ` ${effect.amount.value < 0 ? '-' : '+'} [${effect.amount.calculation}] ${Math.abs(effect.amount.value)}`
+  });
+  return { effectBonus, effectString };
+}

app/imports/api/engine/actions/tests/createAction.testFn.js

@@ -1,26 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-
-export default function createAction({
-  creature = {_id: 'creatureId'},
-  targets = [],
-  properties = [],
-  ancestors = [],
-  method
-} = {}){
-  properties = properties.map(cleanProp);
-  ancestors = ancestors.map(cleanProp);
-  creature = cleanCreature(creature);
-  ancestors = ancestors.map(cleanCreature);
-  return {creature, targets, properties, ancestors, method};
-}
-
-function cleanProp(prop){
-  let schema = CreatureProperties.simpleSchema(prop);
-  return schema.clean(prop);
-}
-
-function cleanCreature(creature){
-  let schema = Creatures.simpleSchema(creature);
-  return schema.clean(creature);
-}

app/imports/api/engine/actions/tests/testTypes/index.testFn.js

@@ -1,6 +0,0 @@
-import applyAction from './applyAction.testFn.js';
-
-export default [{
-  text: 'Applies actions',
-  fn: applyAction,
-},];

app/imports/api/engine/computation/CreatureComputation.js

@@ -1,38 +0,0 @@
-import { EJSON } from 'meteor/ejson';
-import createGraph from 'ngraph.graph';
-
-export default class CreatureComputation {
-  constructor(properties){
-    // Set up fields
-    this.originalPropsById =  {};
-    this.propsById =  {};
-    this.propsWithTag = {};
-    this.scope = {};
-    this.props =  properties;
-    this.dependencyGraph = createGraph();
-    this.errors = [];
-
-    // Store properties for easy access later
-    properties.forEach(prop => {
-      // Store a copy of the unmodified prop
-      // EJSON clone is ~4x faster than lodash cloneDeep for EJSONable objects
-      this.originalPropsById[prop._id] = EJSON.clone(prop);
-      // Store by id
-      this.propsById[prop._id] = prop;
-
-      // Store sets of ids in each tag
-      if (prop.tags){
-        prop.tags.forEach(tag => {
-          if (this.propsWithTag[tag]){
-            this.propsWithTag[tag].push(prop._id);
-          } else {
-            this.propsWithTag[tag] = [prop._id];
-          }
-        });
-      }
-
-      // Store the prop in the dependency graph
-      this.dependencyGraph.addNode(prop._id, prop);
-    });
-  }
-}

app/imports/api/engine/computation/CreatureComputation.ts

@@ -0,0 +1,55 @@
+import { EJSON } from 'meteor/ejson';
+import createGraph, { Graph } from 'ngraph.graph';
+import getEffectivePropTags from '/imports/api/engine/computation/utility/getEffectivePropTags.js';
+
+interface CreatureProperty {
+  _id: string;
+  type: string;
+}
+
+export default class CreatureComputation {
+  originalPropsById: object;
+  propsById: object;
+  propsWithTag: object;
+  scope: object;
+  props: Array<CreatureProperty>;
+  dependencyGraph: Graph;
+  errors: Array<object>;
+  creature: object;
+  variables: object;
+
+  constructor(properties: Array<CreatureProperty>, creature: object, variables: object) {
+    // Set up fields
+    this.originalPropsById = {};
+    this.propsById = {};
+    this.propsWithTag = {};
+    this.scope = {};
+    this.props = properties;
+    this.dependencyGraph = createGraph();
+    this.errors = [];
+    this.creature = creature;
+    this.variables = variables;
+
+    // Store properties for easy access later
+    properties.forEach(prop => {
+      // Store a copy of the unmodified prop
+      // EJSON clone is ~4x faster than lodash cloneDeep for EJSONable objects
+      this.originalPropsById[prop._id] = EJSON.clone(prop);
+      // Store by id
+      this.propsById[prop._id] = prop;
+
+      // Store sets of ids in each tag
+      getEffectivePropTags(prop).forEach(tag => {
+        if (!tag) return;
+        if (this.propsWithTag[tag]) {
+          this.propsWithTag[tag].push(prop._id);
+        } else {
+          this.propsWithTag[tag] = [prop._id];
+        }
+      });
+
+      // Store the prop in the dependency graph
+      this.dependencyGraph.addNode(prop._id, prop);
+    });
+  }
+}

app/imports/api/engine/computation/buildComputation/computeInactiveStatus.js

@@ -29,11 +29,12 @@ function childrenActive(prop){
   // Children of disabled properties are always inactive
   if (prop.disabled) return false;
   switch (prop.type){
-    // Only equipped items have active children
-    case 'item': return !!prop.equipped;
-    // The children of actions are always inactive
+    // Only equipped items with non-zero quantity have active children
+    case 'item': return !!prop.equipped && prop.quantity !== 0;
+    // The children of actions, spells, and triggers are always inactive
     case 'action': return false;
     case 'spell': return false;
+    case 'trigger': return false;
     // The children of notes are always inactive
     case 'note': return false;
     // Other children are active

app/imports/api/engine/computation/buildComputation/computeToggleDependencies.js

@@ -10,8 +10,8 @@ export default function computeToggleDependencies(node, dependencyGraph){
     prop.enabled
   ) return;
   walkDown(node.children, child => {
-    child.node._computationDetails.toggleAncestors.push(prop);
     // The child nodes depend on the toggle condition compuation
+    child.node._computationDetails.toggleAncestors.push(prop);
     dependencyGraph.addLink(child.node._id, prop._id, 'toggle');
   });
 }

app/imports/api/engine/computation/buildComputation/linkCalculationDependencies.js

@@ -1,7 +1,7 @@
 import findAncestorByType from '/imports/api/engine/computation/utility/findAncestorByType.js';
 import { traverse } from '/imports/parser/resolve.js';
 
-export default function linkCalculationDependencies(dependencyGraph, prop, {propsById}){
+export default function linkCalculationDependencies(dependencyGraph, prop, { propsById }) {
   prop._computationDetails.calculations.forEach(calcObj => {
     // Store resolved ancestors
     const memo = {
@@ -16,12 +16,13 @@ export default function linkCalculationDependencies(dependencyGraph, prop, {prop
       // Skip nodes that aren't symbols or accessors
       if (node.parseType !== 'symbol' && node.parseType !== 'accessor') return;
       // Link ancestor references as direct property dependencies
-      if (node.name[0] === '#'){
+      if (node.name[0] === '#') {
         let ancestorProp = getAncestorProp(
           node.name.slice(1), memo, prop, propsById
         );
         if (!ancestorProp) return;
         // Link the ancestor prop as a direct dependency
+        // TODO: we might be referencing a calculation sub-field, depend on that instead
         dependencyGraph.addLink(
           calcNodeId, ancestorProp._id, 'ancestorReference'
         );
@@ -34,16 +35,16 @@ export default function linkCalculationDependencies(dependencyGraph, prop, {prop
     });
     // Store the resolved ancestors in this calculation's local scope
     if (memo.ancestors) {
-      calcObj._localScope = { ...calcObj._localScope, ...memo.ancestors};
+      calcObj._localScope = { ...calcObj._localScope, ...memo.ancestors };
     }
   });
 }
 
-function getAncestorProp(type, memo, prop, propsById){
-  if (memo.ancestors && memo.ancestors['#' + type]){
+function getAncestorProp(type, memo, prop, propsById) {
+  if (memo.ancestors && memo.ancestors['#' + type]) {
     return memo.ancestors['#' + type];
   } else {
-    var ancestorProp = findAncestorByType( prop, type, propsById );
+    var ancestorProp = findAncestorByType(prop, type, propsById);
     if (!memo.ancestors) memo.ancestors = {};
     memo.ancestors['#' + type] = ancestorProp;
     return ancestorProp;

app/imports/api/engine/computation/buildComputation/linkTypeDependencies.js

@@ -1,4 +1,4 @@
-import { get, intersection, difference } from 'lodash';
+import { get, intersection, difference, union } from 'lodash';
 
 const linkDependenciesByType = {
   action: linkAction,
@@ -14,6 +14,7 @@ const linkDependenciesByType = {
   effect: linkEffects,
   proficiency: linkProficiencies,
   roll: linkRoll,
+  pointBuy: linkPointBuy,
   propertySlot: linkSlot,
   skill: linkSkill,
   spell: linkAction,
@@ -22,23 +23,26 @@ const linkDependenciesByType = {
   toggle: linkToggle,
 }
 
-export default function linkTypeDependencies(dependencyGraph, prop, computation){
+export default function linkTypeDependencies(dependencyGraph, prop, computation) {
   linkDependenciesByType[prop.type]?.(dependencyGraph, prop, computation);
 }
 
-function dependOnCalc({dependencyGraph, prop, key}){
+function dependOnCalc({ dependencyGraph, prop, key }) {
   let calc = get(prop, key);
   if (!calc) return;
-  if (calc.type !== '_calculation'){
+  if (calc.type !== '_calculation') {
     throw `Expected calculation got ${calc.type}`
   }
   dependencyGraph.addLink(prop._id, `${prop._id}.${key}`, 'calculation');
 }
 
-function linkAction(dependencyGraph, prop, {propsById}){
+function linkAction(dependencyGraph, prop, { propsById }) {
+  if (prop.variableName) {
+    dependencyGraph.addLink(prop.variableName, prop._id, 'eventDefinition');
+  }
   // The action depends on its attack roll and uses calculations
-  dependOnCalc({dependencyGraph, prop, key: 'attackRoll'});
-  dependOnCalc({dependencyGraph, prop, key: 'uses'});
+  dependOnCalc({ dependencyGraph, prop, key: 'attackRoll' });
+  dependOnCalc({ dependencyGraph, prop, key: 'uses' });
 
   // Link the resources the action uses
   if (!prop.resources) return;
@@ -46,7 +50,7 @@ function linkAction(dependencyGraph, prop, {propsById}){
   prop.resources.itemsConsumed.forEach((itemConsumed, index) => {
     if (!itemConsumed.itemId) return;
     const item = propsById[itemConsumed.itemId];
-    if (!item || item.inactive){
+    if (!item || item.inactive) {
       // Unlink if the item doesn't exist or is inactive
       itemConsumed.itemId = undefined;
       return;
@@ -78,60 +82,77 @@ function linkAction(dependencyGraph, prop, {propsById}){
   });
 }
 
-function linkAdjustment(dependencyGraph, prop){
+function linkAdjustment(dependencyGraph, prop) {
   // Adjustment depends on its amount
-  dependOnCalc({dependencyGraph, prop, key: 'amount'});
+  dependOnCalc({ dependencyGraph, prop, key: 'amount' });
 }
 
-function linkAttribute(dependencyGraph, prop){
+function linkAttribute(dependencyGraph, prop) {
   linkVariableName(dependencyGraph, prop);
   // Depends on spellSlotLevel
-  dependOnCalc({dependencyGraph, prop, key: 'spellSlotLevel'});
+  dependOnCalc({ dependencyGraph, prop, key: 'spellSlotLevel' });
 
   // Depends on base value
-  dependOnCalc({dependencyGraph, prop, key: 'baseValue'});
+  dependOnCalc({ dependencyGraph, prop, key: 'baseValue' });
 
   // hit dice depend on constitution
-  if (prop.attributeType === 'hitDice'){
+  if (prop.attributeType === 'hitDice') {
     dependencyGraph.addLink(prop._id, 'constitution', 'hitDiceConMod');
   }
 }
 
-function linkBranch(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'condition'});
+function linkBranch(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'condition' });
 }
 
-function linkBuff(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'duration'});
+function linkBuff(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'duration' });
 }
 
-function linkClassLevel(dependencyGraph, prop){
+function linkClassLevel(dependencyGraph, prop) {
+  if (prop.inactive) return;
   // The variableName of the prop depends on the prop
-  if (prop.variableName && prop.level){
+  if (prop.variableName && prop.level) {
     dependencyGraph.addLink(prop.variableName, prop._id, 'classLevel');
     // The level variable depends on the class variableName variable
     let existingLevelLink = dependencyGraph.getLink('level', prop.variableName);
-    if (!existingLevelLink){
+    if (!existingLevelLink) {
       dependencyGraph.addLink('level', prop.variableName, 'level');
     }
   }
 }
 
-function linkDamage(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'amount'});
+function linkDamage(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'amount' });
 }
 
-function linkEffects(dependencyGraph, prop, computation){
+function linkEffects(dependencyGraph, prop, computation) {
   // The effect depends on its amount calculation
-  dependOnCalc({dependencyGraph, prop, key: 'amount'});
+  dependOnCalc({ dependencyGraph, prop, key: 'amount' });
+  // Inactive effects aren't going to impact their targeted stats
+  if (prop.inactive) return;
   // The stats depend on the effect
-  if (prop.targetByTags){
+  if (prop.inactive) {
+    // Inactive effects apply to no stats
+    return;
+  } else if (prop.targetByTags) {
     getEffectTagTargets(prop, computation).forEach(targetId => {
       const targetProp = computation.propsById[targetId];
-      const key = prop.targetField || getDefaultCalculationField(targetProp);
-      const calcObj = get(targetProp, key);
-      if (calcObj && calcObj.calculation){
-        dependencyGraph.addLink(`${targetProp._id}.${key}`, prop._id , 'effect');
+      if (
+        (targetProp.type === 'attribute' || targetProp.type === 'skill')
+        && targetProp.variableName
+        && !prop.targetField
+      ) {
+        // If the field wasn't specified and we're targeting an attribute or
+        // skill, just treat it like a normal effect on its variable name
+        dependencyGraph.addLink(targetProp.variableName, prop._id, 'effect');
+      } else {
+        // Otherwise target a field on that property
+        const key = prop.targetField || getDefaultCalculationField(targetProp);
+        const calcObj = get(targetProp, key);
+        if (calcObj && calcObj.calculation) {
+          dependencyGraph.addLink(`${targetProp._id}.${key}`, prop._id, 'effect');
+        }
       }
     });
   } else {
@@ -143,17 +164,19 @@ function linkEffects(dependencyGraph, prop, computation){
 }
 
 // Returns an array of IDs of the properties the effect targets
-function getEffectTagTargets(effect, computation){
-  const targets = getTargetListFromTags(effect.targetTags, computation);
-  const notIds = [];
-  if (effect.extraTags){
+function getEffectTagTargets(effect, computation) {
+  let targets = getTargetListFromTags(effect.targetTags, computation);
+  let notIds = [];
+  if (effect.extraTags) {
     effect.extraTags.forEach(ex => {
-      if (ex.operation === 'OR'){
-        targets.push(...getTargetListFromTags(ex.tags, computation));
-      } else if (ex.operation === 'NOT'){
+      if (ex.operation === 'OR') {
+        targets = union(targets, getTargetListFromTags(ex.tags, computation));
+      } else if (ex.operation === 'NOT') {
         ex.tags.forEach(tag => {
           const idList = computation.propsWithTag[tag];
-          if (idList) notIds.push(...computation.propsWithTag[tag])
+          if (idList) {
+            notIds = union(notIds, computation.propsWithTag[tag]);
+          }
         });
       }
     });
@@ -161,19 +184,19 @@ function getEffectTagTargets(effect, computation){
   return difference(targets, notIds);
 }
 
-function getTargetListFromTags(tags, computation){
+function getTargetListFromTags(tags, computation) {
   const targetTagIdLists = [];
   if (!tags) return [];
   tags.forEach(tag => {
-    const idList = computation.propsWithTag[tag];
-    if (idList) targetTagIdLists.push(idList);
+    const idList = computation.propsWithTag[tag] || [];
+    targetTagIdLists.push(idList);
   });
   const targets = intersection(...targetTagIdLists);
   return targets;
 }
 
-function getDefaultCalculationField(prop){
-  switch (prop.type){
+function getDefaultCalculationField(prop) {
+  switch (prop.type) {
     case 'action': return 'attackRoll';
     case 'adjustment': return 'amount';
     case 'attribute': return 'baseValue';
@@ -203,62 +226,87 @@ function getDefaultCalculationField(prop){
   }
 }
 
-function linkRoll(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'roll'});
+function linkRoll(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'roll' });
 }
 
-function linkVariableName(dependencyGraph, prop){
-  // The variableName of the prop depends on the prop
-  if (prop.variableName){
+function linkVariableName(dependencyGraph, prop) {
+  // The variableName of the prop depends on the prop if the prop is active
+  if (prop.variableName && !prop.inactive) {
     dependencyGraph.addLink(prop.variableName, prop._id, 'definition');
   }
 }
 
-function linkDamageMultiplier(dependencyGraph, prop){
+function linkDamageMultiplier(dependencyGraph, prop) {
+  if (prop.inactive) return;
   prop.damageTypes.forEach(damageType => {
     // Remove all non-letter characters from the damage name
     const damageName = damageType.replace(/[^a-z]/gi, '')
-    dependencyGraph.addLink(`${damageName}Multiplier`, prop._id, prop.type);
+    dependencyGraph.addLink(damageName, prop._id, prop.type);
   });
 }
 
-function linkProficiencies(dependencyGraph, prop){
+function linkPointBuy(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'min' });
+  dependOnCalc({ dependencyGraph, prop, key: 'max' });
+  dependOnCalc({ dependencyGraph, prop, key: 'cost' });
+  dependOnCalc({ dependencyGraph, prop, key: 'total' });
+  prop.values?.forEach(row => {
+    // Wrap the document in a new object so we don't bash it unintentionally
+    const pointBuyRow = {
+      ...row,
+      type: 'pointBuyRow',
+      tableName: prop.name,
+      tableId: prop._id,
+    }
+    dependencyGraph.addNode(row._id, pointBuyRow);
+    linkVariableName(dependencyGraph, pointBuyRow);
+    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.min' });
+    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.max' });
+    dependOnCalc({ dependencyGraph, pointBuyRow, key: 'row.cost' });
+  });
+  if (prop.inactive) return;
+}
+
+function linkProficiencies(dependencyGraph, prop) {
   // The stats depend on the proficiency
+  if (prop.inactive) return;
   prop.stats.forEach(statName => {
     if (!statName) return;
     dependencyGraph.addLink(statName, prop._id, prop.type);
   });
 }
 
-function linkSavingThrow(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'dc'});
+function linkSavingThrow(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'dc' });
 }
 
-function linkSkill(dependencyGraph, prop){
+function linkSkill(dependencyGraph, prop) {
+  // Depends on base value
+  dependOnCalc({ dependencyGraph, prop, key: 'baseValue' });
+  // Link dependents
+  if (prop.inactive) return;
   linkVariableName(dependencyGraph, prop);
   // The prop depends on the variable references as the ability
-  if (prop.ability){
+  if (prop.ability) {
     dependencyGraph.addLink(prop._id, prop.ability, 'skillAbilityScore');
   }
   // Skills depend on the creature's proficiencyBonus
   dependencyGraph.addLink(prop._id, 'proficiencyBonus', 'skillProficiencyBonus');
-  
-  // Depends on base value
-  dependOnCalc({dependencyGraph, prop, key: 'baseValue'});
 }
 
-function linkSlot(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'quantityExpected'});
-  dependOnCalc({dependencyGraph, prop, key: 'slotCondition'});
+function linkSlot(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'quantityExpected' });
+  dependOnCalc({ dependencyGraph, prop, key: 'slotCondition' });
 }
 
-function linkSpellList(dependencyGraph, prop){
-  dependOnCalc({dependencyGraph, prop, key: 'maxPrepared'});
-  dependOnCalc({dependencyGraph, prop, key: 'attackRollBonus'});
-  dependOnCalc({dependencyGraph, prop, key: 'dc'});
+function linkSpellList(dependencyGraph, prop) {
+  dependOnCalc({ dependencyGraph, prop, key: 'maxPrepared' });
+  dependOnCalc({ dependencyGraph, prop, key: 'attackRollBonus' });
+  dependOnCalc({ dependencyGraph, prop, key: 'dc' });
 }
 
-function linkToggle(dependencyGraph, prop){
+function linkToggle(dependencyGraph, prop) {
   linkVariableName(dependencyGraph, prop);
-  dependOnCalc({dependencyGraph, prop, key: 'condition'});
+  dependOnCalc({ dependencyGraph, prop, key: 'condition' });
 }

app/imports/api/engine/computation/buildCreatureComputation.js

@@ -1,8 +1,7 @@
 import { nodeArrayToTree } from '/imports/api/parenting/nodesToTree.js';
-import CreatureProperties,
-  { DenormalisedOnlyCreaturePropertySchema as denormSchema }
+import { DenormalisedOnlyCreaturePropertySchema as denormSchema }
   from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import { getProperties, getCreature, getVariables } from '/imports/api/engine/loadCreatures.js';
 import computedOnlySchemas from '/imports/api/properties/computedOnlyPropertySchemasIndex.js';
 import computedSchemas from '/imports/api/properties/computedPropertySchemasIndex.js';
 import linkInventory from './buildComputation/linkInventory.js';
@@ -13,7 +12,7 @@ import computeToggleDependencies from './buildComputation/computeToggleDependenc
 import linkCalculationDependencies from './buildComputation/linkCalculationDependencies.js';
 import linkTypeDependencies from './buildComputation/linkTypeDependencies.js';
 import computeSlotQuantityFilled from './buildComputation/computeSlotQuantityFilled.js';
-import CreatureComputation from './CreatureComputation.js';
+import CreatureComputation from './CreatureComputation.ts';
 import removeSchemaFields from './buildComputation/removeSchemaFields.js';
 
 /**
@@ -32,29 +31,15 @@ import removeSchemaFields from './buildComputation/removeSchemaFields.js';
 
 export default function buildCreatureComputation(creatureId){
   const creature = getCreature(creatureId);
+  const variables = getVariables(creatureId);
   const properties = getProperties(creatureId);
-  const computation = buildComputationFromProps(properties, creature);
+  const computation = buildComputationFromProps(properties, creature, variables);
   return computation;
 }
 
-function getProperties(creatureId){
-  return CreatureProperties.find({
-    'ancestors.id': creatureId,
-    'removed': {$ne: true},
-  }, {
-    sort: {order: 1}
-  }).fetch();
-}
+export function buildComputationFromProps(properties, creature, variables){
 
-function getCreature(creatureId){
-  return Creatures.findOne(creatureId, {
-    denormalizedStats: 1,
-  });
-}
-
-export function buildComputationFromProps(properties, creature){
-
-  const computation = new CreatureComputation(properties);
+  const computation = new CreatureComputation(properties, creature, variables);
   // Dependency graph where edge(a, b) means a depends on b
   // The graph includes all dependencies even of inactive properties
   // such that any properties changing without changing their dependencies
@@ -81,8 +66,10 @@ export function buildComputationFromProps(properties, creature){
 
   // Process the properties one by one
   properties.forEach(prop => {
+    // The prop has been processed, it's no longer dirty
+    delete prop.dirty;
 
-    let computedSchema = computedOnlySchemas[prop.type];
+    const computedSchema = computedOnlySchemas[prop.type];
     removeSchemaFields([computedSchema, denormSchema], prop);
 
     // Add a place to store all the computation details
@@ -102,6 +89,10 @@ export function buildComputationFromProps(properties, creature){
   // Walk the property trees computing things that need to be inherited
   walkDown(forest, node => {
     computeInactiveStatus(node);
+  });
+  // Inactive status must be complete for the whole tree before toggle deps
+  // are calculated
+  walkDown(forest, node => {
     computeToggleDependencies(node, dependencyGraph);
     computeSlotQuantityFilled(node, dependencyGraph);
   });
@@ -114,5 +105,6 @@ export function buildComputationFromProps(properties, creature){
     linkTypeDependencies(dependencyGraph, prop, computation);
     linkCalculationDependencies(dependencyGraph, prop, computation);
   });
+
   return computation;
 }

app/imports/api/engine/computation/computeComputation/computeByType.js

@@ -2,8 +2,10 @@ import _variable from './computeByType/computeVariable.js';
 import action from './computeByType/computeAction.js';
 import attribute from './computeByType/computeAttribute.js';
 import skill from './computeByType/computeSkill.js';
+import pointBuy from './computeByType/computePointBuy.js';
 import propertySlot from './computeByType/computeSlot.js';
 import container from './computeByType/computeContainer.js';
+import spellList from './computeByType/computeSpellList.js';
 import _calculation from './computeByType/computeCalculation.js';
 
 export default Object.freeze({
@@ -13,6 +15,8 @@ export default Object.freeze({
   attribute,
   container,
   skill,
+  pointBuy,
   propertySlot,
   spell: action,
+  spellList,
 });

app/imports/api/engine/computation/computeComputation/computeByType/computeAction.js

@@ -1,8 +1,8 @@
-export default function computeAction(computation, node){
+export default function computeAction(computation, node) {
   const prop = node.data;
-  if (prop.uses){
+  if (prop.uses) {
     prop.usesLeft = prop.uses.value - (prop.usesUsed || 0);
-    if (!prop.usesLeft){
+    if (!prop.usesLeft) {
       prop.insufficientResources = true;
     }
   }
@@ -10,19 +10,19 @@ export default function computeAction(computation, node){
   if (!prop.resources) return;
   prop.resources.itemsConsumed.forEach(itemConsumed => {
     if (!itemConsumed.itemId) return;
-    if (itemConsumed.available < itemConsumed.quantity?.value){
+    if (itemConsumed.available < itemConsumed.quantity?.value) {
       prop.insufficientResources = true;
     }
   });
   prop.resources.attributesConsumed.forEach(attConsumed => {
     if (!attConsumed.variableName) return;
-    if (attConsumed.available < attConsumed.quantity?.value){
+    if (attConsumed.available < attConsumed.quantity?.value) {
       prop.insufficientResources = true;
     }
   });
 }
 
-function computeResources(computation, node){
+function computeResources(computation, node) {
   const resources = node.data?.resources;
   if (!resources) return;
   resources.attributesConsumed.forEach(attConsumed => {

app/imports/api/engine/computation/computeComputation/computeByType/computePointBuy.js

@@ -0,0 +1,53 @@
+import { has } from 'lodash';
+import evaluateCalculation from '../../utility/evaluateCalculation.js';
+
+export default function computePointBuy(computation, node) {
+  const prop = node.data;
+  const tableMin = prop.min?.value || null;
+  const tableMax = prop.max?.value || null;
+  prop.spent = 0;
+  prop.values?.forEach(row => {
+    // Clean up added properties
+    // delete row.tableId;
+    // delete row.tableName;
+    // delete row.type;
+
+    row.spent = 0;
+    if (row.value === undefined) return;
+    const min = has(row, 'min.value') ? row.min.value : tableMin;
+    const max = has(row, 'max.value') ? row.max.value : tableMax;
+    const costFunction = EJSON.clone(row.cost || prop.cost);
+    if (costFunction) costFunction.parseLevel = 'reduce';
+
+    // Check min and max
+    if (min !== null && row.value < min) {
+      row.value = min;
+    }
+    if (max !== null && row.value > max) {
+      row.value = max;
+    }
+    // Evaluate the cost function
+    if (!costFunction) return;
+    evaluateCalculation(costFunction, { ...computation.scope, value: row.value });
+    // Write calculation errors
+    costFunction.errors?.forEach(error => {
+      if (error?.message) {
+        row.errors = row.errors || [];
+        error.message = 'Cost calculation error.\n' + error.message;
+        row.errors.push(error);
+      }
+    });
+    if (Number.isFinite(costFunction.value)) {
+      row.spent = costFunction.value;
+      prop.spent += costFunction.value;
+    }
+  });
+  prop.pointsLeft = (prop.total?.value || 0) - (prop.spent || 0);
+  if (prop.spent > prop.total?.value) {
+    prop.errors = prop.errors || [];
+    prop.errors.push({
+      type: 'pointBuyError',
+      message: 'Spent more than total points available',
+    });
+  }
+}

app/imports/api/engine/computation/computeComputation/computeByType/computeSkill.js

@@ -4,7 +4,7 @@
 // by computeVariableAsSkill
 export default function computeSkill(computation, node){
   const prop = node.data;
-  prop.proficiency = prop.baseProficiency;
+  prop.proficiency = prop.baseProficiency || 0;
   let profBonus = computation.scope['proficiencyBonus']?.value || 0;
   // Multiply the proficiency bonus by the actual proficiency
   if(prop.proficiency === 0.49){

app/imports/api/engine/computation/computeComputation/computeByType/computeSpellList.js

@@ -0,0 +1,10 @@
+export default function computeSpelllist(computation, node) {
+  const prop = node.data;
+
+  const ability = computation.scope[prop.ability];
+  if (Number.isFinite(ability?.modifier)) {
+    prop.abilityMod = ability.modifier;
+  } else if (Number.isFinite(ability?.value)) {
+    prop.abilityMod = ability.value;
+  }
+}

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable.js

@@ -7,7 +7,7 @@ import computeVariableAsToggle from './computeVariable/computeVariableAsToggle.j
 import computeImplicitVariable from './computeVariable/computeImplicitVariable.js';
 import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 
-export default function computeVariable(computation, node){
+export default function computeVariable(computation, node) {
   const scope = computation.scope;
   if (!node.data) node.data = {};
   aggregateLinks(computation, node);
@@ -15,7 +15,7 @@ export default function computeVariable(computation, node){
   // Don't add to the scope if the node id is not a legitimate variable name
   // Without this `some.thing` could break the entire sheet as a database key
   if (!VARIABLE_NAME_REGEX.test(node.id)) return;
-  if (node.data.definingProp){
+  if (node.data.definingProp) {
     // Add the defining variable to the scope
     scope[node.id] = node.data.definingProp
   } else {
@@ -24,7 +24,7 @@ export default function computeVariable(computation, node){
   }
 }
 
-function aggregateLinks(computation, node){
+function aggregateLinks(computation, node) {
   computation.dependencyGraph.forEachLinkedNode(
     node.id,
     (linkedNode, link) => {
@@ -32,11 +32,12 @@ function aggregateLinks(computation, node){
       // Ignore inactive props
       if (linkedNode.data.inactive) return;
       // Apply all the aggregations
-      let arg = {node, linkedNode, link, computation};
+      let arg = { node, linkedNode, link, computation };
       aggregate.classLevel(arg);
       aggregate.damageMultiplier(arg);
       aggregate.definition(arg);
       aggregate.effect(arg);
+      aggregate.eventDefinition(arg);
       aggregate.inventory(arg);
       aggregate.proficiency(arg);
     },
@@ -44,7 +45,7 @@ function aggregateLinks(computation, node){
   );
 }
 
-function combineAggregations(computation, node){
+function combineAggregations(computation, node) {
   combineMultiplierAggregator(node);
   node.data.overridenProps?.forEach(prop => {
     computeVariableProp(computation, node, prop);
@@ -52,42 +53,52 @@ function combineAggregations(computation, node){
   computeVariableProp(computation, node, node.data.definingProp);
 }
 
-function computeVariableProp(computation, node, prop){
+function computeVariableProp(computation, node, prop) {
   if (!prop) return;
-  if (prop.type === 'attribute'){
+
+  // Combine damage multipliers in all props so that they can't be overridden
+  if (node.data.immunity) {
+    prop.immunity = node.data.immunity;
+    prop.immunities = node.data.immunities;
+  }
+  if (node.data.resistance) {
+    prop.resistance = node.data.resistance;
+    prop.resistances = node.data.resistances;
+  }
+  if (node.data.vulnerability) {
+    prop.vulnerability = node.data.vulnerability;
+    prop.vulnerabilities = node.data.vulnerabilities;
+  }
+
+  if (prop.type === 'attribute') {
     computeVariableAsAttribute(computation, node, prop);
-  } else if (prop.type === 'skill'){
+  } else if (prop.type === 'skill') {
     computeVariableAsSkill(computation, node, prop);
-  } else if (prop.type === 'constant'){
+  } else if (prop.type === 'constant') {
     computeVariableAsConstant(computation, node, prop);
-  } else if (prop.type === 'class'){
+  } else if (prop.type === 'class') {
     computeVariableAsClass(computation, node, prop);
-  } else if (prop.type === 'toggle'){
+  } else if (prop.type === 'toggle') {
     computeVariableAsToggle(computation, node, prop);
   }
 }
 
-function combineMultiplierAggregator(node){
+function combineMultiplierAggregator(node) {
   // get a reference to the  aggregator
   const aggregator = node.data.multiplierAggregator;
   if (!aggregator) return;
 
   // Combine
-  let value;
-  if (aggregator.immunityCount){
-    value = 0;
-  } else if (
-    aggregator.resistanceCount &&
-    !aggregator.vulnerabilityCount
-  ){
-    value = 0.5;
-  }  else if (
-    !aggregator.resistanceCount &&
-    aggregator.vulnerabilityCount
-  ){
-    value = 2;
-  } else {
-    value = 1;
+  if (aggregator.immunities?.length) {
+    node.data.immunity = true;
+    node.data.immunities = aggregator.immunities;
+  }
+  if (aggregator.resistances?.length) {
+    node.data.resistance = true;
+    node.data.resistances = aggregator.resistances;
+  }
+  if (aggregator.vulnerabilities?.length) {
+    node.data.vulnerability = true;
+    node.data.vulnerabilities = aggregator.vulnerabilities;
   }
-  node.data.damageMultiplyValue = value;
 }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateDamageMultiplier.js

@@ -1,22 +1,36 @@
+import { pick } from 'lodash';
+
 export default function aggregateDamageMultipliers({node, linkedNode, link}){
   if (link.data !== 'damageMultiplier') return;
   const multiplierValue = linkedNode.data.value;
   if (multiplierValue === undefined) return;
+
   // Store an aggregator, its presence indicates damage multipliers target this
   // variable
   if (!node.data.multiplierAggregator) node.data.multiplierAggregator = {
-    immunityCount: 0,
-    resistanceCount: 0,
-    vulnerabilityCount: 0,
+    immunities: [],
+    resistances: [],
+    vulnerabilities: [],
   }
   // Store a short reference to the aggregator
   const aggregator = node.data.multiplierAggregator;
-  // Sum the counts of each type of multiplier
+
+  // Make a stripped down copy of the multiplier to store in the aggregator
+  const keysToStore = ['_id', 'name'];
+  if (linkedNode.data.excludeTags?.length){
+    keysToStore.push('excludeTags');
+  }
+  if (linkedNode.data.includeTags?.length){
+    keysToStore.push('includeTags');
+  }
+  const storedMultiplier = pick(linkedNode.data, keysToStore);
+
+  // Store the multiplier in the appropriate field
   if (multiplierValue === 0){
-    aggregator.immunityCount += 1;
+    aggregator.immunities.push(storedMultiplier);
   } else if (multiplierValue === 0.5){
-    aggregator.resistanceCount += 1;
+    aggregator.resistances.push(storedMultiplier);
   } else if (multiplierValue === 2){
-    aggregator.vulnerabilityCount += 1;
+    aggregator.vulnerabilities.push(storedMultiplier);
   }
 }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateDefinition.js

@@ -8,7 +8,13 @@ export default function aggregateDefinition({node, linkedNode, link}){
   // get current defining prop
   const definingProp = node.data.definingProp;
   // Find the last defining prop
-  if (!definingProp || prop.order > definingProp.order){
+  if (
+    !definingProp ||
+    prop.type !== 'pointBuyRow' && (
+      definingProp.type === 'pointBuyRow' ||
+      prop.order > definingProp.order
+    )
+  ) {
     // override the current defining prop
     overrideProp(definingProp, node);
     // set this prop as the new defining prop
@@ -18,9 +24,32 @@ export default function aggregateDefinition({node, linkedNode, link}){
   }
 
   // Aggregate the base value due to the defining properties
-  const propBaseValue = prop.baseValue?.value;
+  let propBaseValue = prop.baseValue?.value;
+  // Point buy rows use prop.value instead of prop.baseValue
+  if (prop.type === 'pointBuyRow') {
+    propBaseValue = prop.value;
+  }
 
   if (propBaseValue === undefined) return;
+  // Store a summary of the definition as a base value effect
+  node.data.effects = node.data.effects || [];
+  if (prop.type === 'pointBuyRow') {
+    node.data.effects.push({
+      _id: prop.tableId,
+      name: prop.tableName,
+      operation: 'base',
+      amount: { value: propBaseValue },
+      type: 'pointBuy',
+    });
+  } else {
+    node.data.effects.push({
+      _id: prop._id,
+      name: prop.name,
+      operation: 'base',
+      amount: { value: propBaseValue },
+      type: prop.type,
+    });
+  }
   if (node.data.baseValue === undefined || propBaseValue > node.data.baseValue){
     node.data.baseValue = propBaseValue;
   }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateEffect.js

@@ -1,4 +1,6 @@
-export default function aggregateEffect({node, linkedNode, link}){
+import { pick } from 'lodash';
+
+export default function aggregateEffect({ node, linkedNode, link }) {
   if (link.data !== 'effect') return;
   // store the effect aggregator, its presence indicates that the variable is
   // targeted by effects
@@ -19,26 +21,39 @@ export default function aggregateEffect({node, linkedNode, link}){
 
   // Store a summary of the effect itself
   node.data.effects = node.data.effects || [];
+  // Store either just 
+  let effectAmount;
+  if (!linkedNode.data.amount) {
+    effectAmount = undefined;
+  } else if (typeof linkedNode.data.amount.value === 'string') {
+    effectAmount = pick(linkedNode.data.amount, [
+      'calculation', 'parseNode', 'parseError', 'value'
+    ]);
+  } else {
+    effectAmount = pick(linkedNode.data.amount, ['value']);
+  }
   node.data.effects.push({
     _id: linkedNode.data._id,
     name: linkedNode.data.name,
     operation: linkedNode.data.operation,
-    amount: linkedNode.data.amount && {value: linkedNode.data.amount.value},
+    amount: effectAmount,
+    type: linkedNode.data.type,
+    text: linkedNode.data.text,
     // ancestors: linkedNode.data.ancestors,
   });
 
   // get a shorter reference to the aggregator document
   const aggregator = node.data.effectAggregator;
   // Get the result of the effect
-  const result = linkedNode.data.amount?.value;
-  // Skip aggregating if the result is not resolved completely
-  if (typeof result === 'string') return;
+  let result = linkedNode.data.amount?.value;
+  if (typeof result !== 'number') result = undefined;
+
   // Aggregate the effect based on its operation
-  switch(linkedNode.data.operation){
+  switch (linkedNode.data.operation) {
     case 'base':
       // Take the largest base value
-      if (Number.isFinite(result)){
-        if(Number.isFinite(aggregator.base)){
+      if (Number.isFinite(result)) {
+        if (Number.isFinite(aggregator.base)) {
           aggregator.base = Math.max(aggregator.base, result);
         } else {
           aggregator.base = result;

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/aggregateEventDefinition.js

@@ -0,0 +1,22 @@
+
+export default function aggregateEventDefinition({ node, linkedNode, link }) {
+  // Look at all event definition links
+  if (link.data !== 'eventDefinition') return;
+
+  // Store which property is THE defining event and which are overridden
+  const prop = linkedNode.data;
+  // get current defining event
+  const definingEvent = node.data.definingEvent;
+  // Find the last defining event
+  if (
+    !definingEvent ||
+    prop.order > definingEvent.order
+  ) {
+    // override the current defining prop
+    if (definingEvent) definingEvent.overridden = true;
+    // set this prop as the new defining prop
+    node.data.definingEvent = prop;
+  } else {
+    prop.overridden = true;
+  }
+}

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/aggregate/index.js

@@ -1,6 +1,7 @@
 import definition from './aggregateDefinition.js';
 import damageMultiplier from './aggregateDamageMultiplier.js';
 import effect from './aggregateEffect.js';
+import eventDefinition from './aggregateEventDefinition.js';
 import proficiency from './aggregateProficiency.js';
 import classLevel from './aggregateClassLevel.js';
 import inventory from './aggregateInventory.js';
@@ -10,6 +11,7 @@ export default Object.freeze({
   damageMultiplier,
   definition,
   effect,
+  eventDefinition,
   inventory,
   proficiency,
 });

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeImplicitVariable.js

@@ -6,6 +6,21 @@ import getAggregatorResult from './getAggregatorResult.js';
  */
  export default function computeImplicitVariable(node){
    const prop = {};
+
+  // Combine damage multipliers
+  if (node.data.immunity){
+    prop.immunity = node.data.immunity;
+    prop.immunities = node.data.immunities;
+  }
+  if (node.data.resistance){
+    prop.resistance = node.data.resistance;
+    prop.resistances = node.data.resistances;
+  }
+  if (node.data.vulnerability){
+    prop.vulnerability = node.data.vulnerability;
+    prop.vulnerabilities = node.data.vulnerabilities;
+  }
+
    const result = getAggregatorResult(node);
    if (result !== undefined){
      prop.value = result;

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeVariableAsAttribute.js

@@ -1,7 +1,7 @@
 import getAggregatorResult from './getAggregatorResult.js';
 
 export default function computeVariableAsAttribute(computation, node, prop){
-  let result = getAggregatorResult(node, prop) || 0;
+  let result = getAggregatorResult(node) || 0;
 
   prop.total = result;
   prop.value = prop.total - (prop.damage || 0);

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/computeVariableAsSkill.js

@@ -29,8 +29,12 @@ export default function computeVariableAsSkill(computation, node, prop){
   }
 
   // Combine everything to get the final result
-  const statBase = node.data.baseValue;
+  const statBase = node.data.baseValue || 0;
   const aggregator = node.data.effectAggregator;
+  const aggregatorBase = aggregator?.base || 0;
+
+  // Store effects
+  prop.effects = node.data.effects;
 
   // If there is no aggregator, determine if the prop can hide, then exit
   if (!aggregator){
@@ -41,7 +45,7 @@ export default function computeVariableAsSkill(computation, node, prop){
     return;
   }
   // Combine aggregator
-  const base = (statBase > aggregator.base ? statBase : aggregator.base) || 0;
+  const base = statBase > aggregatorBase ? statBase : aggregatorBase;
   let result = (base + prop.abilityMod + profBonus + aggregator.add) * aggregator.mul;
   if (result < aggregator.min) result = aggregator.min;
   if (result > aggregator.max) result = aggregator.max;
@@ -83,7 +87,7 @@ function aggregateAbilityEffects({computation, skillNode, abilityNode}){
       // to a skill from its ability
       if (link.data === 'effect'){
         if (![
-          'advantage', 'disadvantage', 'passiveAdd', 'fail'
+          'advantage', 'disadvantage', 'passiveAdd', 'fail', 'conditional'
         ].includes(linkedNode.data.operation)){
           return;
         }

app/imports/api/engine/computation/computeComputation/computeByType/computeVariable/getAggregatorResult.js

@@ -1,15 +1,10 @@
 import stripFloatingPointOddities from '/imports/api/engine/computation/utility/stripFloatingPointOddities.js';
 
 export default function getAggregatorResult(node){
-  // Work out the base value as the greater of the deining stat value or
-  // the damage multiplier value
+  // Work out the base value as the greater of the deining stat value
   // This baseValue comes from aggregating definitions
   let statBase = node.data.baseValue;
 
-  const damageMultiplyValue = node.data.damageMultiplyValue;
-  if (statBase === undefined || damageMultiplyValue > statBase){
-    statBase = damageMultiplyValue;
-  }
   // get a reference to the  aggregator
   const aggregator = node.data.effectAggregator;
 
@@ -34,7 +29,7 @@ export default function getAggregatorResult(node){
   if (aggregator.set !== undefined) {
     result = aggregator.set;
   }
-  if (!node.definingProp?.decimal && Number.isFinite(result)){
+  if (!node.data.definingProp?.decimal && Number.isFinite(result)){
     result = Math.floor(result);
   } else if (Number.isFinite(result)){
     result = stripFloatingPointOddities(result);

app/imports/api/engine/computation/computeComputation/computeToggles.js

@@ -4,7 +4,7 @@ export default function evaluateToggles(computation, node){
   let toggles = prop._computationDetails?.toggleAncestors;
   if (!toggles) return;
   toggles.forEach(toggle => {
-    if (prop.inactive || !toggle.condition) return;
+    if (!toggle.condition) return;
     if (!toggle.condition.value){
       prop.inactive = true;
       prop.deactivatedByToggle = true;

app/imports/api/engine/computation/computeComputation/tests/computeDamageMultipliers.testFn.js

@@ -7,9 +7,11 @@ export default function(){
   const computation = buildComputationFromProps(testProperties);
   computeCreatureComputation(computation);
   const scope = id => computation.scope[id];
-  assert.equal(scope('blugeoningMultiplier').value, 1);
-  assert.equal(scope('customDamageMultiplier').value, 0.5);
-  assert.equal(scope('slashingMultiplier').value, 0);
+  assert.isTrue(scope('blugeoning').vulnerability);
+  assert.isTrue(scope('customDamage').resistance);
+  assert.isNotTrue(scope('customDamage').immunity);
+  assert.isNotTrue(scope('customDamage').vulnerability);
+  assert.isTrue(scope('slashing').immunity);
 }
 
 var testProperties = [

app/imports/api/engine/computation/computeCreatureComputation.js

@@ -51,17 +51,30 @@ function compute(computation, node){
 
 function pushDependenciesToStack(nodeId, graph, stack, computation){
   graph.forEachLinkedNode(nodeId, linkedNode => {
-    if (linkedNode._visitedChildren && !linkedNode._visited){
-      const pather = path.nba(graph, {
-        oriented: true
-      });
-      const loop = pather.find(nodeId, nodeId);
-      computation.errors.push({
-        type: 'dependencyLoop',
-        details: {
-          nodes: loop.map(node => node.id)
-        },
-      });
+    if (linkedNode._visitedChildren && !linkedNode._visited) {
+      // This is a dependency loop, find a path from the node to itself
+      // and store that path as a dependency loop error
+      const pather = path.nba(graph, { oriented: true });
+      let loop = [];
+      // Pather doesn't like going from a node to iteself, so find all the
+      // paths going from the next node back to the original node
+      // and return the shortest one
+      graph.forEachLinkedNode(nodeId, nextNode => {
+        const newLoop = pather.find(nextNode.id, nodeId);
+        if (!newLoop.length) return;
+        if (!loop.length || newLoop.length < loop.length - 1) {
+          loop = [linkedNode, ...newLoop];
+        }
+      }, true);
+      
+      if (loop.length) {
+        computation.errors.push({
+          type: 'dependencyLoop',
+          details: {
+            nodes: loop.map(node => node.id)
+          },
+        });
+      }
     }
     stack.push(linkedNode);
   }, true);

app/imports/api/engine/computation/utility/getEffectivePropTags.js

@@ -0,0 +1,19 @@
+export default function getEffectivePropTags(prop) {
+  if (!prop.tags) return [];
+  const tags = [...prop.tags];
+  // Tags for the property type, separate #damage from #healing
+  if (prop.type === 'damage' && prop.damageType === 'healing') {
+    tags.push('#healing');
+  } else {
+    tags.push(`#${prop.type}`);
+  }
+
+  // Tags for some string properties
+  if (prop.variableName) tags.push(prop.variableName);
+  if (prop.damageType) tags.push(prop.damageType);
+  if (prop.skillType) tags.push(prop.skillType);
+  if (prop.actionType) tags.push(prop.actionType);
+  if (prop.attributeType) tags.push(prop.attributeType);
+  if (prop.reset) tags.push(prop.reset);
+  return tags;
+}

app/imports/api/engine/computation/utility/walkdown.js

@@ -2,7 +2,7 @@ export default function walkDown(tree, callback){
   let stack = [...tree];
   while(stack.length){
     let node = stack.pop();
-    callback(node);
+    callback(node, stack);
     stack.push(...node.children);
   }
 }