Only split properties accross targets if there are targets

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

@@ -4,12 +4,19 @@ export default function applyAttack({
   prop,
   log,
   actionContext,
+  creature,
 }){
   let value = roll(1, 20)[0];
   actionContext.attackRoll = {value};
+  let criticalHitTarget = creature.variables.criticalHitTarget &&
+    creature.variables.criticalHitTarget.currentValue || 20;
+  let criticalHit = value >= criticalHitTarget;
+  if (criticalHit) actionContext.criticalHit = {value: true};
   let result = value + prop.rollBonusResult;
+  actionContext.toHit = {value: result};
+
   log.content.push({
-    name: 'To Hit',
+    name: criticalHit ? 'Critical Hit!' : 'To Hit',
     resultPrefix: `1d20 [${value}] + ${prop.rollBonusResult} = `,
     result,
   });

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

@@ -1,6 +1,7 @@
 import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
 import dealDamage from '/imports/api/creature/creatureProperties/methods/dealDamage.js';
 import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.js';
+import { CompilationContext } from '/imports/parser/parser.js';
 
 export default function applyDamage({
   prop,
@@ -14,8 +15,19 @@ export default function applyDamage({
     ...creature.variables,
     ...actionContext,
   };
+  if (targets.length === 1){
+    scope.target = targets[0].variables;
+  }
+  let criticalHit = !!(
+    actionContext.criticalHit &&
+    actionContext.criticalHit.value &&
+    prop.damageType !== 'healing' // Can't critically heal
+  );
+  let context = new CompilationContext({
+    doubleRolls: criticalHit,
+  });
   try {
-    var {result, errors} = evaluateString(prop.amount, scope, 'reduce');
+    var {result, errors} = evaluateString(prop.amount, scope, 'reduce', context);
     if (typeof result !== 'number') {
       log.content.push({
         error: errors.join(', '),
@@ -26,11 +38,13 @@ export default function applyDamage({
       error: e.toString(),
     });
   }
+  let suffix = (criticalHit ? ' critical ' : '') +
+    prop.damageType +
+    (prop.damageType !== 'healing' ? ' damage': '');
+
   if (damageTargets && damageTargets.length) {
     damageTargets.forEach(target => {
       let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-      let suffix = prop.damageType +
-        prop.damageType !== 'healing' ? ' damage': '';
       if (prop.target === 'each'){
         result = evaluateString(prop.amount, scope, 'reduce');
       }
@@ -69,7 +83,7 @@ export default function applyDamage({
     log.content.push({
       name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
       result,
-      details: `${prop.damageType}${prop.damageType !== 'healing'? ' damage': ''}`,
+      details: suffix,
     });
   }
 }

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

@@ -1,8 +1,11 @@
 import applyAction from '/imports/api/creature/actions/applyAction.js';
 import applyAdjustment from '/imports/api/creature/actions/applyAdjustment.js';
 import applyAttack from '/imports/api/creature/actions/applyAttack.js';
-import applyDamage from '/imports/api/creature/actions/applyDamage.js';
 import applyBuff from '/imports/api/creature/actions/applyBuff.js';
+import applyDamage from '/imports/api/creature/actions/applyDamage.js';
+import applyRoll from '/imports/api/creature/actions/applyRoll.js';
+import applyToggle from '/imports/api/creature/actions/applyToggle.js';
+import applySave from '/imports/api/creature/actions/applySave.js';
 
 function applyProperty(options){
   let prop = options.prop;
@@ -11,8 +14,13 @@ function applyProperty(options){
     if (prop.applied === true){
       return false;
     }
+  // Only ignore toggles if they wont be computed
+  } else if (prop.type === 'toggle') {
+    if (prop.disabled) return false;
+    if (prop.enabled) return true;
+    if (!prop.condition) return false;
   // Ignore inactive props of other types
-  } else if (prop.inactive === true){
+  } else if (prop.deactivatedBySelf === true){
     return false;
   }
   switch (prop.type){
@@ -33,40 +41,40 @@ function applyProperty(options){
     case 'buff':
       applyBuff(options);
       break;
+    case 'toggle':
+      return applyToggle(options);
     case 'roll':
-      // applyRoll(options);
+      applyRoll(options);
       break;
     case 'savingThrow':
-      // applySavingThrow(options);
+      return applySave(options);
-      break;
   }
   return true;
 }
 
-export default function applyProperties({
+function applyPropertyAndWalkChildren({prop, child, targets, ...options}){
-  forest,
+  let shouldKeepWalking = applyProperty({ prop, targets, ...options });
-  creature,
+  if (shouldKeepWalking){
-  targets,
+    applyProperties({ forest: child.children, targets, ...options,});
-  actionContext,
+  }
-  log,
+}
-}){
+
+export default function applyProperties({ forest, targets, ...options}){
   forest.forEach(child => {
-    let walkChildren = applyProperty({
+    let prop = child.node;
-      prop: child.node,
+    if (shouldSplit(prop) && targets.length){
-      children: child.children,
+      targets.forEach(target => {
-      creature,
+        let targets = [target]
-      targets,
+        applyPropertyAndWalkChildren({ targets, prop, child, ...options});
-      actionContext,
-      log,
-    });
-    if (walkChildren){
-      applyProperties({
-        forest: child.children,
-        creature,
-        targets,
-        actionContext,
-        log,
       });
+    } else {
+      applyPropertyAndWalkChildren({prop, child, targets, ...options});
     }
   });
 }
+
+function shouldSplit(prop){
+  if (prop.target === 'each'){
+    return true;
+  }
+}

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

@@ -0,0 +1,32 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+
+export default function applyRoll({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  try {
+    var {result, errors} = evaluateString(prop.roll, scope, 'reduce');
+    actionContext[prop.variableName] = result;
+    log.content.push({
+      name: prop.name,
+      resultPrefix: prop.variableName + ' = ' + prop.roll + ' = ',
+      result,
+    });
+    if (errors.length) {
+      log.content.push({
+        error: errors.join(', '),
+      });
+    }
+
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -0,0 +1,79 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+import CreaturesProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import roll from '/imports/parser/roll.js';
+
+export default function applySave({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  try {
+    // Calculate the DC
+    var {result, errors} = evaluateString(prop.dc, scope, 'reduce');
+    let dc = result;
+    log.content.push({
+      name: prop.name,
+      resultPrefix: ' DC ',
+      result,
+    });
+    if (errors.length) {
+      log.content.push({
+        error: errors.join(', '),
+      });
+      return false;
+    }
+    if (prop.target === 'self'){
+      let save = CreaturesProperties.findOne({
+        'ancestors.id': creature._id,
+        type: 'skill',
+        skillType: 'save',
+        variableName: prop.stat,
+        removed: {$ne: true},
+        inactive: {$ne: true},
+      });
+      if (!save){
+        log.content.push({
+          error: 'No saving throw found: ' + prop.stat,
+        });
+        return;
+      }
+      let value, values, resultPrefix;
+      if (save.advantage === 1){
+        values = roll(2, 20).sort().reverse();
+        value = values[0];
+        resultPrefix = `Advantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
+      } else if (save.advantage === -1){
+        values = roll(2, 20).sort();
+        value = values[0];
+        resultPrefix = `Disadvantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
+      } else {
+        values = roll(1, 20);
+        value = values[0];
+        resultPrefix = `1d20 [${value}] + ${save.value} = `
+      }
+      actionContext.savingThrowRoll = {value};
+      let result = value + save.value;
+      actionContext.savingThrow = {value: result};
+      let saveSuccess = result >= dc;
+      log.content.push({
+        name: 'Save',
+        resultPrefix,
+        result,
+        details: saveSuccess ? 'Passed' : 'Failed'
+      });
+      return !saveSuccess;
+    } else {
+      // TODO
+      return true;
+    }
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -0,0 +1,35 @@
+import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
+
+export default function applyToggle({
+  prop,
+  creature,
+  actionContext,
+  log,
+}){
+  let scope = {
+    ...creature.variables,
+    ...actionContext,
+  };
+  if (Number.isFinite(+prop.condition)){
+    return !!+prop.condition;
+  }
+  try {
+    var {result, errors} = evaluateString(prop.condition, scope, 'reduce');
+    if (typeof result !== 'number' && typeof result !== 'boolean') {
+      log.content.push({
+        error: errors.join(', '),
+      });
+      return false;
+    }
+    log.content.push({
+      name: prop.name,
+      resultPrefix: prop.condition + ' = ',
+      result,
+    });
+    return !!result;
+  } catch (e){
+    log.content.push({
+      error: e.toString(),
+    });
+  }
+}

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

@@ -1,7 +1,7 @@
 import { parse, CompilationContext } from '/imports/parser/parser.js';
 import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
 
-export default function evaluateString(string, scope, fn = 'compile'){
+export default function evaluateString(string, scope, fn = 'compile', context){
   let errors = [];
   if (!string){
     errors.push('No string provided');
@@ -18,7 +18,9 @@ export default function evaluateString(string, scope, fn = 'compile'){
     errors.push(e);
     return {result: string, errors};
   }
-  let context = new CompilationContext();
+  if (!context){
+    context = new CompilationContext({});
+  }
   let result = node[fn](scope, context);
   if (result instanceof ConstantNode){
     return {result: result.value, errors: context.errors}

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

@@ -43,6 +43,13 @@ let CreaturePropertySchema = new SimpleSchema({
     optional: true,
     index: 1,
   },
+  // Denormalised flag if this property was made inactive because of its own
+  // state
+  deactivatedBySelf: {
+    type: Boolean,
+    optional: true,
+    index: 1,
+  },
   // Denormalised list of all properties or creatures this property depends on
   dependencies: {
     type: Array,

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

@@ -20,9 +20,16 @@ export default function recomputeInactiveProperties(ancestorId){
   CreatureProperties.update({
     'ancestors.id': ancestorId,
     '_id': {$in: disabledIds},
-    $or: [{inactive: {$ne: true}}, {deactivatedByAncestor: true}],
+    $or: [
+      {inactive: {$ne: true}},
+      {deactivatedBySelf: {$ne: true}},
+      {deactivatedByAncestor: true},
+    ],
   }, {
-    $set: {inactive: true},
+    $set: {
+      inactive: true,
+      deactivatedBySelf: true,
+    },
     $unset: {deactivatedByAncestor: 1},
   }, {
     multi: true,
@@ -31,7 +38,10 @@ export default function recomputeInactiveProperties(ancestorId){
   // Decendants of inactive properties
   CreatureProperties.update({
     'ancestors.id': {$eq: ancestorId, $in: disabledIds},
-    $or: [{inactive: {$ne: true}}, {deactivatedByAncestor: {$ne: true}}],
+    $or: [
+      {inactive: {$ne: true}},
+      {deactivatedByAncestor: {$ne: true}},
+    ],
   }, {
     $set: {
       inactive: true,
@@ -46,7 +56,10 @@ export default function recomputeInactiveProperties(ancestorId){
   CreatureProperties.update({
     'ancestors.id': {$eq: ancestorId, $nin: disabledIds},
     '_id': {$nin: disabledIds},
-    $or: [{inactive: true}, {deactivatedByAncestor: true}],
+    $or: [
+      {inactive: true},
+      {deactivatedByAncestor: true},
+    ],
   }, {
     $unset: {
       inactive: 1,

app/imports/api/properties/Rolls.js

@@ -1,5 +1,6 @@
 import SimpleSchema from 'simpl-schema';
 import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
+import VARIABLE_NAME_REGEX from '/imports/constants/VARIABLE_NAME_REGEX.js';
 
 /**
  * Rolls are children to actions or other rolls, they are triggered with 0 or
@@ -20,6 +21,17 @@ import ErrorSchema from '/imports/api/properties/subSchemas/ErrorSchema.js';
  *  child rolls are applied
  */
 let RollSchema = new SimpleSchema({
+  name: {
+		type: String,
+    defaultValue: 'New Roll',
+	},
+  // The technical, lowercase, single-word name used in formulae
+  variableName: {
+    type: String,
+		regEx: VARIABLE_NAME_REGEX,
+    min: 2,
+    defaultValue: 'newRoll',
+  },
   // The roll, can be simplified, but only computed in context
   roll: {
     type: String,

app/imports/api/properties/SavingThrows.js

@@ -8,11 +8,22 @@ let SavingThrowSchema = new SimpleSchema ({
     type: String,
     optional: true,
   },
+  // The computed DC
   dc: {
     type: String,
     optional: true,
   },
-  // The variable name of ability the save to roll
+  // Who this saving throw applies to
+	target: {
+		type: String,
+    defaultValue: 'every',
+		allowedValues: [
+      'self',   // the character who took the action
+      'each',   // rolled once for `each` target
+      'every',  // rolled once and applied to `every` target
+    ],
+	},
+  // The variable name of save to roll
   stat: {
     type: String,
     optional: true,

app/imports/ui/properties/forms/RollForm.vue

@@ -1,5 +1,21 @@
 <template lang="html">
   <div class="roll-form">
+    <div class="layout row wrap">
+      <text-field
+        label="Name"
+        :value="model.name"
+        :error-messages="errors.name"
+        @change="change('name', ...arguments)"
+      />
+      <text-field
+        label="Variable name"
+        :value="model.variableName"
+        style="flex-basis: 300px;"
+        hint="Use this name in action formulae to refer to the result of this roll"
+        :error-messages="errors.variableName"
+        @change="change('variableName', ...arguments)"
+      />
+    </div>
     <text-field
       ref="focusFirst"
       label="Roll"

app/imports/ui/properties/forms/SavingThrowForm.vue

@@ -8,6 +8,7 @@
       @change="change('name', ...arguments)"
     />
     <text-field
+      ref="focusFirst"
       label="DC"
       :value="model.dc"
       :error-messages="errors.dc"
@@ -21,6 +22,15 @@
       :error-messages="errors.stat"
       @change="change('stat', ...arguments)"
     />
+    <smart-select
+      label="Target"
+      :hint="targetOptionHint"
+      :items="targetOptions"
+      :value="model.target"
+      :error-messages="errors.target"
+      :menu-props="{auto: true, lazy: true}"
+      @change="change('target', ...arguments)"
+    />
     <smart-combobox
       label="Tags"
       class="mr-2"
@@ -40,5 +50,34 @@ import propertyFormMixin from '/imports/ui/properties/forms/shared/propertyFormM
 
 export default {
   mixins: [saveListMixin, propertyFormMixin],
+  computed: {
+		targetOptions(){
+			return [
+				{
+					text: 'Self',
+					value: 'self',
+				}, {
+					text: 'Roll once for each target',
+					value: 'each',
+				}, {
+					text: 'Roll once and apply to every target',
+					value: 'every',
+				},
+			];
+		},
+		targetOptionHint(){
+			let hints = {
+				self: 'The damage will be applied to the character\'s own attribute when taking the action',
+				target: 'The damage will be applied to the target of the action',
+				each: 'The damage will be rolled separately for each of the targets of the action',
+				every: 'The damage will be rolled once and applied to each of the targets of the action',
+			};
+			if (this.parentTarget === 'singleTarget'){
+				hints.each = hints.target;
+				hints.every = hints.target;
+			}
+			return hints[this.model.target];
+		}
+	},
 };
 </script>