Changed Characters to creatures, as the new attributes system is generalisable

app/Model/Creature/Actions.js

@@ -0,0 +1,40 @@
+Actions = new Mongo.Collection("actions");
+
+/*
+ * Actions are given to a character by items and features
+ */
+Schemas.Action = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	type: {
+		type: String,
+		allowedValues: ["action, bonus, reaction, free"],
+		defaultValue: "action",
+	},
+	//the immediate impact of doing this action (eg. -1 rages)
+	adjustments: {
+		type: [Schemas.Adjustment],
+		defaultValue: [],
+	},
+});
+
+Actions.attachSchema(Schemas.Action);
+
+Actions.attachBehaviour("softRemovable");
+makeChild(Actions);
+
+Actions.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Actions.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Attacks.js

@@ -0,0 +1,87 @@
+Attacks = new Mongo.Collection("attacks");
+
+/*
+ * Attacks are given to a character by items and features
+ */
+Schemas.Attack = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		defaultValue: "New Attack",
+		optional: true,
+		trim: false,
+	},
+	details: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	attackBonus: {
+		type: String,
+		defaultValue: "strengthMod + proficiencyBonus",
+		optional: true,
+		trim: false,
+	},
+	damage: {
+		type: String,
+		defaultValue: "1d8 + {strengthMod}",
+		optional: true,
+		trim: false,
+	},
+	damageType: {
+		type: String,
+		allowedValues: [
+			"bludgeoning",
+			"piercing",
+			"slashing",
+			"acid",
+			"cold",
+			"fire",
+			"force",
+			"lightning",
+			"necrotic",
+			"poison",
+			"psychic",
+			"radiant",
+			"thunder",
+		],
+		defaultValue: "slashing",
+	},
+	//the id of the feature, buff or item that created this effect
+	parent: {
+		type: Schemas.Parent
+	},
+	color: {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+});
+
+Attacks.attachSchema(Schemas.Attack);
+
+Attacks.attachBehaviour("softRemovable");
+makeChild(Attacks, ["name", "enabled"]); //children of lots of things
+
+Attacks.after.insert(function (userId, attack) {
+	//Check to see if this attack's parent is a spell, if so, mirror prepared state to enabled
+	if (attack.parent.collection === "Spells") {
+		var parentSpell = Spells.findOne(attack.parent.id);
+		if (parentSpell.prepared === "unprepared") {
+			Attacks.update(attack._id, {$set: {enabled: false}});
+		} else if (parentSpell.prepared === "prepared" || "always") {
+			Attacks.update(attack._id, {$set: {enabled: true}});
+		}
+	}
+});
+
+Attacks.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Attacks.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Attributes.js

@@ -0,0 +1,70 @@
+Attributes = new Mongo.Collection("attributes");
+
+/*
+ * Attributes are whole numbered stats of a character
+ */
+Schemas.Attribute = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+  // The nice-to-read name
+	name: {
+		type: String,
+	},
+  // The technical, lowercase, single-word name used in formulae
+  variableName: {
+    type: String,
+  },
+  type: {
+    type: String,
+    allowedValues: [
+      "ability", //Strength, Dex, Con, etc.
+      "stat", // Speed, Armor Class
+      "hitDice",
+      "healthBar", // Hitpoints, Temporary Hitpoints
+      "resource", // Rages, sorcery points
+      "spellSlot", // Level 1, 2, 3... spell slots
+      "attribute", // Aren't displayed, Jump height, Carry capacity
+    ],
+  },
+  value: {
+    type: Number,
+    decimal: true,
+  },
+  adjustment: {
+    type: Number,
+    optional: true,
+  },
+  // Can the value be decimal?
+  decimal: {
+    type: Boolean,
+    optional: true,
+  }
+	parent: {
+		type: Schemas.Parent
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+  reset: {
+    type: String,
+    optional: true,
+    allowedValues: ["shortRest", "longRest"],
+  },
+  // Some things are only reset by half on rest
+  resetMultiplier: {
+    type: Number,
+    optional: true,
+  },
+});
+
+Attributes.attachSchema(Schemas.Attribute);
+
+Attributes.attachBehaviour("softRemovable");
+makeChild(Attributes, ["enabled"]); //children of lots of things
+
+Attributes.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Attributes.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Buffs.js

@@ -0,0 +1,67 @@
+Buffs = new Mongo.Collection("buffs");
+
+Schemas.Buff = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+	type: {
+		type: String,
+		allowedValues: [
+			"inate", //this should be "innate", but changing it could be problematic
+			"custom",
+		],
+	},
+	"lifeTime.total": {
+		type: Number,
+		defaultValue: 0, //0 is infinite
+		min: 0,
+	},
+	"lifeTime.spent": {
+		type: Number,
+		defaultValue: 0,
+		min: 0,
+	},
+	color: {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+	appliedBy: { //the charId of whoever applied the buff
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+	},
+	appliedByDetails: {//the name and collection of the thing that applied the buff
+		type: Object,
+		optional: true,
+	},
+	"appliedByDetails.name": {
+		type: String,
+	},
+	"appliedByDetails.collection": {
+		type: String,
+	},
+});
+
+Buffs.attachSchema(Schemas.Buff);
+
+Buffs.attachBehaviour("softRemovable");
+makeParent(Buffs, ["name", "enabled"]); //parents of effects, attacks, proficiencies
+
+Buffs.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Buffs.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/CharacterComputation.js

@@ -0,0 +1,439 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+
+const recomputeCharacter = new ValidatedMethod({
+
+  name: "Characters.methods.recomputeCharacter", // DDP method name
+
+  validate: new SimpleSchema({
+    charId: { type: String }
+  }).validator(),
+
+  run({ charId }) {
+    if (!canEditCharacter(charId, this.userId)) {
+      // Throw errors with a specific error code
+      throw new Meteor.Error('Characters.methods.recomputeCharacter.denied',
+      'You do not have permission to recompute this character');
+    }
+
+    computeCharacterById(charId);
+
+  },
+
+});
+
+/*
+ * This function is the heart of DiceCloud. It recomputes a character's stats,
+ * distilling down effects and proficiencies into the final stats that make up
+ * a character.
+ *
+ * Essentially this is a backtracking algorithm that computes stats'
+ * dependencies before computing stats themselves, while detecting
+ * dependency loops.
+ *
+ * At the moment it makes no effort to limit recomputation to just what was
+ * changed.
+ *
+ * Attempting to implement dependency management to limit recomputation to just
+ * change affected stats should only happen as a last resort, when this function
+ * can no longer be performed more efficiently, and server resources can not be
+ * expanded to meet demand.
+ *
+ * A brief overview:
+ * - Fetch the stats of the character and add them to
+ *   an object for quick lookup
+ * - Fetch the effects and proficiencies which apply to each stat and store them with the stat
+ * - Fetch the class levels and store them as well
+ * - Mark each stat and effect as uncomputed
+ * - Iterate over each stat in order and compute it
+ *   - If the stat is already computed, skip it
+ *   - If the stat is busy being computed, make it NaN and mark computed
+ *   - Mark the stat as busy computing
+ *   - Iterate over each effect which applies to the attribute
+ *     - If the effect is not computed compute it
+ *       - If the effect relies on another attribute, get its computed value
+ *       - Recurse if that attribute is uncomputed
+ *     - apply the effect to the attribute
+ *   - Conglomerate all the effects to compute the final attribute values
+ *   - Mark the attribute as computed
+ */
+const computeCharacterById = function (charId){
+  let char = buildCharacter();
+  char = computeCharacter(char);
+};
+
+/*
+ * Get the character's data from the database and build an in-memory model that
+ * can be computed. Hits 6 database tables with indexed queries.
+ */
+const buildCharacter = function (charId){
+  let char = {
+    atts: {},
+    skills: {},
+    dms: {},
+    classes: {},
+    level: 0,
+  };
+  // Fetch the attributes of the character and add them to an object for quick lookup
+  Attributes.find({charId}).forEach(attribute => {
+    if (!char.atts[attribute.name]){
+      char.atts[attribute.name] = {
+        computed: false,
+        busyComputing: false,
+        type: "attribute",
+        attributeType: attribute.type,
+        result: 0,
+        mod: 0, // The resulting modifier if this is an ability
+        base: 0,
+        add: 0,
+        mul: 1,
+        min: Number.NEGATIVE_INFINITY,
+        max: Number.POSITIVE_INFINITY,
+        effects: [],
+      };
+    }
+  });
+
+  // Fetch the skills of the character and store them
+  Skills.find({charId}).forEach(skill => {
+    if (!char.skills[skill.name]){
+      char.skills[skill.name] = {
+        computed: false,
+        busyComputing: false,
+        type: "skill",
+        ability: skill.ability,
+        result: 0, // For skills the result is the skillMod
+        proficiency: 0,
+        add: 0,
+        mul: 1,
+        min: Number.NEGATIVE_INFINITY,
+        max: Number.POSITIVE_INFINITY,
+        advantage: 0,
+        disadvantage: 0,
+        passiveAdd: 0,
+        fail: 0,
+        conditional: 0,
+        effects: [],
+        proficiencies: [],
+      };
+    }
+  });
+
+  // Fetch the damage multipliers of the character and store them
+  DamageMultipliers.find({charId}).forEach(damageMultiplier =>{
+    if (!char.dms[damageMultiplier.name]){
+      char.dms[damageMultiplier.name] = {
+        computed: false,
+        busyComputing: false,
+        type: "damageMultiplier",
+        result: 0,
+        immunityCount: 0,
+        ressistanceCount: 0,
+        vulnerabilityCount: 0,
+        effects: [],
+      };
+    }
+  });
+
+  // Fetch the class levels and store them
+  // don't use the word "class" it's reserved
+  Classes.find({charId}).forEach(cls => {
+    if (!char.classes[cls.name]){
+      char.classes[cls.name] = {level: cls.level};
+      char.level += cls.level;
+    }
+  });
+
+  // Fetch the effects which apply to each stat and store them under the attribute
+  Effects.find({
+    charId: charId,
+    enabled: true,
+  }).forEach(effect => {
+    let storedEffect = {
+      computed: false,
+      result: 0,
+      operation: effect.operation,
+      value: effect.value,
+      calculation: effect.calculation,
+    }
+    if (char.atts[effect.stat]) {
+      char.atts[effect.stat].effects.push(storedEffect);
+    } else if (char.skills[effect.stat]) {
+      char.skills[effect.stat].effects.push(storedEffect);
+    } else if (char.dms[effect.stat]) {
+      char.dms[effect.stat].effects.push(storedEffect);
+    } else {
+      // ignore effects that don't apply to an actual stat
+    }
+  });
+
+  // Fetch the proficiencies and store them under each skill
+  Proficiencies.find({
+    charId: charId,
+    enabled: true,
+    type: {$in: ["skill", "save"]}
+  }).forEach(proficiency => {
+    if (char.skills[proficiency.name]) {
+      char.skills[proficiency.name].proficiencies.push(effect);
+    }
+  });
+  return char;
+}
+
+/*
+ * Compute the character's stats in-place, returns the same char object
+ */
+export const computeCharacter = function (char){
+  // Iterate over each stat in order and compute it
+  for (statName in char.atts){
+    let stat = char.atts[statName]
+    computeStat (stat, char);
+  }
+  for (statName in char.skills){
+    let stat = char.skills[statName]
+    computeStat (stat, char);
+  }
+  for (statName in char.dms){
+    let stat = char.dms[statName]
+    computeStat (stat, char);
+  }
+  return char;
+}
+
+/*
+ * Compute a single stat on a character
+ */
+const computeStat = function(stat, char){
+  // If the stat is already computed, skip it
+  if (stat.computed) return;
+
+  // If the stat is busy being computed, make it NaN and mark computed
+  if (stat.busyComputing){
+    // Trying to compute this stat again while it is already computing.
+    // We must be in a dependency loop.
+    stat.computed = true;
+    stat.result = NaN;
+    stat.busyComputing = false;
+    return;
+  }
+
+  // Iterate over each effect which applies to the stat
+  for (i in stat.effects){
+    computeEffect(stat.effects[i], char);
+    // apply the effect to the stat
+    applyEffect(stat.effects[i], stat);
+  }
+
+  // Conglomerate all the effects to compute the final stat values
+  combineStat(stat, char);
+
+  // Mark the attribute as computed
+  stat.computed = true;
+  stat.busyComputing = false;
+}
+
+/*
+ * Compute a single effect on a character
+ */
+const computeEffect = function(effect, char){
+  if (effect.computed) return;
+  if (_.isFinite(effect.value)){
+		effect.result = effect.value;
+	} else if(effect.operation === "conditional"){
+    effect.result = effect.calculation;
+  } else if(_.contains(["advantage", "disadvantage", "fail"], effect.operation)){
+    effect.result = 1;
+  } else if (_.isString(effect.calculation)){
+		effect.result = evaluateCalculation(effect.calculation, char);
+	}
+  effect.computed = true;
+  console.log({effect});
+};
+
+/*
+ * Apply a computed effect to its stat
+ */
+const applyEffect = function(effect, stat){
+  // Take the largest base value
+  if (effect.operation === "base"){
+    if (!_.has(stat, "base")) return;
+    stat.base = effect.result > stat.base ? effect.result : stat.base;
+  }
+  // Add all adds together
+  else if (effect.operation === "add"){
+    if (!_.has(stat, "add")) return;
+    stat.add += effect.result;
+  }
+  else if (effect.operation === "mul"){
+    if (!_.has(stat, "mul")) return;
+    if (stat.type === "damageMultiplier"){
+      if (value === 0) stat.immunityCount++;
+      else if (value === 0.5) stat.ressistanceCount++;
+      else if (value === 2) stat.vulnerabilityCount++;
+    } else {
+      // Multiply all muls together
+      stat.mul *= effect.result;
+    }
+  }
+  // Take the largest min value
+  if (effect.operation === "min"){
+    if (!_.has(stat, "min")) return;
+    stat.min = effect.result > stat.min ? effect.result : stat.min;
+  }
+  // Take the smallest max value
+  if (effect.operation === "max"){
+    if (!_.has(stat, "max")) return;
+    stat.max = effect.result < stat.max ? effect.result : stat.max;
+  }
+  // Sum number of advantages
+  else if (effect.operation === "advantage"){
+    if (!_.has(stat, "advantage")) return;
+    stat.advantage++;
+  }
+  // Sum number of disadvantages
+  else if (effect.operation === "disadvantage"){
+    if (!_.has(stat, "disadvantage")) return;
+    stat.disadvantage++;
+  }
+  // Add all passive adds together
+  else if (effect.operation === "passiveAdd"){
+    if (!_.has(stat, "passiveAdd")) return;
+    stat.passiveAdd += effect.result;
+  }
+  // Sum number of fails
+  else if (effect.operation === "fail"){
+    if (!_.has(stat, "fail")) return;
+    stat.fail++;
+  }
+  // Sum number of conditionals
+  else if (effect.operation === "conditional"){
+    if (!_.has(stat, "conditional")) return;
+    stat.conditional++;
+  }
+};
+
+/*
+ * Combine the results of multiple effects to get the result of the stat
+ */
+const combineStat = function(stat, char){
+  if (stat.type === "attribute"){
+    combineAttribute(stat, char)
+  } else if (stat.type === "skill"){
+    combineSkill(stat, char)
+  } else if (stat.type === "damageMultiplier"){
+    combineDamageMultiplier(stat, char);
+  }
+}
+
+const combineAttribute = function(stat, char){
+  stat.result = (stat.base + stat.add) * stat.mul;
+  if (stat.result < stat.min) stat.result = stat.min;
+  if (stat.result > stat.max) stat.result = stat.max;
+  // Round everything that isn't the carry multiplier
+  if (!stat.decimal) stat.result = Math.floor(stat.result);
+  if (stat.attributeType === "ability") {
+    stat.mod = Math.floor((stat.result - 10) / 2);
+  }
+  console.log({statResult: stat.result})
+}
+
+const combineSkill = function(stat, char){
+  for (i in stat.proficiencies){
+    let prof = stat.proficiencies[i];
+    if (prof.value > stat.proficiency) stat.proficiency = prof.value;
+  }
+  let profBonus;
+  if (char.atts.proificiencyBonus){
+    if (!char.atts.proficiencyBonus.computed){
+      computeStat(char.atts.proficiencyBonus, char);
+    }
+    profBonus = char.atts.proficiencyBonus.result;
+  } else {
+    profBonus = Math.floor(char.level / 4 + 1.75);
+  }
+  profBonus *= stat.proficiency;
+  // Skills are based on some ability Modifier
+  let abilityMod = 0;
+  if (stat.ability && char.atts[stat.ability]){
+    if (!char.atts[stat.ability].computed){
+      computeStat(char.atts[stat.ability], char);
+    }
+    abilityMod = char.atts[stat.ability].mod;
+  }
+  stat.result = (abilityMod + profBonus + stat.add) * stat.mul;
+  if (stat.result < stat.min) stat.result = stat.min;
+  if (stat.result > stat.max) stat.result = stat.max;
+  stat.result = Math.floor(stat.result);
+}
+
+const combineDamageMultiplier = function(stat, char){
+  if (stat.immunityCount) return 0;
+  if (stat.ressistanceCount && !stat.vulnerabilityCount){
+    stat.result = 0.5;
+  }  else if (!stat.ressistanceCount && stat.vulnerabilityCount){
+    stat.result = 2;
+  } else {
+    stat.result = 1;
+  }
+}
+
+// Evaluate a string computation
+const evaluateCalculation = function(string, char){
+  if (!string) return string;
+
+  // Replace all the string variables with numbers if possible
+  string = string.replace(/\b[a-z,1-9]+\b/gi, function(sub){
+    // Make case insensitive
+    sub = sub.toLowerCase()
+    // Attributes
+    if (char.atts[sub]){
+      if (!char.atts[sub].computed){
+        computeStat(char.atts[sub], char);
+      }
+      return char.atts[sub].result;
+    }
+    // Modifiers
+    if (/^\w+mod$/.test(sub)){
+      var slice = sub.slice(0, -3);
+      if (char.atts[slice]){
+        if (!char.atts[slice].computed){
+          computeStat(char.atts[sub], char);
+        }
+        return char.atts[slice].mod || NaN;
+      }
+    }
+    // Skills
+    if (char.skills[sub]){
+      if (!char.skills[sub].computed){
+        computeStat(char.skills[sub], char);
+      }
+      return char.skills[sub].result;
+    }
+    // Damage Multipliers
+    if (char.dms[sub]){
+      if (!char.dms[sub].computed){
+        computeStat(char.dms[sub], char);
+      }
+      return char.dms[sub].result;
+    }
+    // Class levels
+    if (/^\w+levels?$/.test(sub)){
+      //strip out "level(s)"
+      var className = sub.replace(/levels?$/, "");
+      return char.classes[className] && char.classes[className].level || sub;
+    }
+    // Character level
+    if (sub  === "level"){
+      return char.level;
+    }
+    // Give up
+    return sub;
+  });
+
+  // Evaluate the expression to a number or return it as is.
+  try {
+    var result = math.eval(string); // math.eval is safe
+    return result;
+  } catch (e){
+    return string;
+  }
+};

app/Model/Creature/CharacterComputation.test.js

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

app/Model/Creature/Characters.js

@@ -0,0 +1,589 @@
+//set up the collection for characters
+Characters = new Mongo.Collection("characters");
+
+Schemas.Character = new SimpleSchema({
+	//strings
+	name:         {type: String, defaultValue: "", trim: false, optional: true},
+	urlName:      {type: String, defaultValue: "-", trim: false, optional: true},
+	alignment:    {type: String, defaultValue: "", trim: false, optional: true},
+	gender:       {type: String, defaultValue: "", trim: false, optional: true},
+	race:         {type: String, defaultValue: "", trim: false, optional: true},
+	picture:      {type: String, defaultValue: "", trim: true,  optional: true},
+	description:  {type: String, defaultValue: "", trim: false, optional: true},
+	personality:  {type: String, defaultValue: "", trim: false, optional: true},
+	ideals:       {type: String, defaultValue: "", trim: false, optional: true},
+	bonds:        {type: String, defaultValue: "", trim: false, optional: true},
+	flaws:        {type: String, defaultValue: "", trim: false, optional: true},
+	backstory:    {type: String, defaultValue: "", trim: false, optional: true},
+
+	//attributes
+	//ability scores
+	strength:         {type: Schemas.Attribute},
+	dexterity:        {type: Schemas.Attribute},
+	constitution:     {type: Schemas.Attribute},
+	intelligence:     {type: Schemas.Attribute},
+	wisdom:           {type: Schemas.Attribute},
+	charisma:         {type: Schemas.Attribute},
+
+	//stats
+	hitPoints:        {type: Schemas.Attribute},
+	tempHP:           {type: Schemas.Attribute},
+	experience:       {type: Schemas.Attribute},
+	proficiencyBonus: {type: Schemas.Attribute},
+	speed:            {type: Schemas.Attribute},
+	weight:           {type: Schemas.Attribute},
+	age:              {type: Schemas.Attribute},
+	ageRate:          {type: Schemas.Attribute},
+	armor:            {type: Schemas.Attribute},
+	carryMultiplier:  {type: Schemas.Attribute},
+
+	//resources
+	level1SpellSlots: {type: Schemas.Attribute},
+	level2SpellSlots: {type: Schemas.Attribute},
+	level3SpellSlots: {type: Schemas.Attribute},
+	level4SpellSlots: {type: Schemas.Attribute},
+	level5SpellSlots: {type: Schemas.Attribute},
+	level6SpellSlots: {type: Schemas.Attribute},
+	level7SpellSlots: {type: Schemas.Attribute},
+	level8SpellSlots: {type: Schemas.Attribute},
+	level9SpellSlots: {type: Schemas.Attribute},
+	ki:               {type: Schemas.Attribute},
+	sorceryPoints:    {type: Schemas.Attribute},
+	rages:            {type: Schemas.Attribute},
+	superiorityDice:  {type: Schemas.Attribute},
+	expertiseDice:    {type: Schemas.Attribute},
+
+	//specific features
+	rageDamage:       {type: Schemas.Attribute},
+
+	//hit dice
+	d6HitDice:        {type: Schemas.Attribute},
+	d8HitDice:        {type: Schemas.Attribute},
+	d10HitDice:       {type: Schemas.Attribute},
+	d12HitDice:       {type: Schemas.Attribute},
+
+	//vulnerabilities
+	acidMultiplier:        {type: Schemas.Attribute},
+	bludgeoningMultiplier: {type: Schemas.Attribute},
+	coldMultiplier:        {type: Schemas.Attribute},
+	fireMultiplier:        {type: Schemas.Attribute},
+	forceMultiplier:       {type: Schemas.Attribute},
+	lightningMultiplier:   {type: Schemas.Attribute},
+	necroticMultiplier:    {type: Schemas.Attribute},
+	piercingMultiplier:    {type: Schemas.Attribute},
+	poisonMultiplier:      {type: Schemas.Attribute},
+	psychicMultiplier:     {type: Schemas.Attribute},
+	radiantMultiplier:     {type: Schemas.Attribute},
+	slashingMultiplier:    {type: Schemas.Attribute},
+	thunderMultiplier:     {type: Schemas.Attribute},
+
+	//skills
+	//saves
+	strengthSave:    {type: Schemas.Skill},
+	"strengthSave.ability":     {type: String, defaultValue: "strength"},
+
+	dexteritySave:	 {type: Schemas.Skill},
+	"dexteritySave.ability":    {type: String, defaultValue: "dexterity"},
+
+	constitutionSave:{type: Schemas.Skill},
+	"constitutionSave.ability": {type: String, defaultValue: "constitution"},
+
+	intelligenceSave:{type: Schemas.Skill},
+	"intelligenceSave.ability":	{type: String, defaultValue: "intelligence"},
+
+	wisdomSave:      {type: Schemas.Skill},
+	"wisdomSave.ability":       {type: String, defaultValue: "wisdom"},
+
+	charismaSave:    {type: Schemas.Skill},
+	"charismaSave.ability":     {type: String, defaultValue: "charisma"},
+
+	//skill skills
+	acrobatics:      {type: Schemas.Skill},
+	"acrobatics.ability":       {type: String, defaultValue: "dexterity"},
+
+	animalHandling:  {type: Schemas.Skill},
+	"animalHandling.ability":   {type: String, defaultValue: "wisdom"},
+
+	arcana:          {type: Schemas.Skill},
+	"arcana.ability":           {type: String, defaultValue: "intelligence"},
+
+	athletics:       {type: Schemas.Skill},
+	"athletics.ability":        {type: String, defaultValue: "strength"},
+
+	deception:       {type: Schemas.Skill},
+	"deception.ability":        {type: String, defaultValue: "charisma"},
+
+	history:        {type: Schemas.Skill},
+	"history.ability":          {type: String, defaultValue: "intelligence"},
+
+	insight:        {type: Schemas.Skill},
+	"insight.ability":          {type: String, defaultValue: "wisdom"},
+
+	intimidation:   {type: Schemas.Skill},
+	"intimidation.ability":		{type: String, defaultValue: "charisma"},
+
+	investigation:	{type: Schemas.Skill},
+	"investigation.ability":	{type: String, defaultValue: "intelligence"},
+
+	medicine:		{type: Schemas.Skill},
+	"medicine.ability":        {type: String, defaultValue: "wisdom"},
+
+	nature:			{type: Schemas.Skill},
+	"nature.ability":          {type: String, defaultValue: "intelligence"},
+
+	perception:		{type: Schemas.Skill},
+	"perception.ability":      {type: String, defaultValue: "wisdom"},
+
+	performance:	{type: Schemas.Skill},
+	"performance.ability":     {type: String, defaultValue: "charisma"},
+
+	persuasion:     {type: Schemas.Skill},
+	"persuasion.ability":      {type: String, defaultValue: "charisma"},
+
+	religion:       {type: Schemas.Skill},
+	"religion.ability":        {type: String, defaultValue: "intelligence"},
+
+	sleightOfHand:	{type: Schemas.Skill},
+	"sleightOfHand.ability":	{type: String, defaultValue: "dexterity"},
+
+	stealth:		{type: Schemas.Skill},
+	"stealth.ability":          {type: String, defaultValue: "dexterity"},
+
+	survival:		{type: Schemas.Skill},
+	"survival.ability":         {type: String, defaultValue: "wisdom"},
+
+	//Mechanical Skills
+	initiative:      {type: Schemas.Skill},
+	"initiative.ability":		{type: String, defaultValue: "dexterity"},
+
+	dexterityArmor:		{type: Schemas.Skill},
+	"dexterityArmor.ability":	{type: String, defaultValue: "dexterity"},
+
+	//mechanics
+	deathSave:      {type: Schemas.DeathSave},
+
+	//permissions
+	party:   {type: String, regEx: SimpleSchema.RegEx.Id, optional: true},
+	owner:   {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	readers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: [], index: 1},
+	writers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: [], index: 1},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+	//TODO add per-character settings
+	//how many experiences to load at a time in XP table
+	"settings.experiencesInc": {type: Number, defaultValue: 20},
+	//slowed down by carrying too much?
+	"settings.useVariantEncumbrance": {type: Boolean, defaultValue: false},
+	"settings.useStandardEncumbrance": {type: Boolean, defaultValue: true},
+	//hide spellcasting
+	"settings.hideSpellcasting": {type: Boolean, defaultValue: false},
+	//show to anyone with link
+	"settings.viewPermission": {
+		type: String,
+		defaultValue: "whitelist",
+		allowedValues: ["whitelist", "public"],
+		index: 1,
+	},
+	"settings.swapStatAndModifier": {type: Boolean, defaultValue: false},
+	"settings.exportFeatures": {type: Boolean, defaultValue: true},
+	"settings.exportAttacks": {type: Boolean, defaultValue: true},
+	"settings.exportDescription": {type: Boolean, defaultValue: true},
+	"settings.newUserExperience": {type: Boolean, optional: true},
+});
+
+Characters.attachSchema(Schemas.Character);
+
+var attributeBase = preventLoop(function(charId, statName){
+	check(statName, String);
+	//if it's a damage multiplier, we treat it specially
+	if (_.contains(DAMAGE_MULTIPLIERS, statName)){
+		var invulnerabilityCount = Effects.find({
+			charId: charId,
+			stat: statName,
+			enabled: true,
+			operation: "mul",
+			value: 0,
+		}).count();
+		if (invulnerabilityCount) return 0;
+		var resistCount = Effects.find({
+			charId: charId,
+			stat: statName,
+			enabled: true,
+			operation: "mul",
+			value: 0.5,
+		}).count();
+		var vulnCount = Effects.find({
+			charId: charId,
+			stat: statName,
+			enabled: true,
+			operation: "mul",
+			value: 2,
+		}).count();
+		if (!resistCount && !vulnCount){
+			return 1;
+		}  else if (resistCount && !vulnCount){
+			return 0.5;
+		}  else if (!resistCount && vulnCount){
+			return 2;
+		} else {
+			return 1;
+		}
+	}
+	var value;
+	var base = 0;
+	var add = 0;
+	var mul = 1;
+	var min = Number.NEGATIVE_INFINITY;
+	var max = Number.POSITIVE_INFINITY;
+
+	Effects.find({
+		charId: charId,
+		stat: statName,
+		enabled: true,
+		operation: {$in: ["base", "add", "mul", "min", "max"]},
+	}).forEach(function(effect) {
+		value = evaluateEffect(charId, effect);
+		if (effect.operation === "base"){
+			if (value > base) base = value;
+		} else if (effect.operation === "add"){
+			add += value;
+		} else if (effect.operation === "mul"){
+			mul *= value;
+		} else if (effect.operation === "min"){
+			if (value > min) min = value;
+		} else if (effect.operation === "max"){
+			if (value < max) max = value;
+		}
+	});
+
+	var result = (base + add) * mul;
+	if (result < min) result = min;
+	if (result > max) result = max;
+	// Don't round carry multiplier
+	if (statName === "carryMultiplier"){
+		return result;
+	}
+	return Math.floor(result);
+});
+
+if (Meteor.isClient) {
+	Template.registerHelper("characterCalculate", function(func, charId, input) {
+		try {
+			return Characters.calculate[func](charId, input);
+		} catch (e){
+			if (!Characters.calculate[func]){
+				throw new Error(func + "is not a function name");
+			} else {
+				throw e;
+			}
+		}
+	});
+}
+
+//create a local memoize with a argument concatenating hash function
+var memoize = function(f) {
+	if (Meteor.isServer) return f;
+	return Tracker.memoize(f, function() {
+		return _.reduce(arguments, function(memo, arg) {
+			return memo + arg;
+		}, "");
+	});
+};
+
+//memoize funcitons that have finds and slow loops
+Characters.calculate = {
+	getField: function(charId, fieldName) {
+		var fieldSelector = {};
+		fieldSelector[fieldName] = 1;
+		var char = Characters.findOne(charId, {fields: fieldSelector});
+		if (!char) return;
+		var field = char[fieldName];
+		if (field === undefined){
+			throw new Meteor.Error(
+				"getField failed",
+				"getField could not find field " +
+				fieldName +
+				" in character " +
+				char._id
+			);
+		}
+		return field;
+	},
+	fieldValue: function(charId, fieldName) {
+		if (!Schemas.Character.schema(fieldName)){
+			throw new Meteor.Error(
+				"Field not found",
+				"Character's schema does not contain a field called: " + fieldName
+			);
+		}
+		//duck typing to get the right value function
+		//.ability implies skill
+		if (Schemas.Character.schema(fieldName + ".ability")){
+			return Characters.calculate.skillMod(charId, fieldName);
+		}
+		//adjustment implies attribute
+		if (Schemas.Character.schema(fieldName + ".adjustment")){
+			return Characters.calculate.attributeValue(charId, fieldName);
+		}
+		//fall back to just returning the field itself
+		return Characters.calculate.getField(charId, fieldName);
+	},
+	attributeValue: memoize(function(charId, attributeName){
+		var attribute = Characters.calculate.getField(charId, attributeName);
+		if (!attribute) return;
+		//base value
+		var value = Characters.calculate.attributeBase(charId, attributeName);
+		//plus adjustment
+		value += attribute.adjustment;
+		return value;
+	}),
+	attributeBase: memoize(function(charId, attributeName){
+		return attributeBase(charId, attributeName);
+	}),
+	skillMod: memoize(preventLoop(function(charId, skillName){
+		var skill = Characters.calculate.getField(charId, skillName);
+		if (!skill) return;
+		//get the final value of the ability score
+		var ability = Characters.calculate.attributeValue(charId, skill.ability);
+
+		//base modifier
+		var mod = +getMod(ability);
+
+		//multiply proficiency bonus by largest value in proficiency array
+		var prof = Characters.calculate.proficiency(charId, skillName);
+
+		//add multiplied proficiency bonus to modifier
+		mod += prof * Characters.calculate.attributeValue(charId, "proficiencyBonus");
+
+		//apply all effects
+		var value;
+		var add = 0;
+		var mul = 1;
+		var min = Number.NEGATIVE_INFINITY;
+		var max = Number.POSITIVE_INFINITY;
+
+		Effects.find({
+			charId: charId,
+			stat: skillName,
+			enabled: true,
+			operation: {$in: ["base", "add", "mul", "min", "max"]},
+		}).forEach(function(effect) {
+			value = evaluateEffect(charId, effect);
+			if (effect.operation === "add"){
+				add += value;
+			} else if (effect.operation === "mul"){
+				mul *= value;
+			} else if (effect.operation === "min"){
+				if (value > min) min = value;
+			} else if (effect.operation === "max"){
+				if (value < max) max = value;
+			}
+		});
+		var result = (mod + add) * mul;
+		if (result < min) result = min;
+		if (result > max) result = max;
+
+		return Math.floor(result);
+	})),
+	proficiency: memoize(function(charId, skillName){
+		//return largest value in proficiency array
+		var prof = Proficiencies.findOne(
+			{charId: charId, name: skillName, enabled: true},
+			{sort: {value: -1}}
+		);
+		return prof && prof.value || 0;
+	}),
+	passiveSkill: memoize(function(charId, skillName){
+		var mod = +Characters.calculate.skillMod(charId, skillName);
+		var value = 10 + mod;
+		Effects.find(
+			{charId: charId, stat: skillName, enabled: true, operation: "passiveAdd"}
+		).forEach(function(effect){
+			value += evaluateEffect(charId, effect);
+		});
+		var advantage = Characters.calculate.advantage(charId, skillName);
+		value += 5 * advantage;
+		return Math.floor(value);
+	}),
+	advantage: memoize(function(charId, skillName){
+		var advantage = Effects.find(
+			{charId: charId, stat: skillName, enabled: true, operation: "advantage"}
+		).count();
+		var disadvantage = Effects.find(
+			{charId: charId, stat: skillName, enabled: true, operation: "disadvantage"}
+		).count();
+		if (advantage && !disadvantage) return 1;
+		if (disadvantage && !advantage) return -1;
+		return 0;
+	}),
+	abilityMod: function(charId, attribute){
+		return getMod(
+			Characters.calculate.attributeValue(charId, attribute)
+		);
+	},
+	passiveAbility: function(charId, attribute){
+		var mod = +getMod(Characters.calculate.attributeValue(charId, attribute));
+		return 10 + mod;
+	},
+	xpLevel: function(charId){
+		var xp = Characters.calculate.experience(charId);
+		for (var i = 0; i < 19; i++){
+			if (xp < XP_TABLE[i]){
+				return i;
+			}
+		}
+		if (xp > 355000) return 20;
+		return 0;
+	},
+	level: memoize(function(charId){
+		var level = 0;
+		Classes.find({charId: charId}).forEach(function(cls){
+			level += cls.level;
+		});
+		return level;
+	}),
+	experience: memoize(function(charId){
+		var xp = 0;
+		Experiences.find(
+			{charId: charId},
+			{fields: {value: 1}}
+		).forEach(function(e){
+			xp += e.value;
+		});
+		return xp;
+	}),
+};
+
+var deprecated = function() {
+	//var err = new Error("this function has been deprecated");
+	var name = "";
+	if (Template.instance()){
+		name = Template.instance().view.name;
+	}
+	var logString = "this function has been deprecated \n";
+	if (name){
+		logString += "View: " + name + "\n\n";
+	}
+	//logString += err.stack + "\n\n---------------------\n\n";
+	console.log(logString);
+};
+
+//functions and calculated values.
+//These functions can only rely on this._id since no other
+//field is likely to be attached to all returned characters
+Characters.helpers({
+	//returns the value stored in the field requested
+	//will set up dependencies on just that field
+	getField : function(fieldName){
+		deprecated();
+		return Characters.calculate.getField(this._id, fieldName);
+	},
+	//returns the value of a field
+	fieldValue : function(fieldName){
+		deprecated();
+		return Characters.calculate.fieldValue(this._id, fieldName);
+	},
+	attributeValue: function(attributeName){
+		deprecated();
+		return Characters.calculate.attributeValue(this._id, attributeName);
+	},
+	attributeBase: function(attributeName){
+		deprecated();
+		return Characters.calculate.attributeBase(this._id, attributeName);
+	},
+	skillMod: function(skillName){
+		deprecated();
+		return Characters.calculate.skillMod(this._id, skillName);
+	},
+	proficiency: function(skillName){
+		deprecated();
+		return Characters.calculate.proficiency(this._id, skillName);
+	},
+	passiveSkill: function(skillName){
+		deprecated();
+		return Characters.calculate.passiveSkill(this._id, skillName);
+	},
+	advantage: function(skillName){
+		deprecated();
+		return Characters.calculate.advantage(this._id, skillName);
+	},
+	abilityMod: function(attribute){
+		deprecated();
+		return Characters.calculate.abilityMod(this._id, attribute);
+	},
+	passiveAbility: function(attribute){
+		deprecated();
+		return Characters.calculate.passiveAbility(this._id, attribute);
+	},
+	xpLevel: function(){
+		deprecated();
+		return Characters.calculate.xpLevel(this._id);
+	},
+	level: function(){
+		deprecated();
+		return Characters.calculate.level(this._id);
+	},
+	experience: function(){
+		deprecated();
+		return Characters.calculate.experience(this._id);
+	},
+});
+
+//clean up all data related to that character before removing it
+if (Meteor.isServer){
+	Characters.after.remove(function(userId, character) {
+		Actions       .remove({charId: character._id});
+		Attacks       .remove({charId: character._id});
+		Buffs         .remove({charId: character._id});
+		Classes       .remove({charId: character._id});
+		CustomBuffs   .remove({charId: character._id});
+		Effects       .remove({charId: character._id});
+		Experiences   .remove({charId: character._id});
+		Features      .remove({charId: character._id});
+		Notes         .remove({charId: character._id});
+		Proficiencies .remove({charId: character._id});
+		SpellLists    .remove({charId: character._id});
+		Items         .remove({charId: character._id});
+		Containers    .remove({charId: character._id});
+	});
+	Characters.after.update(function(userId, doc, fieldNames, modifier, options) {
+		if (_.contains(fieldNames, "name")){
+			var urlName = getSlug(doc.name, {maintainCase: true}) || "-";
+			Characters.update(doc._id, {$set: {urlName}});
+		}
+	});
+	Characters.before.insert(function(userId, doc) {
+		doc.urlName = getSlug(doc.name, {maintainCase: true}) || "-";
+		// The first character a user creates should have the new user experience
+		if (!Characters.find({owner: userId}).count()){
+			doc.settings.newUserExperience = true;
+		}
+	});
+}
+
+Characters.allow({
+	insert: function(userId, doc) {
+		// the user must be logged in, and the document must be owned by the user
+		return (userId && doc.owner === userId);
+	},
+	update: function(userId, doc, fields, modifier) {
+		// can only change documents you have write access to
+		return doc.owner === userId ||
+			_.contains(doc.writers, userId);
+	},
+	remove: function(userId, doc) {
+		// can only remove your own documents
+		return doc.owner === userId;
+	},
+	fetch: ["owner", "writers"],
+});
+
+Characters.deny({
+	update: function(userId, docs, fields, modifier) {
+		// can't change owners
+		return _.contains(fields, "owner");
+	}
+});

app/Model/Creature/Classes.js

@@ -0,0 +1,32 @@
+Classes = new Mongo.Collection("classes");
+
+Schemas.Class = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:		 {type: String, optional: true, trim: false},
+	level:		 {type: Number},
+	createdAt: {
+		type: Date,
+		autoValue: function() {
+			if (this.isInsert) {
+				return new Date();
+			} else if (this.isUpsert) {
+				return {$setOnInsert: new Date()};
+			} else {
+				this.unset();
+			}
+		},
+	},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+});
+
+Classes.attachSchema(Schemas.Class);
+
+Classes.attachBehaviour("softRemovable");
+makeParent(Classes, "name"); //parents of effects and attacks
+
+Classes.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Classes.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Conditions.js

@@ -0,0 +1,42 @@
+Conditions = new Mongo.Collection("conditions");
+
+Schemas.Conditions = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	"lifeTime.total": {
+		type: Number,
+		defaultValue: 0, //0 is infinite
+		min: 0,
+	},
+	"lifeTime.spent": {
+		type: Number,
+		defaultValue: 0,
+		min: 0,
+	},
+	color: {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+});
+
+Conditions.attachSchema(Schemas.Conditions);
+
+Conditions.attachBehaviour("softRemovable");
+makeParent(Conditions, ["name"]); //parents of effects, attacks, proficiencies
+
+Conditions.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Conditions.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/CustomBuffs.js

@@ -0,0 +1,53 @@
+CustomBuffs = new Mongo.Collection("customBuffs");
+
+Schemas.CustomBuff = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	target: {
+		type: String,
+		allowedValues: [
+			"self",
+			"others",
+			"both"
+		],
+		defaultValue: "self",
+	},
+	enabled: {
+		type: Boolean,
+		autoValue: function(){
+			return false;
+			//enabled is ALWAYS false on these, so that its children are also not enabled, so that the buff templates have no effects.
+		},
+	},
+	"lifeTime.total": {
+		type: Number,
+		defaultValue: 0, //0 is infinite
+		min: 0,
+	},
+	//the id of the feature, buff or item that creates this buff
+	parent: {
+		type: Schemas.Parent,
+	},
+});
+
+CustomBuffs.attachSchema(Schemas.CustomBuff);
+
+CustomBuffs.attachBehaviour("softRemovable");
+makeParent(CustomBuffs, ["name", "enabled"]); //parents of effects, attacks, proficiencies. Since this represents a template, "enabled" is always false.
+makeChild(CustomBuffs); //children of lots of things
+
+CustomBuffs.allow(CHARACTER_SUBSCHEMA_ALLOW);
+CustomBuffs.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/DamageMultipliers.js

@@ -0,0 +1,39 @@
+DamageMultipliers = new Mongo.Collection("damageMultipliers");
+
+/*
+ * DamageMultipliers are whole numbered stats of a character
+ */
+Schemas.DamageMultiplier = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+  // The nice-to-read name
+	name: {
+		type: String,
+	},
+  // The technical, lowercase, single-word name used in formulae
+  variableName: {
+    type: String,
+  },
+  value: {
+    type: Number,
+    decimal: true,
+  },
+	parent: {
+		type: Schemas.Parent
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+});
+
+DamageMultipliers.attachSchema(Schemas.DamageMultiplier);
+
+DamageMultipliers.attachBehaviour("softRemovable");
+makeChild(DamageMultipliers, ["enabled"]); //children of lots of things
+
+DamageMultipliers.allow(CHARACTER_SUBSCHEMA_ALLOW);
+DamageMultipliers.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Effects.js

@@ -0,0 +1,131 @@
+Effects = new Mongo.Collection("effects");
+
+/*
+ * Effects are reason-value attached to skills and abilities
+ * that modify their final value or presentation in some way
+ */
+Schemas.Effect = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		optional: true, //TODO make necessary if there is no owner
+		trim: false,
+	},
+	operation: {
+		type: String,
+		defaultValue: "add",
+		allowedValues: [
+			"base",
+			"add",
+			"mul",
+			"min",
+			"max",
+			"advantage",
+			"disadvantage",
+			"passiveAdd",
+			"fail",
+			"conditional",
+		],
+	},
+	value: {
+		type: Number,
+		decimal: true,
+		optional: true,
+	},
+	calculation: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	//the thing that created this effect
+	parent: {
+		type: Schemas.Parent
+	},
+	//which stat the effect is applied to
+	stat: {
+		type: String,
+		optional: true,
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+});
+
+Effects.attachSchema(Schemas.Effect);
+
+Effects.attachBehaviour("softRemovable");
+makeChild(Effects, ["enabled"]); //children of lots of things
+
+Effects.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Effects.deny(CHARACTER_SUBSCHEMA_DENY);
+
+//give characters default character effects
+Characters.after.insert(function(userId, char) {
+	if (Meteor.isServer) {
+		Effects.insert({
+			charId: char._id,
+			name: "Constitution modifier for each level",
+			stat: "hitPoints",
+			operation: "add",
+			calculation: "level * constitutionMod",
+			parent: {
+				id: char._id,
+				collection: "Characters",
+				group: "Inate",
+			},
+		});
+		Effects.insert({
+			charId: char._id,
+			name: "Proficiency bonus by level",
+			stat: "proficiencyBonus",
+			operation: "add",
+			calculation: "floor(level / 4 + 1.75)",
+			parent: {
+				id: char._id,
+				collection: "Characters",
+				group: "Inate",
+			},
+		});
+		Effects.insert({
+			charId: char._id,
+			name: "Dexterity Armor Bonus",
+			stat: "armor",
+			operation: "add",
+			calculation: "dexterityArmor",
+			parent: {
+				id: char._id,
+				collection: "Characters",
+				group: "Inate",
+			},
+		});
+		Effects.insert({
+			charId: char._id,
+			name: "Natural Armor",
+			stat: "armor",
+			operation: "base",
+			value: 10,
+			parent: {
+				id: char._id,
+				collection: "Characters",
+				group: "Inate",
+			},
+		});
+		Effects.insert({
+			charId: char._id,
+			name: "Natural Carrying Capacity",
+			stat: "carryMultiplier",
+			operation: "base",
+			value: "1",
+			parent: {
+				id: char._id,
+				collection: "Characters",
+				group: "Inate",
+			},
+		});
+	}
+});

app/Model/Creature/Experience.js

@@ -0,0 +1,27 @@
+Experiences = new Mongo.Collection("experience");
+
+Schemas.Experience = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:		 {type: String, optional: true, trim: false, defaultValue: "New Experience"},
+	description: {type: String, optional: true, trim: false},
+	value:       {type: Number, defaultValue: 0},
+	dateAdded:   {
+		type: Date,
+		autoValue: function() {
+			if (this.isInsert) {
+				return new Date();
+			} else if (this.isUpsert) {
+				return {$setOnInsert: new Date()};
+			} else {
+				this.unset();
+			}
+		},
+	},
+});
+
+Experiences.attachSchema(Schemas.Experience);
+
+Experiences.attachBehaviour("softRemovable");
+
+Experiences.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Experiences.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Features.js

@@ -0,0 +1,115 @@
+Features = new Mongo.Collection("features");
+
+Schemas.Feature = new SimpleSchema({
+	charId:		  {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:         {type: String, optional: true, trim: false},
+	description:  {type: String, optional: true, trim: false},
+	uses:         {type: String, optional: true, trim: false},
+	used:         {type: Number, defaultValue: 0},
+	reset:        {
+		type: String,
+		allowedValues: ["manual", "longRest", "shortRest"],
+		defaultValue: "manual",
+	},
+	enabled:      {type: Boolean, defaultValue: true},
+	alwaysEnabled:{type: Boolean, defaultValue: true},
+	color:   {type: String,
+			  allowedValues: _.pluck(colorOptions, "key"),
+			  defaultValue: "q",
+			 },
+});
+
+Features.attachSchema(Schemas.Feature);
+
+Features.helpers({
+	usesLeft: function(){
+		return evaluate(this.charId, this.uses) - this.used;
+	},
+	usesValue: function(){
+		return evaluate(this.charId, this.uses);
+	},
+});
+
+Features.attachBehaviour("softRemovable");
+makeParent(Features, ["name", "enabled"]); //parents of effects and attacks
+
+Features.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Features.deny(CHARACTER_SUBSCHEMA_DENY);
+
+//give characters default feature of base ability scores of 10
+Characters.after.insert(function(userId, char) {
+	if (Meteor.isServer){
+		var featureId = Features.insert({
+			name: "Base Ability Scores",
+			charId: char._id,
+			enabled: true,
+			alwaysEnabled: true,
+		});
+		Effects.insert({
+			stat: "strength",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+		Effects.insert({
+			stat: "dexterity",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+		Effects.insert({
+			stat: "constitution",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+		Effects.insert({
+			stat: "intelligence",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+		Effects.insert({
+			stat: "wisdom",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+		Effects.insert({
+			stat: "charisma",
+			charId: char._id,
+			parent: {
+				id: featureId,
+				collection: "Features",
+			},
+			operation: "base",
+			value: 10,
+			enabled: true,
+		});
+	}
+});

app/Model/Creature/Notes.js

@@ -0,0 +1,19 @@
+Notes = new Mongo.Collection("notes");
+
+Schemas.Note = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:		 {type: String, optional: true, trim: false},
+	description: {type: String, optional: true, trim: false},
+	color:   {
+		type: String,
+		allowedValues:_.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+});
+
+Notes.attachSchema(Schemas.Note);
+
+Notes.attachBehaviour("softRemovable");
+
+Notes.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Notes.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Proficiencies.js

@@ -0,0 +1,37 @@
+Proficiencies = new Mongo.Collection("proficiencies");
+
+Schemas.Proficiency = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+	name: {
+		type: String,
+		trim: false,
+		optional: true,
+	},
+	value: {
+		type: Number,
+		allowedValues: [0, 0.5, 1, 2],
+		defaultValue: 1,
+		decimal: true,
+	},
+	type: {
+		type: String,
+		allowedValues: ["skill", "save", "weapon", "armor", "tool", "language"],
+		defaultValue: "skill",
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+});
+
+Proficiencies.attachSchema(Schemas.Proficiency);
+
+Proficiencies.attachBehaviour("softRemovable");
+makeChild(Proficiencies, ["enabled"]);
+
+Proficiencies.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Proficiencies.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Skills.js

@@ -0,0 +1,75 @@
+Skills = new Mongo.Collection("skills");
+
+/*
+ * Skills are anything that results in a modifier to be added to a D20
+ * Skills usually have an ability score modifier that they use as their basis
+ */
+Schemas.Skill = new SimpleSchema({
+	charId: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+		index: 1,
+	},
+  // The nice-to-read name
+	name: {
+		type: String,
+	},
+  // The technical, lowercase, single-word name used in formulae
+  variableName: {
+    type: String,
+  },
+  ability: {
+    type: String,
+    optional: true,
+  },
+  type: {
+    type: String,
+    allowedValues: [
+      "skill",
+      "save",
+      "tool",
+      "weapon",
+      "language",
+    ],
+  },
+  value: {
+    type: Number,
+    decimal: true,
+  },
+  advantage: {
+    type: Number,
+    optional: true,
+    allowedValues: [-1, 0, 1],
+  },
+  passiveBonus: {
+    type: Number,
+    optional: true,
+  },
+  proficiency: {
+    type: Number,
+    allowedValues: [0, 0.5, 1, 2],
+  },
+  conditionalBenefits: {
+    type: Number,
+    optional: true,
+  },
+  fail: {
+    type: Number,
+    optional: true,
+  },
+	parent: {
+		type: Schemas.Parent
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+});
+
+Skills.attachSchema(Schemas.Skill);
+
+Skills.attachBehaviour("softRemovable");
+makeChild(Skills, ["enabled"]); //children of lots of things
+
+Skills.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Skills.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/SpellLists.js

@@ -0,0 +1,37 @@
+SpellLists = new Mongo.Collection("spellLists");
+
+Schemas.SpellLists = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:        {type: String, optional: true, trim: false},
+	description: {type: String, optional: true, trim: false},
+	saveDC:      {type: String, optional: true, trim: false},
+	attackBonus: {type: String, optional: true, trim: false},
+	maxPrepared: {type: String, optional: true, trim: false},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+	"settings.showUnprepared": {type: Boolean, defaultValue: true},
+});
+
+SpellLists.attachSchema(Schemas.SpellLists);
+
+SpellLists.helpers({
+	numPrepared: function(){
+		var num = 0;
+		Spells.find(
+			{charId: this.charId, listId: this._id, prepared: 1},
+			{fields: {prepareCost: 1}}
+		).forEach(function(spell){
+			num += spell.prepareCost;
+		});
+		return num;
+	}
+});
+
+SpellLists.attachBehaviour("softRemovable");
+makeParent(SpellLists); //parents of spells
+
+SpellLists.allow(CHARACTER_SUBSCHEMA_ALLOW);
+SpellLists.deny(CHARACTER_SUBSCHEMA_DENY);

app/Model/Creature/Spells.js

@@ -0,0 +1,252 @@
+Spells = new Mongo.Collection("spells");
+
+Schemas.Spell = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	prepared: {
+		type: String,
+		defaultValue: "prepared",
+		allowedValues: ["prepared", "unprepared", "always"],
+	},
+	name: {
+		type: String,
+		optional: true,
+		trim: false,
+		defaultValue: "New Spell",
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	castingTime: {
+		type: String,
+		optional: true,
+		defaultValue: "action",
+		trim: false,
+	},
+	range: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	duration: {
+		type: String,
+		optional: true,
+		trim: false,
+		defaultValue: "Instantaneous",
+	},
+	"components.verbal":        {type: Boolean, defaultValue: false},
+	"components.somatic":       {type: Boolean, defaultValue: false},
+	"components.concentration":	{type: Boolean, defaultValue: false},
+	"components.material":      {type: String, optional: true},
+	ritual:      {
+		type: Boolean,
+		defaultValue: false,
+	},
+	level:       {
+		type: Number,
+		defaultValue: 1,
+	},
+	school:      {
+		type: String,
+		defaultValue: "Abjuration",
+		allowedValues: magicSchools,
+	},
+	color:       {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
+});
+
+Spells.attachSchema(Schemas.Spell);
+
+Spells.attachBehaviour("softRemovable");
+makeChild(Spells); //children of spell lists
+makeParent(Spells, ["name", "enabled"]); //parents of attacks
+
+Spells.after.update(function (userId, spell, fieldNames) {
+	//Update prepared state of spell and child attacks to be enabled or not
+	if (_.contains(fieldNames, "prepared")) {
+		var childAttacks = Attacks.find({"parent.id": spell._id}).fetch();
+		if (spell.prepared === "unprepared") {
+			_.each(childAttacks, function(attack){
+				Attacks.update(attack._id, {$set: {enabled: false}});
+			});
+		} else if (spell.prepared === "prepared" || "always") {
+			_.each(childAttacks, function(attack){
+				Attacks.update(attack._id, {$set: {enabled: true}});
+			});
+		}
+	}
+});
+
+Spells.allow(CHARACTER_SUBSCHEMA_ALLOW);
+Spells.deny(CHARACTER_SUBSCHEMA_DENY);
+
+
+
+
+var checkMovePermission = function(spellId, parent, destinationOnly) {
+	var spell = Spells.findOne(spellId);
+	if (!spell)
+		throw new Meteor.Error("No such spell",
+		"An spell could not be found to move");
+	//handle permissions
+	var permission;
+
+	if (!destinationOnly) { //if we're not modifying the origin, only the destination
+		permission = Meteor.call("canWriteCharacter", spell.charId);
+		if (!permission){
+			throw new Meteor.Error("Access denied",
+			"Not permitted to move spells from this character");
+		}
+	}
+	if (parent.collection === "Characters"){
+		permission = Meteor.call("canWriteCharacter", parent.id);
+		if (!permission){
+			throw new Meteor.Error("Access denied",
+			"Not permitted to move spells to this character");
+		}
+	} else {
+		var parentCollectionObject = global[parent.collection];
+		var parentObject = null;
+		if (parentCollectionObject)
+			parentObject = parentCollectionObject.findOne(
+				parent.id, {fields: {_id: 1, charId: 1}}
+			);
+		if (!parentObject) throw new Meteor.Error(
+			"Invalid parent",
+			"The destination parent " + parent.id +
+			" does not exist in the collection " + parent.collection
+		);
+		if (parentObject.charId){
+			permission = Meteor.call("canWriteCharacter", parentObject.charId);
+			if (!permission){
+				throw new Meteor.Error("Access denied",
+				"Not permitted to move spells to this character");
+			}
+		}
+	}
+};
+
+var moveSpell = function(spellId, targetCollection, targetId) {
+	var spell = Spells.findOne(spellId);
+	if (!spell) return;
+	targetCollection = targetCollection || spell.parent.collection;
+	targetId = targetId || spell.parent.id;
+
+	if (Meteor.isServer) {
+		checkMovePermission(spellId, {collection: targetCollection, id: targetId}, false);
+	}
+
+	if (targetCollection == "Characters") { //then we are copying the spell to a different character.
+		targetList = SpellLists.findOne({"charId": targetId});
+		targetListId = targetList && targetList._id;
+		if (!targetListId) {
+			targetListId = SpellLists.insert({ //create a spell list if we don't already have one
+				name: "New SpellList",
+				charId: targetId,
+				saveDC: "8 + intelligenceMod + proficiencyBonus",
+				attackBonus: "intelligenceMod + proficiencyBonus",
+			});
+		}
+
+		Spells.update(
+			spellId,
+			{$set: {
+				charId: targetId,
+				"parent.collection": "SpellLists",
+				"parent.id": targetListId,
+			}}
+		);
+	}
+	else { //we are moving the spell within the same character
+		//update the spell provided the update will actually change something
+		if (
+			spell.parent.collection !== targetCollection ||
+			spell.parent.id !== targetId
+		){
+			Spells.update(
+				spellId,
+				{$set: {
+					"parent.collection": targetCollection,
+					"parent.id": targetId,
+				}}
+			);
+		}
+	}
+};
+
+var copySpell = function(spellId, targetCollection, targetId) {
+	var spell = Spells.findOne(spellId);
+	if (!spell) return;
+	targetCollection = targetCollection || spell.parent.collection;
+	targetId = targetId || spell.parent.id;
+
+	if (Meteor.isServer) {
+		checkMovePermission(spellId, {collection: targetCollection, id: targetId}, true); //we're only reading from the source character
+	}
+
+
+	if (targetCollection == "Characters") { //then we are copying the spell to a different character.
+		targetList = SpellLists.findOne({"charId": targetId});
+		targetListId = targetList && targetList._id;
+		if (!targetListId) {
+			targetListId = SpellLists.insert({ //create a spell list if we don't already have one
+				name: "New SpellList",
+				charId: targetId,
+				saveDC: "8 + intelligenceMod + proficiencyBonus",
+				attackBonus: "intelligenceMod + proficiencyBonus",
+			});
+		}
+
+		newSpell = _.clone(spell);
+		delete newSpell._id;
+		newSpellId = Spells.insert(newSpell); //add a new copy of the spell
+		Spells.update(
+			newSpellId,
+			{$set: {
+				charId: targetId,
+				"parent.collection": "SpellLists",
+				"parent.id": targetListId,
+			}}
+		);
+	}
+	else { //else we are copying the spell within the same character
+		newSpell = _.clone(spell);
+		delete newSpell._id;
+		newSpellId = Spells.insert(newSpell); //add a new copy of the spell
+		Spells.update(
+			newSpellId,
+			{$set: {
+				"parent.collection": targetCollection,
+				"parent.id": targetId,
+			}}
+		);
+	}
+};
+
+
+Meteor.methods({
+	moveSpellToList: function(spellId, spellListId) {
+		check(spellId, String);
+		check(spellListId, String);
+		moveSpell(spellId, "SpellLists", spellListId);
+	},
+	copySpellToList: function(spellId, spellListId) {
+		check(spellId, String);
+		check(spellListId, String);
+		copySpell(spellId, "SpellLists", spellListId);
+	},
+	moveSpellToCharacter: function(spellId, charId) {
+		check(spellId, String);
+		check(charId, String);
+		moveSpell(spellId, "Characters", charId);
+	},
+	copySpellToCharacter: function(spellId, charId) {
+		check(spellId, String);
+		check(charId, String);
+		copySpell(spellId, "Characters", charId);
+	},
+});

app/Model/Creature/SubSchemas/Adjustment.js

@@ -0,0 +1,21 @@
+/*
+ * Adjustments make instantaneous changes to the value of some attribute
+ * Damage, healing and resource cost/recovery are all adjustments
+ */
+Schemas.Adjustment = new SimpleSchema({
+	//which stat the adjustment is applied to
+	stat: {
+		type: String,
+		optional: true,
+	},
+	//the value added to the stat
+	value: {
+		type: Number,
+		decimal: true,
+		optional: true,
+	},
+	calculation: {
+		type: String,
+		optional: true,
+	},
+});

app/Model/Creature/SubSchemas/Attribute.js

@@ -0,0 +1,13 @@
+Schemas.Attribute = new SimpleSchema({
+	//the temporary shift of the attribute
+	//should be zero after reset
+	adjustment: {
+		type: Number,
+		defaultValue: 0,
+	},
+	reset: {
+		type: String,
+		defaultValue: "longRest",
+		allowedValues: ["longRest", "shortRest"],
+	},
+});

app/Model/Creature/SubSchemas/DeathSaves.js

@@ -0,0 +1,22 @@
+Schemas.DeathSave = new SimpleSchema({
+	pass: {
+		type: Number,
+		min: 0,
+		max: 3,
+		defaultValue: 0,
+	},
+	fail: {
+		type: Number,
+		min: 0,
+		max: 3,
+		defaultValue: 0,
+	},
+	canDeathSave: {
+		type: Boolean,
+		defaultValue: true,
+	},
+	stable: {
+		type: Boolean,
+		defaultValue: false,
+	},
+});

app/Model/Creature/SubSchemas/Skill.js

@@ -0,0 +1,4 @@
+Schemas.Skill = new SimpleSchema({
+	//attribute name that this skill used as base mod for roll
+	ability: {type: String, defaultValue: ""},
+});

app/Model/Creature/TemporaryHitPoints.js

@@ -0,0 +1,41 @@
+TemporaryHitPoints = new Mongo.Collection("temporaryHitPoints");
+
+Schemas.TemporaryHitPoints = new SimpleSchema({
+	charId:      {type: String, regEx: SimpleSchema.RegEx.Id, index: 1},
+	name:        {type: String, optional: true},
+	maximum:     {type: Number, defaultValue: 0, min: 0, max: 500},
+	used:        {type: Number, defaultValue: 0, min: 0, max: 500},
+	deleteOnZero:{type: Boolean, defaultValue: false},
+	dateAdded:   {
+		type: Date,
+		autoValue: function() {
+			if (this.isInsert) {
+				return new Date();
+			} else if (this.isUpsert) {
+				return {$setOnInsert: new Date()};
+			} else {
+				this.unset();
+			}
+		},
+	},
+});
+
+TemporaryHitPoints.attachSchema(Schemas.TemporaryHitPoints);
+
+TemporaryHitPoints.helpers({
+	left: function(){
+		return this.maximum - this.used;
+	}
+});
+
+//remove the temporary hit points when they hit zero
+TemporaryHitPoints.after.update(
+	function(userId, thp, fieldNames, modifier, options){
+		if (thp.used >= thp.maximum && thp.deleteOnZero){
+			TemporaryHitPoints.remove(thp._id);
+		}
+	}, {fetchPrevious: false}
+);
+
+TemporaryHitPoints.allow(CHARACTER_SUBSCHEMA_ALLOW);
+TemporaryHitPoints.deny(CHARACTER_SUBSCHEMA_DENY);