Replaced damageProperty with new action engine

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

@@ -1,5 +1,4 @@
 import '/imports/api/creature/creatures/methods/insertCreature';
 import '/imports/api/creature/creatures/methods/removeCreature';
-import '/imports/api/creature/creatures/methods/restCreature';
 import '/imports/api/creature/creatures/methods/updateCreature';
 import '/imports/api/creature/creatures/methods/changeAllowedLibraries';

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

@@ -1,169 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions';
-import { union } from 'lodash';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty';
-import { getFilter } from '/imports/api/parenting/parentingFunctions';
-
-const restCreature = new ValidatedMethod({
-  name: 'creature.methods.rest',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-    restType: {
-      type: String,
-      allowedValues: ['shortRest', 'longRest'],
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-  run({ creatureId, restType }) {
-    // Get action context
-    const actionContext = new ActionContext(creatureId, [creatureId], this);
-    // Check permissions
-    assertEditPermission(actionContext.creature, this.userId);
-
-    // Join, sort, and apply before triggers
-    const beforeTriggers = union(
-      actionContext.triggers.anyRest?.before, actionContext.triggers[restType]?.before
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(beforeTriggers, null, actionContext);
-
-    // Rest
-    actionContext.addLog({
-      name: restType === 'shortRest' ? 'Short rest' : 'Long rest',
-    });
-    doRestWork(restType, actionContext);
-
-    // Join, sort, and apply after triggers
-    const afterTriggers = union(
-      actionContext.triggers.anyRest?.after, actionContext.triggers[restType]?.after
-    ).sort((a, b) => a.order - b.order);
-    applyTriggers(afterTriggers, null, actionContext);
-
-    // Insert log
-    actionContext.writeLog();
-  },
-});
-
-function doRestWork(restType, actionContext) {
-  const creatureId = actionContext.creature._id;
-  // Long rests reset short rest properties as well
-  let resetFilter;
-  if (restType === 'shortRest') {
-    resetFilter = 'shortRest'
-  } else {
-    resetFilter = { $in: ['shortRest', 'longRest'] }
-  }
-  resetProperties(creatureId, resetFilter, actionContext);
-
-  // Reset half hit dice on a long rest, starting with the highest dice
-  if (restType === 'longRest') {
-    resetHitDice(creatureId, actionContext);
-  }
-}
-
-export function resetProperties(creatureId, resetFilter, actionContext) {
-  // Only apply to active properties
-  const filter = {
-    ...getFilter.descendantsOfRoot(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({
-    ...getFilter.descendantsOfRoot(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;