Merge branch 'version-2' into version-2-tabletop

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

@@ -6,23 +6,24 @@ import CreatureProperties from '/imports/api/creature/creatureProperties/Creatur
 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 { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.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 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);
-  }
+  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;
@@ -31,28 +32,29 @@ export default function applyAction(node, {creature, targets, scope, log}){
   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, {creature, 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);
   }
 }
 
-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,
@@ -72,14 +74,15 @@ function applyAttackWithoutTarget({attack, scope, log}){
     scope['$attackMiss'] = {value: true};
   }
 
-  log.content.push({
+  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'];
@@ -87,7 +90,7 @@ function applyAttackToTarget({attack, target, scope, log}){
   delete scope['$attackDiceRoll'];
   delete scope['$attackRoll'];
 
-  recalculateCalculation(attack, scope, log);
+  recalculateCalculation(attack, actionContext);
 
   let {
     resultPrefix,
@@ -108,7 +111,7 @@ function applyAttackToTarget({attack, target, scope, log}){
       name += ' (Disadvantage)';
     }
 
-    log.content.push({
+    actionContext.addLog({
       name,
       value: `${resultPrefix}\n**${result}**`,
       inline: true,
@@ -119,11 +122,11 @@ function applyAttackToTarget({attack, target, scope, log}){
       scope['$attackHit'] = {value: true};
     }
   } else {
-    log.content.push({
+    actionContext.addLog({
       name: 'Error',
       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,
@@ -177,14 +180,15 @@ function applyCrits(value, scope){
   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.silent) actionContext.addLog({
       name: 'Error',
       value: `${prop.name || 'action'} does not have enough uses left`,
     });
@@ -192,7 +196,7 @@ function spendResources({prop, log, scope}){
   }
   // Resources
   if (prop.insufficientResources){
-    log.content.push({
+    if (!prop.silent) actionContext.addLog({
       name: 'Error',
       value: 'This creature doesn\'t have sufficient resources to perform this action',
     });
@@ -204,7 +208,7 @@ function spendResources({prop, log, scope}){
   let gainLog = [];
   try {
     prop.resources.itemsConsumed.forEach(itemConsumed => {
-      recalculateCalculation(itemConsumed.quantity, scope, log);
+      recalculateCalculation(itemConsumed.quantity, actionContext);
       if (!itemConsumed.itemId){
         throw 'No ammo was selected for this prop';
       }
@@ -235,7 +239,7 @@ function spendResources({prop, log, scope}){
       }
     });
   } catch (e){
-    log.content.push({
+    actionContext.addLog({
       name: 'Error',
       value: e,
     });
@@ -253,7 +257,7 @@ function spendResources({prop, log, scope}){
     }, {
       selector: prop
     });
-    log.content.push({
+    if (!prop.silent) actionContext.addLog({
       name: 'Uses left',
       value: prop.usesLeft - 1,
       inline: true,
@@ -262,18 +266,19 @@ 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];
+    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){
       spendLog.push(stat.name + ': ' + attConsumed.quantity.value);
@@ -283,12 +288,12 @@ function spendResources({prop, log, scope}){
   });
 
   // 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,26 +1,27 @@
 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, scope, log);
+        recalculateCalculation(prop.condition, actionContext);
         if (!isFinite(prop.condition?.value)) {
-          log.content.push({
+          actionContext.addLog({
             name: 'Branch Error',
             value: 'Index did not resolve into a valid number'
           });
@@ -29,49 +30,47 @@ export default function applyBranch(node, {
         let index = Math.floor(prop.condition?.value);
         if (index < 1) index = 1;
         if (index > node.children.length) index = node.children.length;
-        applyProperty(node.children[index - 1], {
-          creature, targets, scope, log
-        });
+        applyNodeTriggers(node, 'after', actionContext);
+        applyProperty(node.children[index - 1], actionContext);
       }
       break;
     case 'hit':
       if (scope['$attackHit']?.value){
-        if (!targets.length) log.content.push({value: '**On hit**'});
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On hit**'});
         applyChildren();
       }
       break;
     case 'miss':
       if (scope['$attackMiss']?.value){
-        if (!targets.length) log.content.push({value: '**On miss**'});
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On miss**'});
         applyChildren();
       }
       break;
     case 'failedSave':
       if (scope['$saveFailed']?.value){
-        if (!targets.length) log.content.push({value: '**On failed save**'});
+        if (!targets.length && !prop.silent) actionContext.addLog({value: '**On failed save**'});
         applyChildren();
       }
       break;
     case 'successfulSave':
       if (scope['$saveSucceeded']?.value){
-        if (!targets.length) log.content.push({value: '**On save**',});
+        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';
@@ -12,21 +12,30 @@ 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';
 
-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,
@@ -37,10 +46,10 @@ export default function applyBuff(node, {creature, targets, scope, log}){
     copyNodeListToTarget(propList, target, oldParent);
 
     //Log the buff
-    if (prop.name || prop.description?.value){
-      if (target._id === creature._id){
+    if ((prop.name || prop.description?.value) && !prop.silent) {
+      if (target._id === actionContext.creature._id) {
         // Targeting self
-        log.content.push({
+        actionContext.addLog({
           name: prop.name,
           value: prop.description?.value,
         });
@@ -58,12 +67,13 @@ export default function applyBuff(node, {creature, targets, scope, log}){
       }
     }
   });
+  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,
@@ -83,9 +93,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;
@@ -95,16 +110,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',
               });
@@ -112,8 +127,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;
           }
         });
@@ -121,5 +136,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,28 +1,30 @@
-import { some, intersection, difference } from 'lodash';
+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 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';
 
-export default function applyDamage(node, {
-  creature, targets, scope, log
-}){
+export default function applyDamage(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 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
@@ -37,19 +39,19 @@ export default function applyDamage(node, {
   const logName = prop.damageType === 'healing' ? 'Healing' : 'Damage';
 
   // roll the dice only and store that string
-  applyEffectsToCalculationParseNode(prop.amount, 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, log);
+  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);
+  logErrors(context.errors, actionContext);
 
   // Store the result
   if (reduced.parseType === 'constant'){
@@ -69,6 +71,15 @@ export default function applyDamage(node, {
   // 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 +
@@ -86,15 +97,17 @@ export default function applyDamage(node, {
         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 {
@@ -114,7 +127,7 @@ 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,
@@ -133,21 +146,21 @@ function applyDamageMultipliers({target, damage, damageProp, logValue}){
 
   if (
     multiplier.immunity &&
-    some(multiplier.immunities, multiplierAppliesTo(damageProp))
+    some(multiplier.immunities, multiplierAppliesTo(damageProp, 'immunity'))
   ){
     logValue.push(`Immune to ${damageTypeText}`);
     return 0;
   } else {
     if (
       multiplier.resistance &&
-      some(multiplier.resistances, multiplierAppliesTo(damageProp))
+      some(multiplier.resistances, multiplierAppliesTo(damageProp, 'resistance'))
     ){
       logValue.push(`Resistant to ${damageTypeText}`);
       damage = Math.floor(damage / 2);
     }
     if (
       multiplier.vulnerability &&
-      some(multiplier.vulnerabilities, multiplierAppliesTo(damageProp))
+      some(multiplier.vulnerabilities, multiplierAppliesTo(damageProp, 'vulnerability'))
     ){
       logValue.push(`Vulnerable to ${damageTypeText}`);
       damage = Math.floor(damage * 2);
@@ -156,8 +169,11 @@ function applyDamageMultipliers({target, damage, damageProp, logValue}){
   return damage;
 }
 
-function multiplierAppliesTo(damageProp){
+function multiplierAppliesTo(damageProp, multiplierType){
   return multiplier => {
+    // Apply the default 'ignore x' tags
+    if (includes(damageProp.tags, `ignore ${multiplierType}`)) return false;
+
     const hasRequiredTags = difference(
       multiplier.includeTags, damageProp.tags
     ).length === 0;
@@ -169,3 +185,59 @@ function multiplierAppliesTo(damageProp){
     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;
+  });
+  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

@@ -2,33 +2,34 @@ import applyProperty from '../applyProperty.js';
 import logErrors from './shared/logErrors.js';
 import applyEffectsToCalculationParseNode from '/imports/api/engine/actions/applyPropertyByType/shared/applyEffectsToCalculationParseNode.js';
 import resolve, { toString } from '/imports/parser/resolve.js';
+import { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.js';
 
-export default function applyRoll(node, {creature, targets, scope, log}){
+export default function applyRoll(node, actionContext){
+  applyNodeTriggers(node, 'before', actionContext);
   const prop = node.node;
 
   const applyChildren = function(){
-    node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+    applyNodeTriggers(node, 'after', actionContext);
+    node.children.forEach(child => applyProperty(child, actionContext));
   };
 
   if (prop.roll?.calculation){
     const logValue = [];
 
     // roll the dice only and store that string
-    applyEffectsToCalculationParseNode(prop.roll, log);
-    const {result: rolled, context} = resolve('roll', prop.roll.parseNode, scope);
+    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, log);
+    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, actionContext.scope, context);
+    logErrors(context.errors, actionContext);
 
     // Store the result
     if (reduced.parseType === 'constant'){
@@ -45,11 +46,11 @@ export default function applyRoll(node, {creature, targets, scope, log}){
     }
     const value = reduced.value;
 
-    scope[prop.variableName] = value;
+    actionContext.scope[prop.variableName] = value;
     logValue.push(`**${value}**`);
 
     if (!prop.silent){
-      log.content.push({
+      actionContext.addLog({
         name: prop.name,
         value: logValue.join('\n'),
         inline: true,

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

@@ -2,38 +2,38 @@ 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 { applyNodeTriggers } from '/imports/api/engine/actions/applyTriggers.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({
+    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}**`,
     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};
-    return node.children.forEach(child => applyProperty(child, {
-      creature, targets, scope, log
-    }));
+    scope['$saveSucceeded'] = { value: true };
+    applyNodeTriggers(node, 'after', actionContext);
+    return node.children.forEach(child => applyProperty(child, actionContext));
   }
 
   // Each target makes the saving throw
@@ -43,16 +43,16 @@ export default function applySavingThrow(node, {creature, targets, scope, log}){
     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({
+      actionContext.addLog({
         name: 'Saving throw error',
         value: 'No saving throw found: ' + prop.stat,
       });
@@ -94,7 +94,7 @@ export default function applySavingThrow(node, {creature, targets, scope, log}){
     } else {
       scope['$saveFailed'] = {value: true};
     }
-    log.content.push({
+    if (!prop.silent) actionContext.addLog({
       name: saveSuccess ? 'Successful save' : 'Failed save',
       value: resultPrefix + '\n**' + result + '**',
       inline: true,

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 { 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,48 @@ 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);
 
     // 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 +73,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 +90,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 +106,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}**`,
   });
 }
+
+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,
-},];