Implemented very basic value-auditing for skills/abilities

rpg-docs/Model/Character/Characters.js

@@ -5,12 +5,12 @@ Schemas.Character = new SimpleSchema({
 	strings: 		{ type: Schemas.Strings },
 	attributes: 	{ type: Schemas.Attributes },
 	skills: 		{ type: Schemas.Skills },
-	vulerabilities:	{ type: Schemas.Vulnerabilities },
 	proficiencies:	{ type: Schemas.Proficiencies },
-	features:		{ type: [Schemas.Feature]},
-	time:			{ type: Number, min: 0, decimal: true},
-	initiativeOrder:{ type: Number, min: 0, max: 1, decimal: true},
-	expirations:	{ type: [Schemas.Expiration]}
+	features:		{ type: [Schemas.Feature], defaultValue: []},
+	deathSave:		{ type: Schemas.DeathSave },
+	time:			{ type: Number, min: 0, decimal: true, defaultValue: 0},
+	initiativeOrder:{ type: Number, min: 0, max: 1, decimal: true, defaultValue: 0},
+	expirations:	{ type: [Schemas.Expiration], defaultValue: []}
 	//TODO add permission stuff for owner, readers and writers
 	//TODO hit dice
 	//TODO spells
@@ -38,26 +38,26 @@ Characters.helpers({
 		if (attribute === undefined) return;
 		//base value
 		var value = attribute.base;
-
+		var char = this;
 		//add all values in add array
 		_.each(attribute.add, function(effect){
-			value += pop(effect.value, this)
+			value += evaluateEffect(char, effect);
 		});
 
 		//multiply all values in mul array
 		_.each(attribute.mul, function(effect){
-			value *= pop(effect.value, this)
+			value *= evaluateEffect(char, effect);
 		});
 
 		//largest min
 		_.each(attribute.min, function(effect){
-			var min = pop(effect.value, this);
+			var min = evaluateEffect(char, effect);
 			value = value > min? value : min;
 		});
 
 		//smallest max
 		_.each(attribute.max, function(effect){
-			var max = pop(effect.value, this);
+			var max = evaluateEffect(char, effect);
 			value = value < max? value : max;
 		});
 
@@ -66,13 +66,14 @@ Characters.helpers({
 
 	proficiency: function(skill){
 		//return largest value in proficiency array
+		var char = this;
 		var prof = 0;
-		for(var i = 0, l = skill.proficiency.length; i < l; i++){
-			var newProf = pop(skill.proficiency[i].value, this);
+		_.each(skill.proficiency, function(effect){
+			var newProf = evaluateEffect(char, effect);
 			if (newProf > prof){
 				prof = newProf;
 			}
-		}
+		});
 		return prof;
 	},
 
@@ -81,6 +82,7 @@ Characters.helpers({
 			console.log("Cannot get skillMod of undefined");
 			return;
 		}
+		var char = this;
 		//get the final value of the ability score
 		var ability = this.attributeValue(this.attributes[skill.ability]);
 
@@ -95,23 +97,23 @@ Characters.helpers({
 
 		//add all values in add array
 		_.each(skill.add, function(effect){
-			mod += pop(effect.value, this)
+			mod += evaluateEffect(char, effect);
 		});
 
 		//multiply all values in mul array
 		_.each(skill.mul, function(effect){
-			mod *= pop(effect.value, this)
+			mod *= evaluateEffect(char, effect);
 		});
 
 		//largest min
 		_.each(skill.min, function(effect){
-			var min = pop(effect.value, this);
+			var min = evaluateEffect(char, effect);
 			mod = mod > min? mod : min;
 		});
 
 		//smallest max
 		_.each(skill.max, function(effect){
-			var max = pop(effect.value, this);
+			var max = evaluateEffect(char, effect);
 			mod = mod < max? mod : max;
 		});
 
@@ -120,9 +122,10 @@ Characters.helpers({
 
 	passiveSkill: function(skill){
 		var mod = +this.skillMod(skill);
+		var char = this;
 		var value = 10 + mod;
 		_.each(skill.passiveAdd, function(effect){
-			value += pop(effect.value, this);
+			value += evaluateEffect(char, effect);
 		});
 		return value;
 		//TODO decide whether (dis)advantage gives (-)+5 to passive checks

rpg-docs/Model/Character/SubSchemas/Attributes.js

@@ -13,13 +13,31 @@ Schemas.Attribute = new SimpleSchema({
 	conditional:{ type: [Schemas.Effect], defaultValue: [] }
 });
 
+//note to make an invulnerability add a new max of zero value
+Schemas.Vulnerability = new SimpleSchema({
+	//same as attribute
+	base: {
+		type: Number,
+		defaultValue: 0
+	},
+	//effect arrays
+	add: 		{ type: [Schemas.Effect], defaultValue: [] },
+	mul: 		{ type: [Schemas.Effect], defaultValue: [] },
+	min: 		{ type: [Schemas.Effect], defaultValue: [{name: "Resistance doesn't stack", value: 0.5}] },
+	max: 		{ type: [Schemas.Effect], defaultValue: [{name: "Vulnerability doesn't stack", value:  2}] },
+	conditional:{ type: [Schemas.Effect], defaultValue: [] },
+});
+
 Schemas.Attributes = new SimpleSchema({
+	//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},
 	experience:			{type: Schemas.Attribute},
 	proficiencyBonus:	{type: Schemas.Attribute},
@@ -28,6 +46,15 @@ Schemas.Attributes = new SimpleSchema({
 	weightCarried: 		{type: Schemas.Attribute},
 	age: 				{type: Schemas.Attribute},
 	ageRate: 			{type: Schemas.Attribute},
+	armor:				{type: Schemas.Attribute},
+	"armor.add": {
+		type: [Schemas.Effect],
+		defaultValue: [
+			{name: "Dexterity Modifier", calculation: "dexterityArmor"}
+		]
+	},
+	
+	//resources
 	level1SpellSlots:	{type: Schemas.Attribute},
 	level2SpellSlots:	{type: Schemas.Attribute},
 	level3SpellSlots:	{type: Schemas.Attribute},
@@ -40,11 +67,26 @@ Schemas.Attributes = new SimpleSchema({
 	ki:					{type: Schemas.Attribute},
 	sorceryPoints:		{type: Schemas.Attribute},
 	rages:				{type: Schemas.Attribute},
-	armor:				{type: Schemas.Attribute},
-	"armor.add": {
-		type: [Schemas.Effect],
-		defaultValue: [
-			{name: "Dexterity Modifier", value: "skillMod skills.dexterityArmor"}
-		]
-	}
+	
+	
+	//hit dice
+	d6HitDice:				{type: Schemas.Attribute},
+	d8HitDice:				{type: Schemas.Attribute},
+	d10HitDice:				{type: Schemas.Attribute},
+	d12HitDice:				{type: Schemas.Attribute},
+	
+	//vulnerabilities
+	acidMultiplier:			{type: Schemas.Vulnerability},
+	bludgeoningMultiplier:	{type: Schemas.Vulnerability},
+	coldMultiplier:			{type: Schemas.Vulnerability},
+	fireMultiplier:			{type: Schemas.Vulnerability},
+	forceMultiplier:		{type: Schemas.Vulnerability},
+	lightningMultiplier:	{type: Schemas.Vulnerability},
+	necroticMultiplier:		{type: Schemas.Vulnerability},
+	piercingMultiplier:		{type: Schemas.Vulnerability},
+	poisonMultiplier:		{type: Schemas.Vulnerability},
+	psychicMultiplier:		{type: Schemas.Vulnerability},
+	radiantMultiplier:		{type: Schemas.Vulnerability},
+	slashingMultiplier:		{type: Schemas.Vulnerability},
+	thunderMultiplier:		{type: Schemas.Vulnerability},
 });

rpg-docs/Model/Character/SubSchemas/Effect/Effect.js

@@ -21,5 +21,11 @@ Schemas.Effect = new SimpleSchema({
 	calculation: {
 		type: String,
 		optional: true
+	},
+	//indicates what the effect originated from
+	type: {
+		type: String,
+		defaultValue: "default",
+		allowedValues: ["default", "class", "race", "feat", "equippedMagic", "equippedMundane", "external"]
 	}
 });

rpg-docs/Model/Character/SubSchemas/Proficiencies

@@ -1,10 +0,0 @@
-Schemas.Proficiency = new simpleSchema({
-	name: 	{type: String},
-	source: {type: String}
-})
-
-Schemas.Proficiencies = new SimpleSchema({
-	weapons: {type: [Schemas.Proficiency]},
-	tools: {type: [Schemas.Proficiency]},
-	languages: {type: [Schemas.Proficiency]}
-});

rpg-docs/Model/Character/SubSchemas/Proficiencies.js

@@ -0,0 +1,19 @@
+Schemas.Proficiency = new SimpleSchema({
+	name: 	{type: String},
+	source: {type: String}
+})
+
+Schemas.Proficiencies = new SimpleSchema({
+	weapons: {
+		type: [Schemas.Proficiency], 
+		defaultValue: []
+	},
+	tools: {
+		type: [Schemas.Proficiency],
+		defaultValue: []
+	},
+	languages: {
+		type: [Schemas.Proficiency], 
+		defaultValue: []
+	}
+});

rpg-docs/Model/Character/SubSchemas/Vulnerabilities.js

@@ -1,24 +0,0 @@
-Schemas.Vulnerability = _.extend({
-	"min.defaultValue": [
-		{name: "Resistance doesn't stack", value: 0.5}
-	],
-	"max.defaultValue": [
-		{name: "Vulnerability doesn't stack", value:  2}
-	]
-}, Schemas.Attribute);
-
-Schemas.Vulnerabilities = new SimpleSchema({
-	acid:		{type: Schemas.Vulnerability},
-	bludgeoning:{type: Schemas.Vulnerability},
-	cold:		{type: Schemas.Vulnerability},
-	fire:		{type: Schemas.Vulnerability},
-	force:		{type: Schemas.Vulnerability},
-	lightning:	{type: Schemas.Vulnerability},
-	necrotic:	{type: Schemas.Vulnerability},
-	piercing:	{type: Schemas.Vulnerability},
-	poison:		{type: Schemas.Vulnerability},
-	psychic:	{type: Schemas.Vulnerability},
-	radiant:	{type: Schemas.Vulnerability},
-	slashing:	{type: Schemas.Vulnerability},
-	thunder:	{type: Schemas.Vulnerability}
-});