Merge branch 'hotfix-style'

Conflicts:
	rpg-docs/client/style/main.scss

.jscsrc

@@ -0,0 +1,56 @@
+{
+	"requireOperatorBeforeLineBreak": true,
+	"requireCamelCaseOrUpperCaseIdentifiers": true,
+	"maximumLineLength": {
+		"value": 80,
+		"allowComments": true,
+		"allowRegex": true
+	},
+	"validateIndentation": "\t",
+	"validateQuoteMarks": "\"",
+
+	"disallowMultipleLineStrings": true,
+	"disallowMixedSpacesAndTabs": "smart",
+	"disallowTrailingWhitespace": true,
+	"disallowSpaceAfterPrefixUnaryOperators": true,
+	"disallowMultipleVarDecl": true,
+	"disallowNewlineBeforeBlockStatements": true,
+	"disallowKeywordsOnNewLine": ["else"],
+
+	"requireSpaceAfterKeywords": [
+		"if",
+		"else",
+		"for",
+		"while",
+		"do",
+		"switch",
+		"return",
+		"try",
+		"catch"
+	],
+	"requireSpaceBeforeBinaryOperators": [
+		"=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=",
+		"&=", "|=", "^=", "+=",
+
+		"+", "-", "*", "/", "%", "<<", ">>", ">>>", "&",
+		"|", "^", "&&", "||", "===", "==", ">=",
+		"<=", "<", ">", "!=", "!=="
+	],
+	"requireSpaceAfterBinaryOperators": true,
+	"requireSpacesInConditionalExpression": true,
+	"requireSpacesInForStatement": true,
+	"requireTrailingComma": {
+		"ignoreSingleValue": true,
+		"ignoreSingleLine": true
+	},
+	"requireLineFeedAtFileEnd": true,
+	"disallowSpacesInAnonymousFunctionExpression": {
+		"beforeOpeningRoundBrace": true
+	},
+	"disallowSpacesInsideObjectBrackets": "all",
+	"disallowSpacesInsideArrayBrackets": "all",
+	"disallowSpacesInsideParentheses": true,
+
+	"disallowMultipleLineBreaks": true,
+	"disallowNewlineBeforeBlockStatements": true
+}

.jshintrc

@@ -0,0 +1,3 @@
+{
+	"undef": false
+}

rpg-docs/.gitignore

@@ -1,4 +1,5 @@
 .meteor/local
 .meteor/meteorite
 public/components
-nohup.out
+nohup.out
+dump

rpg-docs/.meteor/packages

@@ -16,5 +16,15 @@ differential:vulcanize
 matb33:collection-hooks
 zimme:collection-softremovable
 momentjs:moment
-mike:mocha
 dburles:mongo-collection-instances
+percolate:migrations
+ecwyne:mathjs
+useraccounts:polymer
+accounts-google
+splendido:accounts-meld
+email
+fourseven:scss@2.1.1
+wolves:bourbon
+meteorhacks:subs-manager
+meteorhacks:kadira
+chuangbo:marked

rpg-docs/.meteor/versions

@@ -1,10 +1,11 @@
 accounts-base@1.2.0
+accounts-google@1.0.4
+accounts-oauth@1.1.5
 accounts-password@1.1.1
 accounts-ui@1.1.5
 accounts-ui-unstyled@1.1.7
 aldeed:collection2@2.3.3
-aldeed:simple-schema@1.3.2
+aldeed:simple-schema@1.3.3
-amplify@1.0.0
 autoupdate@1.2.1
 base64@1.0.3
 binary-heap@1.0.3
@@ -13,16 +14,20 @@ blaze-tools@1.0.3
 boilerplate-generator@1.0.3
 callback-hook@1.0.3
 check@1.0.5
+chuangbo:marked@0.3.5
 coffeescript@1.0.6
 dburles:collection-helpers@1.0.3
 dburles:mongo-collection-instances@0.3.3
 ddp@1.1.0
 deps@1.0.7
-differential:vulcanize@0.0.4
+differential:vulcanize@0.0.5
+ecwyne:mathjs@0.25.0
 ejson@1.0.6
 email@1.0.6
 fastclick@1.0.3
+fourseven:scss@2.1.1
 geojson-utils@1.0.3
+google@1.1.5
 html-tools@1.0.4
 htmljs@1.0.4
 http@1.1.0
@@ -43,20 +48,24 @@ less@1.0.14
 livedata@1.0.13
 localstorage@1.0.3
 logging@1.0.7
-matb33:collection-hooks@0.7.11
+matb33:collection-hooks@0.7.13
 meteor@1.1.6
 meteor-platform@1.2.2
-mike:mocha@0.5.2
+meteorhacks:kadira@2.21.0
+meteorhacks:meteorx@1.3.1
+meteorhacks:subs-manager@1.3.0
 minifiers@1.1.5
 minimongo@1.0.8
 mobile-status-bar@1.0.3
-momentjs:moment@2.10.0
+momentjs:moment@2.10.3
 mongo@1.1.0
+mongo-livedata@1.0.8
 npm-bcrypt@0.7.8_2
+oauth@1.1.4
+oauth2@1.1.3
 observe-sequence@1.0.6
 ordered-dict@1.0.3
-practicalmeteor:chai@1.9.2_3
+percolate:migrations@0.7.5
-practicalmeteor:loglevel@1.1.0_3
 random@1.0.3
 reactive-dict@1.1.0
 reactive-var@1.0.5
@@ -66,20 +75,21 @@ routepolicy@1.0.5
 service-configuration@1.0.4
 session@1.1.0
 sha@1.0.3
+softwarerero:accounts-t9n@1.0.9
 spacebars@1.0.6
 spacebars-compiler@1.0.6
+splendido:accounts-emails-field@1.2.0
+splendido:accounts-meld@1.3.0
 srp@1.0.3
 templating@1.1.1
 tracker@1.0.7
 ui@1.0.6
 underscore@1.0.3
 url@1.0.4
-velocity:core@0.4.5
+useraccounts:core@1.9.1
-velocity:html-reporter@0.3.2
+useraccounts:polymer@1.9.1
-velocity:node-soft-mirror@0.3.1
-velocity:shim@0.1.0
-velocity:test-proxy@0.0.4
 webapp@1.2.0
 webapp-hashing@1.0.3
+wolves:bourbon@1.0.0
 zimme:collection-behaviours@1.0.4
 zimme:collection-softremovable@1.0.4

rpg-docs/Model/Campaign/Instance.js

@@ -4,4 +4,4 @@ Schemas.Instance = new SimpleSchema({
 	//an instance is a single flow of time all parties in an instance are in-sync time wise
 });
 
-Instances.attachSchema(Schemas.Instance);
+Instances.attachSchema(Schemas.Instance);

rpg-docs/Model/Campaign/Party.js

@@ -5,4 +5,4 @@ Schemas.Party = new SimpleSchema({
 	//each party can only be in a single instance at a time
 });
 
-Parties.attachSchema(Schemas.Party);
+Parties.attachSchema(Schemas.Party);

rpg-docs/Model/Character/Actions.js

@@ -5,29 +5,32 @@ Actions = new Mongo.Collection("actions");
  */
 Schemas.Action = new SimpleSchema({
 	charId: {
-		type: String, 
+		type: String,
-		regEx: SimpleSchema.RegEx.Id
+		regEx: SimpleSchema.RegEx.Id,
 	},
 	name: {
-		type: String, trim: false
+		type: String,
+		trim: false,
 	},
 	description: {
-		type: String, trim: false
+		type: String,
+		trim: false,
 	},
 	type: {
 		type: String,
 		allowedValues: ["action, bonus, reaction, free"],
-		defaultValue: "action"
+		defaultValue: "action",
 	},
 	//the immediate impact of doing this action (eg. -1 rages)
 	adjustments: {
-		type: [Schemas.Adjustment], defaultValue: []
+		type: [Schemas.Adjustment],
-	}
+		defaultValue: [],
+	},
 });
 
 Actions.attachSchema(Schemas.Action);
 
-Actions.attachBehaviour('softRemovable');
+Actions.attachBehaviour("softRemovable");
 makeChild(Actions);
 
 Actions.allow(CHARACTER_SUBSCHEMA_ALLOW);

rpg-docs/Model/Character/Attacks.js

@@ -5,68 +5,69 @@ Attacks = new Mongo.Collection("attacks");
  */
 Schemas.Attack = new SimpleSchema({
 	charId: {
-		type: String, 
+		type: String,
-		regEx: SimpleSchema.RegEx.Id
+		regEx: SimpleSchema.RegEx.Id,
 	},
 	name: {
 		type: String,
-		defaultValue: "New Attack", 
+		defaultValue: "New Attack",
-		trim: false
+		trim: false,
 	},
 	details: {
 		type: String,
-		optional: true, 
+		optional: true,
-		trim: false
+		trim: false,
 	},
 	attackBonus: {
 		type: String,
 		defaultValue: "strengthMod + proficiencyBonus",
-		optional: true, 
-		trim: false
-	},
-	damageBonus: {
-		type: String,
-		defaultValue: "strengthMod",
-		optional: true, 
-		trim: false
-	},
-	damageDice: {
-		type: String,
 		optional: true,
-		defaultValue: "1d8",
+		trim: false,
-		allowedValues: DAMAGE_DICE
+	},
+	damage: {
+		type: String,
+		defaultValue: "1d8 + {strengthMod}",
+		optional: true,
+		trim: false,
 	},
 	damageType: {
 		type: String,
-		allowedValues: ["bludgeoning", "piercing", "slashing", "acid", "cold", "fire", "force", "lightning", "necrotic", 
+		allowedValues: [
-						"poison", "psychic", "radiant", "thunder"],
+			"bludgeoning",
-		defaultValue: "slashing"
+			"piercing",
-	},
+			"slashing",
-	//indicates what the attack originated from
+			"acid",
-	type: {
+			"cold",
-		type: String,
+			"fire",
-		defaultValue: "editable",
+			"force",
-		allowedValues: ["editable", "feature", "class", "buff", "equipment", "racial", "inate"]
+			"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, 
+		type: String,
-		allowedValues: _.pluck(colorOptions, "key"), 
+		allowedValues: _.pluck(colorOptions, "key"),
-		defaultValue: "q"
+		defaultValue: "q",
 	},
 	enabled: {
 		type: Boolean,
-		defaultValue: true
+		defaultValue: true,
-	}
+	},
 });
 
 Attacks.attachSchema(Schemas.Attack);
 
-Attacks.attachBehaviour('softRemovable');
+Attacks.attachBehaviour("softRemovable");
-makeChild(Attacks, ['name', 'enabled']); //children of lots of things
+makeChild(Attacks, ["name", "enabled"]); //children of lots of things
 
 Attacks.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Attacks.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Buffs.js

@@ -1,27 +1,51 @@
 Buffs = new Mongo.Collection("buffs");
 
-//buffs are temporary once applied and store things which expire and their expiry time
 Schemas.Buff = new SimpleSchema({
-	//buff id
+	charId: {
-	_id: {
 		type: String,
 		regEx: SimpleSchema.RegEx.Id,
-		autoValue: function(){
-			if(!this.isSet) return Random.id();
-		}},
-	charId: {
-		type: String, 
-		regEx: SimpleSchema.RegEx.Id
 	},
-	//expiry time
+	name: {
-	expiry:     { type: Number, optional: true},
+		type: String,
-	duration:	{ type: Number }
+		trim: false,
+	},
+	description: {
+		type: String,
+		optional: true,
+		trim: false,
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
+	},
+	type: {
+		type: String,
+		allowedValues: [
+			"inate",
+			"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",
+	},
 });
 
 Buffs.attachSchema(Schemas.Buff);
 
-Buffs.attachBehaviour('softRemovable');
+Buffs.attachBehaviour("softRemovable");
-makeParent(Buffs, 'name'); //parents of effects and attacks
+makeParent(Buffs, ["name", "enabled"]); //parents of effects
 
 Buffs.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Buffs.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Characters.js

@@ -3,18 +3,17 @@ Characters = new Mongo.Collection("characters");
 
 Schemas.Character = new SimpleSchema({
 	//strings
-	name:         { type: String, defaultValue: "", trim: false},
+	name:         {type: String, defaultValue: "", trim: false, optional: true},
-	alignment:    { type: String, defaultValue: "", trim: false},
+	alignment:    {type: String, defaultValue: "", trim: false, optional: true},
-	gender:       { type: String, defaultValue: "", trim: false},
+	gender:       {type: String, defaultValue: "", trim: false, optional: true},
-	race:         { type: String, defaultValue: "", trim: false},
+	race:         {type: String, defaultValue: "", trim: false, optional: true},
-	description:  { type: String, defaultValue: "", trim: false},
+	picture:      {type: String, defaultValue: "", trim: true,  optional: true},
-	personality:  { type: String, defaultValue: "", trim: false},
+	description:  {type: String, defaultValue: "", trim: false, optional: true},
-	ideals:       { type: String, defaultValue: "", trim: false},
+	personality:  {type: String, defaultValue: "", trim: false, optional: true},
-	bonds:        { type: String, defaultValue: "", trim: false},
+	ideals:       {type: String, defaultValue: "", trim: false, optional: true},
-	flaws:        { type: String, defaultValue: "", trim: false},
+	bonds:        {type: String, defaultValue: "", trim: false, optional: true},
-	backstory:    { type: String, defaultValue: "", trim: false},
+	flaws:        {type: String, defaultValue: "", trim: false, optional: true},
-	proficiencies:{ type: String, defaultValue: "", trim: false},
+	backstory:    {type: String, defaultValue: "", trim: false, optional: true},
-	languages:    { type: String, defaultValue: "", trim: false},
 
 	//attributes
 	//ability scores
@@ -75,143 +74,388 @@ Schemas.Character = new SimpleSchema({
 	slashingMultiplier:    {type: Schemas.Attribute},
 	thunderMultiplier:     {type: Schemas.Attribute},
 
-
 	//skills
 	//saves
 	strengthSave:    {type: Schemas.Skill},
-	"strengthSave.ability":     { type: String, defaultValue: "strength" },
+	"strengthSave.ability":     {type: String, defaultValue: "strength"},
 
 	dexteritySave:	 {type: Schemas.Skill},
-	"dexteritySave.ability":    { type: String, defaultValue: "dexterity" },
+	"dexteritySave.ability":    {type: String, defaultValue: "dexterity"},
 
 	constitutionSave:{type: Schemas.Skill},
-	"constitutionSave.ability": { type: String, defaultValue: "constitution" },
+	"constitutionSave.ability": {type: String, defaultValue: "constitution"},
 
 	intelligenceSave:{type: Schemas.Skill},
-	"intelligenceSave.ability":	{ type: String, defaultValue: "intelligence" },
+	"intelligenceSave.ability":	{type: String, defaultValue: "intelligence"},
 
 	wisdomSave:      {type: Schemas.Skill},
-	"wisdomSave.ability":       { type: String, defaultValue: "wisdom" },
+	"wisdomSave.ability":       {type: String, defaultValue: "wisdom"},
 
 	charismaSave:    {type: Schemas.Skill},
-	"charismaSave.ability":     { type: String, defaultValue: "charisma" },
+	"charismaSave.ability":     {type: String, defaultValue: "charisma"},
-
 
 	//skill skills
-	acrobatics: 	{type: Schemas.Skill},
+	acrobatics:      {type: Schemas.Skill},
-	"acrobatics.ability": 		{ type: String, defaultValue: "dexterity" },
+	"acrobatics.ability":       {type: String, defaultValue: "dexterity"},
 
-	animalHandling: {type: Schemas.Skill},
+	animalHandling:  {type: Schemas.Skill},
-	"animalHandling.ability":	{ type: String, defaultValue: "wisdom" },
+	"animalHandling.ability":   {type: String, defaultValue: "wisdom"},
 
-	arcana: 		{type: Schemas.Skill},
+	arcana:          {type: Schemas.Skill},
-	"arcana.ability": 			{ type: String, defaultValue: "intelligence" },
+	"arcana.ability":           {type: String, defaultValue: "intelligence"},
 
-	athletics: 		{type: Schemas.Skill},
+	athletics:       {type: Schemas.Skill},
-	"athletics.ability": 		{ type: String, defaultValue: "strength" },
+	"athletics.ability":        {type: String, defaultValue: "strength"},
 
-	deception: 		{type: Schemas.Skill},
+	deception:       {type: Schemas.Skill},
-	"deception.ability": 		{ type: String, defaultValue: "charisma" },
+	"deception.ability":        {type: String, defaultValue: "charisma"},
 
-	history: 		{type: Schemas.Skill},
+	history:        {type: Schemas.Skill},
-	"history.ability": 			{ type: String, defaultValue: "intelligence" },
+	"history.ability":          {type: String, defaultValue: "intelligence"},
 
-	insight:		{type: Schemas.Skill},
+	insight:        {type: Schemas.Skill},
-	"insight.ability":			{ type: String, defaultValue: "wisdom" },
+	"insight.ability":          {type: String, defaultValue: "wisdom"},
 
-	intimidation:	{type: Schemas.Skill},
+	intimidation:   {type: Schemas.Skill},
-	"intimidation.ability":		{ type: String, defaultValue: "charisma" },
+	"intimidation.ability":		{type: String, defaultValue: "charisma"},
 
 	investigation:	{type: Schemas.Skill},
-	"investigation.ability":	{ type: String, defaultValue: "intelligence" },
+	"investigation.ability":	{type: String, defaultValue: "intelligence"},
 
 	medicine:		{type: Schemas.Skill},
-	"medicine.ability": 		{ type: String, defaultValue: "wisdom" },
+	"medicine.ability":        {type: String, defaultValue: "wisdom"},
 
 	nature:			{type: Schemas.Skill},
-	"nature.ability": 			{ type: String, defaultValue: "intelligence" },
+	"nature.ability":          {type: String, defaultValue: "intelligence"},
 
 	perception:		{type: Schemas.Skill},
-	"perception.ability": 		{ type: String, defaultValue: "wisdom" },
+	"perception.ability":      {type: String, defaultValue: "wisdom"},
 
 	performance:	{type: Schemas.Skill},
-	"performance.ability": 		{ type: String, defaultValue: "charisma" },
+	"performance.ability":     {type: String, defaultValue: "charisma"},
 
-	persuasion: 	{type: Schemas.Skill},
+	persuasion:     {type: Schemas.Skill},
-	"persuasion.ability": 		{ type: String, defaultValue: "charisma" },
+	"persuasion.ability":      {type: String, defaultValue: "charisma"},
 
-	religion:		{type: Schemas.Skill},
+	religion:       {type: Schemas.Skill},
-	"religion.ability": 		{ type: String, defaultValue: "intelligence" },
+	"religion.ability":        {type: String, defaultValue: "intelligence"},
 
 	sleightOfHand:	{type: Schemas.Skill},
-	"sleightOfHand.ability":	{ type: String, defaultValue: "dexterity" },
+	"sleightOfHand.ability":	{type: String, defaultValue: "dexterity"},
 
 	stealth:		{type: Schemas.Skill},
-	"stealth.ability": 			{ type: String, defaultValue: "dexterity" },
+	"stealth.ability":          {type: String, defaultValue: "dexterity"},
 
 	survival:		{type: Schemas.Skill},
-	"survival.ability": 		{ type: String, defaultValue: "wisdom" },
+	"survival.ability":         {type: String, defaultValue: "wisdom"},
-
 
 	//Mechanical Skills
-	initiative: 		{type: Schemas.Skill},
+	initiative:      {type: Schemas.Skill},
-	"initiative.ability":		{ type: String, defaultValue: "dexterity" },
+	"initiative.ability":		{type: String, defaultValue: "dexterity"},
 
 	dexterityArmor:		{type: Schemas.Skill},
-	"dexterityArmor.ability":	{ type: String, defaultValue: "dexterity" },
+	"dexterityArmor.ability":	{type: String, defaultValue: "dexterity"},
 
 	//mechanics
-	deathSave:      { type: Schemas.DeathSave },
+	deathSave:      {type: Schemas.DeathSave},
 
 	//permissions
-	owner:   { type: String, regEx: SimpleSchema.RegEx.Id },
+	party:   {type: String, regEx: SimpleSchema.RegEx.Id, optional: true},
-	readers: { type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: [] },
+	owner:   {type: String, regEx: SimpleSchema.RegEx.Id},
-	writers: { type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: [] },
+	readers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: []},
-	color:   {type: String, allowedValues: _.pluck(colorOptions, "key"), defaultValue: "q"},
+	writers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: []},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
 	//TODO add per-character settings
-	"settings.experiencesInc": {type: Number, defaultValue: 20}, //how many experiences to load at a time in XP table
+	//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"],
+	},
 });
 
 Characters.attachSchema(Schemas.Character);
 
-var attributeBase = function(charId, statName){
+var attributeBase = preventLoop(function(charId, statName){
 	check(statName, String);
-	var effects = Effects.find({charId: charId, stat: statName, enabled: true}).fetch();
+	//if it's a damage multiplier, we treat it specially
-	effects = _.groupBy(effects, "operation");
+	if (_.contains(DAMAGE_MULTIPLIERS, statName)){
-	var value = _.contains(DAMAGE_MULTIPLIERS, statName)? 1 : 0;
+		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;
 
-	//start with the highest base value
+	Effects.find({
-	_.each(effects.base, function(effect){
+		charId: charId,
-		var efv = evaluateEffect(charId, effect)
+		stat: statName,
-		if (efv > value){
+		enabled: true,
-			value = efv;
+		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;
 		}
 	});
 
-	//add all the add values
+	var result = (base + add) * mul;
-	_.each(effects.add, function(effect){
+	if (result < min) result = min;
-		value += evaluateEffect(charId, effect);
+	if (result > max) result = max;
-	});
 
-	//multiply all the mul values
+	return Math.floor(result);
-	_.each(effects.mul, function(effect){
+});
-		value *= evaluateEffect(charId, effect);
-	});
 
-	//ensure value is >= all mins
+if (Meteor.isClient) {
-	_.each(effects.min, function(effect){
+	Template.registerHelper("characterCalculate", function(func, charId, input) {
-		var min = evaluateEffect(charId, effect);
+		try {
-		value = value > min? value : min;
+			return Characters.calculate[func](charId, input);
+		} catch (e){
+			if (!Characters.calculate[func]){
+				throw new Error(func + "is not a function name");
+			} else {
+				throw e;
+			}
+		}
 	});
-
-	//ensure value is <= all maxes
-	_.each(effects.max, function(effect){
-		var max = evaluateEffect(charId, effect);
-		value = value < max? value : max;
-	});
-	return value;
 }
 
+//create a local memoize with a argument concatenating hash function
+var memoize = function(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});
+		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);
+		//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);
+		//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 skill = Characters.calculate.getField(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 depreciated = function() {
+	//var err = new Error("this function has been depreciated");
+	var name = "";
+	if (Template.instance()){
+		name = Template.instance().view.name;
+	}
+	var logString = "this function has been depreciated \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
@@ -219,166 +463,63 @@ Characters.helpers({
 	//returns the value stored in the field requested
 	//will set up dependencies on just that field
 	getField : function(fieldName){
-		var fieldSelector = {};
+		depreciated();
-		fieldSelector[fieldName] = 1;
+		return Characters.calculate.getField(this._id, fieldName);
-		var char = Characters.findOne(this._id, {fields: fieldSelector});
-		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;
 	},
 	//returns the value of a field
 	fieldValue : function(fieldName){
-		if(!Schemas.Character.schema(fieldName)){
+		depreciated();
-			throw new Meteor.Error("Field not found", "Character's schema does not contain a field called: " + fieldName);
+		return Characters.calculate.fieldValue(this._id, fieldName);
-		}
-		//duck typing to get the right value function
-		//.ability implies skill
-		if (Schemas.Character.schema(fieldName + ".ability")){
-			return this.skillMod(fieldName);
-		}
-		//adjustment implies attribute
-		if (Schemas.Character.schema(fieldName + ".adjustment")){
-			return this.attributeValue(fieldName);
-		}
-		//fall back to just returning the field itself
-		return this.getField(fieldName);
 	},
-
 	attributeValue: function(attributeName){
-		var charId = this._id;
+		depreciated();
-		var attribute = this.getField(attributeName);
+		return Characters.calculate.attributeValue(this._id, attributeName);
-		//base value
+	},
-		var value = this.attributeBase(attributeName);
+	attributeBase: function(attributeName){
-		//plus adjustment
+		depreciated();
-		value += attribute.adjustment;
+		return Characters.calculate.attributeBase(this._id, attributeName);
-		return value;
+	},
+	skillMod: function(skillName){
+		depreciated();
+		return Characters.calculate.skillMod(this._id, skillName);
 	},
-
-	attributeBase: preventLoop(function(attributeName){
-		var charId = this._id;
-		//base value
-		return attributeBase(charId, attributeName);
-	}),
-
-	skillMod: preventLoop(function(skillName){
-		var charId = this._id;
-		var skill = this.getField(skillName);
-		//get the final value of the ability score
-		var ability = this.attributeValue(skill.ability);
-
-		//base modifier
-		var mod = +getMod(ability)
-
-		//multiply proficiency bonus by largest value in proficiency array
-		var prof = this.proficiency(skillName);
-
-		//add multiplied proficiency bonus to modifier
-		mod += prof * this.attributeValue("proficiencyBonus");
-
-		//apply all effects
-		var rawEffects = Effects.find({charId: charId, stat: skillName, enabled: true}).fetch();
-		var effects = _.groupBy(rawEffects, "operation");
-		_.forEach(effects.add, function(effect){
-			mod += evaluateEffect(charId, effect);
-		});
-		_.forEach(effects.mul, function(effect){
-			mod *= evaluateEffect(charId, effect);
-		});
-		_.forEach(effects.min, function(effect){
-			var min = evaluateEffect(charId, effect);
-			mod = mod > min? mod : min;
-		});
-		_.forEach(effects.max, function(effect){
-			var max = evaluateEffect(charId, effect);
-			mod = mod < max? mod : max;
-		});
-		return signedString(mod);
-	}),
-
 	proficiency: function(skillName){
-		var charId = this._id;
+		depreciated();
-		//return largest value in proficiency array
+		return Characters.calculate.proficiency(this._id, skillName);
-		var prof = 0;
-		Effects.find({charId: charId, stat: skillName, enabled: true}).forEach(function(effect){
-			if(effect.operation === "proficiency"){
-				var newProf = evaluateEffect(charId, effect);
-				if (newProf > prof){
-					prof = newProf;
-				}
-			}
-		});
-		return prof;
 	},
-
 	passiveSkill: function(skillName){
-		if (_.isString(skillName)){
+		depreciated();
-			var skill = this.getField(skillName);
+		return Characters.calculate.passiveSkill(this._id, skillName);
-		}
-		var charId = this._id
-		var mod = +this.skillMod(skillName);
-		var value = 10 + mod;
-		Effects.find({charId: charId, stat: skillName, enabled: true, operation: "passiveAdd"}).forEach(function(effect){
-			value += evaluateEffect(charId, effect);
-		});
-		return value;
-		//TODO decide whether (dis)advantage gives (-)+5 to passive checks
 	},
-
 	advantage: function(skillName){
-		var charId = this._id
+		depreciated();
-		var advantage = Effects.find({charId: charId, stat: skillName, enabled: true, operation: "advantage"}).count();
+		return Characters.calculate.advantage(this._id, skillName);
-		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(attribute){
-		return signedString(getMod(this.attributeValue(attribute)));
+		depreciated();
+		return Characters.calculate.abilityMod(this._id, attribute);
 	},
-
 	passiveAbility: function(attribute){
-		var mod = +getMod(this.attributeValue(attribute));
+		depreciated();
-		return 10 + mod;
+		return Characters.calculate.passiveAbility(this._id, attribute);
 	},
-
 	xpLevel: function(){
-		var xp = this.experience();
+		depreciated();
-		var xpTable = [0, 300, 900, 2700, 6500, 14000, 23000, 34000, 48000, 64000,
+		return Characters.calculate.xpLevel(this._id);
-					   85000, 100000, 120000, 140000, 165000, 195000, 225000, 265000,
-					   305000, 355000];
-		for(var i = 0; i < 19; i++){
-			if(xp < xpTable[i]){
-				return i;
-			}
-		};
-		if(xp > 355000) return 20;
-		return 0;
 	},
-
 	level: function(){
-		var level = 0;
+		depreciated();
-		Classes.find({charId: this._id}).forEach(function(cls){
+		return Characters.calculate.level(this._id);
-			level += cls.level;
-		})
-		return level;
 	},
-
 	experience: function(){
-		var xp = 0;
+		depreciated();
-		Experiences.find({charId: this._id}, {fields: {value: 1}}).forEach(function(e){
+		return Characters.calculate.experience(this._id);
-			xp += e.value;
+	},
-		})
-		return xp;
-	}
 });
 
 //clean up all data related to that character before removing it
-Characters.after.remove(function (userId, character) {
+if (Meteor.isServer){
-	if(Meteor.isServer){
+	Characters.after.remove(function(userId, character) {
 		Actions       .remove({charId: character._id});
 		Attacks       .remove({charId: character._id});
 		Buffs         .remove({charId: character._id});
@@ -391,29 +532,29 @@ Characters.after.remove(function (userId, character) {
 		SpellLists    .remove({charId: character._id});
 		Items         .remove({charId: character._id});
 		Containers    .remove({charId: character._id});
-	}
+	});
-});
+}
 
 Characters.allow({
-	insert: function (userId, doc) {
+	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) {
+	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) {
+	remove: function(userId, doc) {
 		// can only remove your own documents
 		return doc.owner === userId;
 	},
-	fetch: ["owner", "writers"]
+	fetch: ["owner", "writers"],
 });
 
 Characters.deny({
-	update: function (userId, docs, fields, modifier) {
+	update: function(userId, docs, fields, modifier) {
 		// can't change owners
-		return _.contains(fields, 'owner');
+		return _.contains(fields, "owner");
 	}
 });

rpg-docs/Model/Character/Classes.js

@@ -8,21 +8,25 @@ Schemas.Class = new SimpleSchema({
 		type: Date,
 		autoValue: function() {
 			if (this.isInsert) {
-				return new Date;
+				return new Date();
 			} else if (this.isUpsert) {
-				return {$setOnInsert: new Date};
+				return {$setOnInsert: new Date()};
 			} else {
 				this.unset();
 			}
-		}
+		},
+	},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
 	},
-	color:   {type: String, allowedValues: _.pluck(colorOptions, "key"), defaultValue: "q"}
 });
 
 Classes.attachSchema(Schemas.Class);
 
-Classes.attachBehaviour('softRemovable');
+Classes.attachBehaviour("softRemovable");
-makeParent(Classes, 'name'); //parents of effects and attacks
+makeParent(Classes, "name"); //parents of effects and attacks
 
 Classes.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Classes.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Effects.js

@@ -7,33 +7,39 @@ Effects = new Mongo.Collection("effects");
 Schemas.Effect = new SimpleSchema({
 	charId: {
 		type: String,
-		regEx: SimpleSchema.RegEx.Id
+		regEx: SimpleSchema.RegEx.Id,
 	},
 	name: {
 		type: String,
 		optional: true, //TODO make necessary if there is no owner
-		trim: false
+		trim: false,
 	},
 	operation: {
 		type: String,
 		defaultValue: "add",
-		allowedValues: ["base", "proficiency","add","mul","min","max","advantage","disadvantage","passiveAdd","fail","conditional"]
+		allowedValues: [
+			"base",
+			"proficiency",
+			"add",
+			"mul",
+			"min",
+			"max",
+			"advantage",
+			"disadvantage",
+			"passiveAdd",
+			"fail",
+			"conditional",
+		],
 	},
 	value: {
 		type: Number,
 		decimal: true,
-		optional: true
+		optional: true,
 	},
 	calculation: {
 		type: String,
 		optional: true,
-		trim: false
+		trim: false,
-	},
-	//indicates what the effect originated from
-	type: {
-		type: String,
-		defaultValue: "editable",
-		allowedValues: ["editable", "feature", "class", "buff", "equipment", "racial", "inate"]
 	},
 	//the thing that created this effect
 	parent: {
@@ -42,69 +48,69 @@ Schemas.Effect = new SimpleSchema({
 	//which stat the effect is applied to
 	stat: {
 		type: String,
-		optional: true
+		optional: true,
 	},
 	enabled: {
 		type: Boolean,
-		defaultValue: true
+		defaultValue: true,
-	}
+	},
 });
 
 Effects.attachSchema(Schemas.Effect);
 
-if(Meteor.isServer) Characters.after.insert(function (userId, char) {
+if (Meteor.isServer) Characters.after.insert(function(userId, char) {
 	Effects.insert({
 		charId: char._id,
-		type: "inate",
 		name: "Constitution modifier for each level",
 		stat: "hitPoints",
 		operation: "add",
 		calculation: "level * constitutionMod",
 		parent: {
 			id: char._id,
-			collection: "Characters"
+			collection: "Characters",
-		}
+			group: "Inate",
+		},
 	});
 	Effects.insert({
 		charId: char._id,
-		type: "inate",
 		name: "Proficiency bonus by level",
 		stat: "proficiencyBonus",
 		operation: "add",
 		calculation: "floor(level / 4 + 1.75)",
 		parent: {
 			id: char._id,
-			collection: "Characters"
+			collection: "Characters",
-		}
+			group: "Inate",
+		},
 	});
 	Effects.insert({
 		charId: char._id,
-		type: "inate",
 		name: "Dexterity Armor Bonus",
 		stat: "armor",
 		operation: "add",
 		calculation: "dexterityArmor",
 		parent: {
 			id: char._id,
-			collection: "Characters"
+			collection: "Characters",
-		}
+			group: "Inate",
+		},
 	});
 	Effects.insert({
 		charId: char._id,
-		type: "inate",
 		name: "Natural Armor",
 		stat: "armor",
 		operation: "base",
 		value: 10,
 		parent: {
 			id: char._id,
-			collection: "Characters"
+			collection: "Characters",
-		}
+			group: "Inate",
+		},
 	});
 });
 
-Effects.attachBehaviour('softRemovable');
+Effects.attachBehaviour("softRemovable");
-makeChild(Effects, ['name', 'enabled']); //children of lots of things
+makeChild(Effects, ["enabled"]); //children of lots of things
 
 Effects.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Effects.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Experience.js

@@ -9,19 +9,19 @@ Schemas.Experience = new SimpleSchema({
 		type: Date,
 		autoValue: function() {
 			if (this.isInsert) {
-				return new Date;
+				return new Date();
 			} else if (this.isUpsert) {
-				return {$setOnInsert: new Date};
+				return {$setOnInsert: new Date()};
 			} else {
 				this.unset();
 			}
-		}
+		},
 	},
 });
 
 Experiences.attachSchema(Schemas.Experience);
 
-Experiences.attachBehaviour('softRemovable');
+Experiences.attachBehaviour("softRemovable");
 
 Experiences.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Experiences.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Features.js

@@ -6,10 +6,17 @@ Schemas.Feature = new SimpleSchema({
 	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"},
+	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"}
+	color:   {type: String,
+			  allowedValues: _.pluck(colorOptions, "key"),
+			  defaultValue: "q",
+			 },
 });
 
 Features.attachSchema(Schemas.Feature);
@@ -20,11 +27,11 @@ Features.helpers({
 	},
 	usesValue: function(){
 		return evaluate(this.charId, this.uses);
-	}
+	},
 });
 
-Features.attachBehaviour('softRemovable');
+Features.attachBehaviour("softRemovable");
-makeParent(Features, ['name', 'enabled']); //parents of effects and attacks
+makeParent(Features, ["name", "enabled"]); //parents of effects and attacks
 
 Features.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Features.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/Notes.js

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

rpg-docs/Model/Character/Proficiencies.js

@@ -2,25 +2,35 @@ Proficiencies = new Mongo.Collection("proficiencies");
 
 Schemas.Proficiency = new SimpleSchema({
 	charId: {
-		type: String, 
-		regEx: SimpleSchema.RegEx.Id
-	},
-	name: 	{
 		type: String,
-		trim: false
+		regEx: SimpleSchema.RegEx.Id,
+	},
+	name: {
+		type: String,
+		trim: false,
+		optional: true,
+	},
+	value: {
+		type: Number,
+		allowedValues: [0, 0.5, 1, 2],
+		defaultValue: 1,
+		decimal: true,
 	},
-	//indicates what type of thing proficiency originated from
 	type: {
 		type: String,
-		defaultValue: "editable",
+		allowedValues: ["skill", "save", "weapon", "armor", "tool", "language"],
-		allowedValues: ["editable", "feature", "buff", "equipment", "inate"]
+		defaultValue: "skill",
+	},
+	enabled: {
+		type: Boolean,
+		defaultValue: true,
 	},
 });
 
 Proficiencies.attachSchema(Schemas.Proficiency);
 
-Proficiencies.attachBehaviour('softRemovable');
+Proficiencies.attachBehaviour("softRemovable");
-makeChild(Proficiencies); 
+makeChild(Proficiencies);
 
 Proficiencies.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Proficiencies.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Character/SpellLists.js

@@ -7,7 +7,11 @@ Schemas.SpellLists = new SimpleSchema({
 	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"},
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
 	"settings.showUnprepared": {type: Boolean, defaultValue: true},
 });
 
@@ -16,14 +20,17 @@ 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){
+		Spells.find(
+			{charId: this.charId, listId: this._id, prepared: 1},
+			{fields: {prepareCost: 1}}
+		).forEach(function(spell){
 			num += spell.prepareCost;
 		});
 		return num;
 	}
 });
 
-SpellLists.attachBehaviour('softRemovable');
+SpellLists.attachBehaviour("softRemovable");
 makeParent(SpellLists); //parents of spells
 
 SpellLists.allow(CHARACTER_SUBSCHEMA_ALLOW);

rpg-docs/Model/Character/Spells.js

@@ -2,26 +2,67 @@ Spells = new Mongo.Collection("spells");
 
 Schemas.Spell = new SimpleSchema({
 	charId:      {type: String, regEx: SimpleSchema.RegEx.Id},
-	prepared:    {type: String, defaultValue: "prepared", allowedValues: ["prepared","unprepared","always"]},
+	prepared: {
-	name:        {type: String, trim: false, defaultValue: "New Spell"},
+		type: String,
-	description: {type: String, optional: true, trim: false},
+		defaultValue: "prepared",
-	castingTime: {type: String, optional: true, defaultValue: "action", trim: false},
+		allowedValues: ["prepared", "unprepared", "always"],
-	range:       {type: String, optional: true, trim: false},
+	},
-	duration:    {type: String, optional: true, trim: false, defaultValue: "Instantaneous"},
+	name: {
-	"components.verbal":		{type: Boolean, defaultValue: false},
+		type: String,
-	"components.somatic":		{type: Boolean, defaultValue: false},
+		trim: false,
-	"components.material":		{type: String, optional: true},
+		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},
-	ritual:      {type: Boolean, defaultValue: false},
+	"components.material":      {type: String, optional: true},
-	level:       {type: Number, defaultValue: 1},
+	ritual:      {
-	school:      {type: String, defaultValue: "Abjuration", allowedValues: magicSchools},
+		type: Boolean,
-	color:       {type: String, allowedValues: _.pluck(colorOptions, "key"), defaultValue: "q"}
+		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');
+Spells.attachBehaviour("softRemovable");
 makeChild(Spells); //children of spell lists
+makeParent(Spells, ["name", "enabled"]); //parents of attacks
 
 Spells.allow(CHARACTER_SUBSCHEMA_ALLOW);
 Spells.deny(CHARACTER_SUBSCHEMA_DENY);

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

@@ -3,23 +3,19 @@
  * Damage, healing and resource cost/recovery are all adjustments
  */
 Schemas.Adjustment = new SimpleSchema({
-	name: {
-		type: String,
-		optional: true
-	},
 	//which stat the adjustment is applied to
 	stat: {
 		type: String,
-		optional: true
+		optional: true,
 	},
 	//the value added to the stat
 	value: {
 		type: Number,
 		decimal: true,
-		optional: true
+		optional: true,
 	},
 	calculation: {
 		type: String,
-		optional: true
+		optional: true,
-	}
+	},
 });

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

@@ -3,11 +3,11 @@ Schemas.Attribute = new SimpleSchema({
 	//should be zero after reset
 	adjustment: {
 		type: Number,
-		defaultValue: 0
+		defaultValue: 0,
 	},
 	reset: {
 		type: String,
 		defaultValue: "longRest",
-		allowedValues: ["longRest", "shortRest"]
+		allowedValues: ["longRest", "shortRest"],
-	}
+	},
 });

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

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

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

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

rpg-docs/Model/Character/TemporaryHitPoints.js

@@ -5,7 +5,7 @@ Schemas.TemporaryHitPoints = new SimpleSchema({
 	name:        {type: String, optional: true},
 	maximum:     {type: Number, defaultValue: 0},
 	used:        {type: Number, defaultValue: 0},
-	deleteOnZero:{type: Boolean, defaultValue: true},
+	deleteOnZero:{type: Boolean, defaultValue: false},
 	dateAdded:   {
 		type: Date,
 		autoValue: function() {
@@ -16,7 +16,7 @@ Schemas.TemporaryHitPoints = new SimpleSchema({
 			} else {
 				this.unset();
 			}
-		}
+		},
 	},
 });
 
@@ -29,11 +29,13 @@ TemporaryHitPoints.helpers({
 });
 
 //remove the temporary hit points when they hit zero
-TemporaryHitPoints.after.update(function (userId, thp, fieldNames, modifier, options) {
+TemporaryHitPoints.after.update(
-	if(thp.used >= thp.maximum && thp.deleteOnZero){
+	function(userId, thp, fieldNames, modifier, options){
-		TemporaryHitPoints.remove(thp._id);
+		if (thp.used >= thp.maximum && thp.deleteOnZero){
-	}
+			TemporaryHitPoints.remove(thp._id);
-}, {fetchPrevious: false});
+		}
+	}, {fetchPrevious: false}
+);
 
 TemporaryHitPoints.allow(CHARACTER_SUBSCHEMA_ALLOW);
 TemporaryHitPoints.deny(CHARACTER_SUBSCHEMA_DENY);

rpg-docs/Model/Inventory/Containers.js

@@ -2,39 +2,55 @@
 Containers = new Mongo.Collection("containers");
 
 Schemas.Container = new SimpleSchema({
-	name: 		{ type: String, trim: false },
+	name:       {type: String, trim: false},
-	charId: 	{ type: String, regEx: SimpleSchema.RegEx.Id},
+	charId:     {type: String, regEx: SimpleSchema.RegEx.Id},
-	isCarried: 	{ type: Boolean },
+	isCarried:  {type: Boolean},
 	weight:		{type: Number, min: 0, defaultValue: 0, decimal: true},
 	value:		{type: Number, min: 0, defaultValue: 0, decimal: true},
 	description:{type: String, optional: true, trim: false},
-	color:   {type: String, allowedValues: _.pluck(colorOptions, "key"), defaultValue: "q"}
+	color:   {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
 });
 
 Containers.attachSchema(Schemas.Container);
 
 Containers.helpers({
-	totalValue: function(){
+	contentsValue: function(){
-		var value = this.value;
+		var value = 0;
-		Items.find({"parent.id": this._id}, {fields: {quantity: 1, value: 1}}).forEach(function(item){
+		Items.find(
+			{"parent.id": this._id},
+			{fields: {quantity: 1, value: 1}}
+		).forEach(function(item){
 			value += item.totalValue();
 		});
 		return value;
 	},
-	totalWeight: function(){
+	totalValue: function(){
-		var weight = this.weight;
+		return this.contentsValue() + this.value;
-		Items.find({"parent.id": this._id}, {fields: {quantity: 1, weight: 1}}).forEach(function(item){
+	},
+	contentsWeight: function(){
+		var weight = 0;
+		Items.find(
+			{"parent.id": this._id},
+			{fields: {quantity: 1, weight: 1}}
+		).forEach(function(item){
 			weight += item.totalWeight();
 		});
 		return weight;
 	},
+	totalWeight: function(){
+		return this.contentsWeight() + this.weight;
+	},
 	moveToCharacter: function(characterId){
-		if(this.charId === characterId) return;
+		if (this.charId === characterId) return;
 		Items.update(this._id, {$set: {charId: characterId}});
-	}
+	},
 });
 
-Containers.attachBehaviour('softRemovable');
+Containers.attachBehaviour("softRemovable");
 makeParent(Containers); //parents of items
 
 Containers.allow(CHARACTER_SUBSCHEMA_ALLOW);

rpg-docs/Model/Inventory/Items.js

@@ -1,4 +1,4 @@
-Items = new Mongo.Collection('items');
+Items = new Mongo.Collection("items");
 
 Schemas.Item = new SimpleSchema({
 	name:       {type: String, defaultValue: "New Item", trim: false},
@@ -10,11 +10,166 @@ Schemas.Item = new SimpleSchema({
 	value:		{type: Number, min: 0, defaultValue: 0, decimal: true},
 	enabled:    {type: Boolean, defaultValue: false},
 	requiresAttunement: {type: Boolean, defaultValue: false},
-	color:      {type: String, allowedValues: _.pluck(colorOptions, "key"), defaultValue: "q"}
+	"settings.showIncrement": {type: Boolean, defaultValue: false},
+	color:      {
+		type: String,
+		allowedValues: _.pluck(colorOptions, "key"),
+		defaultValue: "q",
+	},
 });
 
 Items.attachSchema(Schemas.Item);
 
+var checkMovePermission = function(itemId, parent) {
+	var item = Items.findOne(itemId);
+	if (!item)
+		throw new Meteor.Error("No such item",
+							   "An item could not be found to move");
+	//handle permissions
+	var permission = Meteor.call("canWriteCharacter", item.charId);
+	if (!permission){
+		throw new Meteor.Error("Access denied",
+							   "Not permitted to move items 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 items 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 items to this character");
+			}
+		}
+	}
+};
+
+var moveItem = function(itemId, enable, parentCollection, parentId) {
+	var item = Items.findOne(itemId);
+	if (!item) return;
+	parentCollection = parentCollection || item.parent.collection;
+	parentId = parentId || item.parent.id;
+
+	if (Meteor.isServer) {
+		checkMovePermission(itemId, {collection: parentCollection, id: parentId});
+	}
+
+	//update the item provided the update will actually change something
+	if (
+		item.parent.collection !== parentCollection ||
+		item.parent.id !== parentId ||
+		item.enabled !== enable
+	){
+		Items.update(
+			itemId,
+			{$set: {
+				"parent.collection": parentCollection,
+				"parent.id": parentId,
+				enabled: enable,
+			}}
+		);
+	}
+};
+
+Meteor.methods({
+	moveItemToParent: function(itemId, parent) {
+		check(itemId, String);
+		check(parent, {collection: String, id: String});
+		moveItem(itemId, false, parent.collection, parent.id);
+	},
+	moveItemToCharacter: function(itemId, charId) {
+		check(itemId, String);
+		check(charId, String);
+		moveItem(itemId, false, "Characters", charId);
+	},
+	moveItemToContainer: function(itemId, containerId) {
+		check(itemId, String);
+		check(containerId, String);
+		moveItem(itemId, false, "Containers", containerId);
+	},
+	equipItem: function(itemId, charId){
+		check(itemId, String);
+		check(charId, String);
+		moveItem(itemId, true, "Characters", charId);
+	},
+	unequipItem: function(itemId, charId){
+		check(itemId, String);
+		check(charId, String);
+		moveItem(itemId, false, "Characters", charId);
+	},
+	splitItemToParent: function(itemId, moveQuantity, parent){
+		check(itemId, String);
+		check(moveQuantity, Number);
+		check(parent, {id: String, collection: String});
+
+		//get the item
+		var item = Items.findOne(itemId);
+		if (!item) return;
+
+		//don't bother moving nothing
+		if (moveQuantity <= 0 || item.quantity <= 0){
+			return;
+		}
+		//ensure we are only moving up to the current stack size
+		if (item.quantity < moveQuantity){
+			moveQuantity = this.quantity;
+		}
+
+		if (Meteor.isServer) {
+			checkMovePermission(itemId, parent);
+		}
+
+		//create a new item stack
+		var newStack = _.omit(EJSON.clone(item), "_id");
+		newStack.parent = parent;
+		newStack.quantity = moveQuantity;
+
+		//find out if we have an exact replica in the destination
+		var query = _.omit(newStack, ["parent", "quantity"]);
+		query["parent.collection"] = newStack.parent.collection;
+		query["parent.id"] = newStack.parent.id;
+		query._id = {$ne: itemId}; //make sure we don't join it to itself
+		var existingStack = Items.findOne(query);
+		if (existingStack){
+			//increase the existing stack's size
+			Items.update(
+				existingStack._id,
+				{$inc: {quantity: moveQuantity}}
+			);
+		} else {
+			//insert the new stack
+			Items.insert(newStack, function(err, id){
+				if (err) throw err;
+				//copy the children also
+				Meteor.call("cloneChildren", item._id, {collection: "Items", id: id});
+			});
+		}
+
+		//reduce the old stack's size
+		var oldQuantity = item.quantity - moveQuantity;
+		if (oldQuantity === 0){
+			Items.remove(itemId);
+		} else {
+			Items.update(itemId, {$set: {quantity: oldQuantity}});
+		}
+	},
+});
+
 Items.helpers({
 	totalValue: function(){
 		return this.value * this.quantity;
@@ -23,73 +178,21 @@ Items.helpers({
 		return this.weight * this.quantity;
 	},
 	pluralName: function(){
-		if(this.plural && this.quantity !== 1){
+		if (this.plural && this.quantity !== 1){
 			return this.plural;
-		} else{
+		} else {
 			return this.name;
 		}
 	},
-	equip: function(characterId){
-		var charId = characterId || this.charId;
-		if(!charId || ! Characters.findOne(charId)) throw "Invalid character";
-		if(this.parent.collection === "Characters" && this.parent.id === charId && this.enabled) return;
-		Items.update(this._id, {$set: {"parent.collection": "Characters", "parent.id": charId, enabled: true}});
-	},
-	unequip: function(){
-		if(!this.enabled) return;
-		Items.update(this._id, {$set: {enabled: false}});
-	},
-	moveToContainer: function(containerId){
-		if( !containerId || !Containers.findOne(containerId) ) throw "Invalid container";
-		if(this.parent.collection === "Containers" && this.parent.id === containerId && !this.enabled) return;
-		Items.update(this._id, {$set: {"parent.collection": "Containers", "parent.id": containerId, enabled: false}});
-	},
-	moveToCharacter: function(characterId){
-		if(!characterId || ! Characters.findOne(characterId)) throw "Invalid character";
-		if(this.parent.collection === "Characters" && this.parent.id === characterId && !this.enabled) return;
-		Items.update(this._id, {$set: {"parent.collection": "Characters", "parent.id": characterId, charId: characterId, enabled: false}});
-	},
-	splitToParent: function(parent, moveQuantity){
-		check(parent, {id: String, collection: String});
-		check(moveQuantity, Number);
-		var parentCollection = Meteor.isClient? window[parent.collection] : global[parent.collection];
-		if(!parent.id || !parentCollection.findOne(parent.id)) throw "Invalid parent";
-		var oldStack = this;
-		//we can only move as much as we have, leaving 0 behind at worst
-		if(oldStack.quantity < moveQuantity) moveQuantity = oldStack.quantity;
-		var oldQuantity = oldStack.quantity - moveQuantity;
-
-		var newStack = _.pick(oldStack, Schemas.Item.objectKeys());
-		newStack.parent = parent;
-		newStack.quantity = moveQuantity;
-
-		var existingStack = Items.findOne(_.omit(newStack, "quantity"));
-		var updateStackSize = function(){
-			if(oldQuantity > 0){
-				Items.update(oldStack._id, {$set: {quantity: oldQuantity}});
-			} else {
-				Items.remove(oldStack._id);
-			}
-		};
-		if(existingStack){
-			Items.update(existingStack._id, {$inc: {quantity: moveQuantity}}, {}, function(){
-				updateStackSize();
-			});
-		}else{
-			Items.insert(newStack, function(err, id){
-				if(err) throw err;
-				updateStackSize();
-				//copy the children also
-				Meteor.call("cloneChildren", oldStack._id, {collection: "Items", id: id});
-			});
-		}
-	}
 });
 
 Items.before.update(function(userId, doc, fieldNames, modifier, options){
-	if(
+	if (
 		modifier && modifier.$set && modifier.$set.enabled && //we are equipping this item
-		!(modifier.$set["parent.collection"] === "Characters" && modifier.$set["parent.id"]) //and we haven't specified a character to equip to
+		!(
+			modifier.$set["parent.collection"] === "Characters" &&
+			modifier.$set["parent.id"]
+		) //and we haven"t specified a character to equip to
 	){
 		//equip it to the current character
 		modifier.$set["parent.collection"] = "Characters";
@@ -97,21 +200,21 @@ Items.before.update(function(userId, doc, fieldNames, modifier, options){
 	}
 });
 
-Items.attachBehaviour('softRemovable');
+Items.attachBehaviour("softRemovable");
 makeChild(Items); //children of containers
-makeParent(Items, ['name', 'enabled']); //parents of effects and attacks
+makeParent(Items, ["name", "enabled"]); //parents of effects and attacks
 
 Items.allow(CHARACTER_SUBSCHEMA_ALLOW);
 
 //give characters default items
-Characters.after.insert(function (userId, char) {
+Characters.after.insert(function(userId, char) {
-	if(Meteor.isServer){
+	if (Meteor.isServer){
 		var containerId = Containers.insert({
 			name: "Coin Pouch",
 			charId: char._id,
 			isCarried: true,
 			description: "A sturdy pouch for coins",
-			color: "d"
+			color: "d",
 		});
 		Items.insert({
 			name: "Gold piece",
@@ -123,8 +226,8 @@ Characters.after.insert(function (userId, char) {
 			color: "n",
 			parent: {
 				id: containerId,
-				collection: "Containers"
+				collection: "Containers",
-			}
+			},
 		});
 		Items.insert({
 			name: "Silver piece",
@@ -136,8 +239,8 @@ Characters.after.insert(function (userId, char) {
 			color: "q",
 			parent: {
 				id: containerId,
-				collection: "Containers"
+				collection: "Containers",
-			}
+			},
 		});
 		Items.insert({
 			name: "Copper piece",
@@ -149,8 +252,8 @@ Characters.after.insert(function (userId, char) {
 			color: "s",
 			parent: {
 				id: containerId,
-				collection: "Containers"
+				collection: "Containers",
-			}
+			},
 		});
 	}
 });

rpg-docs/Model/Meta/ChangeLogs.js

@@ -0,0 +1,27 @@
+ChangeLogs = new Mongo.Collection("changeLogs");
+
+Schemas.ChangeLog = new SimpleSchema({
+	version: {
+		type: String,
+	},
+	changes: {
+		type: [String],
+	},
+});
+
+ChangeLogs.attachSchema(Schemas.ChangeLog);
+
+ChangeLogs.allow({
+	insert: function(userId, doc) {
+		var user = Meteor.users.findOne(userId);
+		if (user) return _.contains(user.roles, "admin");
+	},
+	update: function(userId, doc, fields, modifier) {
+		var user = Meteor.users.findOne(userId);
+		if (user) return _.contains(user.roles, "admin");
+	},
+	remove: function(userId, doc) {
+		var user = Meteor.users.findOne(userId);
+		if (user) return _.contains(user.roles, "admin");
+	},
+});

rpg-docs/Model/Meta/Reports.js

@@ -0,0 +1,79 @@
+Reports = new Mongo.Collection("reports");
+
+Schemas.Report = new SimpleSchema({
+	owner: {
+		type: String,
+		regEx: SimpleSchema.RegEx.Id,
+	},
+	title: {
+		type: String,
+		trim: false,
+		optional: true,
+	},
+	description: {
+		type: String,
+		trim: false,
+		optional: true,
+	},
+	type: {
+		type: String,
+		allowedValues: ["bug", "change", "feature", "general"],
+		defaultValue: "bug",
+	},
+	//the immediate impact of doing this action (eg. -1 rages)
+	severity: {
+		type: Number,
+		defaultValue: 5,
+		min: 1,
+		max: 10,
+	},
+	metaData: {
+		type: Object,
+		blackbox: true,
+	},
+});
+
+Reports.attachSchema(Schemas.Report);
+
+Meteor.methods({
+	insertReport: function(report) {
+		check(report, {
+			title: String,
+			description: String,
+			type: String,
+			severity: Number,
+			metaData: Object,
+		});
+		report.owner = this.userId;
+		var id = Reports.insert(report);
+		var user = Meteor.users.findOne(this.userId);
+		var sender = user &&
+			user.emails &&
+			user.emails[0] &&
+			user.emails[0].address ||
+			user.services &&
+			user.services.google &&
+			user.services.google.email ||
+			"reports@dicecloud.com";
+		var bodyText = "Report ID: " + id +
+			"\nSeverity: " + report.severity +
+			"\nType: " + report.type +
+			"\n\n" + report.description;
+		Email.send({
+			from: sender,
+			to: "stefan.zermatten@gmail.com",
+			subject: "DiceCloud feedback - " + report.title,
+			text: bodyText,
+		});
+	},
+	deleteReport: function(id) {
+		var user = Meteor.users.findOne(this.userId);
+		if (!_.contains(user.roles, "admin")){
+			throw new Meteor.Error(
+				"not admin",
+				"The user must be an administrator to delete feedback"
+			);
+		}
+		Reports.remove(id);
+	},
+});

rpg-docs/Model/Users/Users.js

@@ -1,44 +1,23 @@
-Schema = {};
-
-Schema.User = new SimpleSchema({
-	username: {
-		type: String,
-		regEx: /^[a-z0-9A-Z_]{3,15}$/,
-		optional: true
-	},
-	emails: {
-		type: [Object],
-		// this must be optional if you also use other login services like facebook,
-		// but if you use only accounts-password, then it can be required
-		optional: true
-	},
-	"emails.$.address": {
-		type: String,
-		regEx: SimpleSchema.RegEx.Email
-	},
-	"emails.$.verified": {
-		type: Boolean
-	},
-	createdAt: {
-		type: Date
-	},
-	services: {
-		type: Object,
-		optional: true,
-		blackbox: true
-	},
-	roles: {
-		type: [String],
-		optional: true
-	}
-});
-
-Meteor.users.attachSchema(Schema.User);
-
 Meteor.users.allow({
-	update: function (userId, doc, fields, modifier) {
+	update: function(userId, doc, fields, modifier) {
-		return userId === doc._id &&
+		if (
-			fields.length === 1 &&
+			doc._id === userId &&
-			fields[0] === 'username';
+			_.contains(fields, "username") &&
+			_.contains(fields, "profile") &&
+			fields.length === 2 &&
+			_.keys(modifier).length === 1 &&
+			modifier.$set &&
+			modifier.$set["profile.username"] &&
+			modifier.$set.username &&
+			_.keys(modifier.$set).length === 2
+		){
+			var expectedUsername = modifier.$set["profile.username"];
+			expectedUsername = expectedUsername.toLowerCase().replace(/\s+/gm, "");
+			if (modifier.$set.username !== expectedUsername){
+				return false;
+			}
+			var foundUser = Meteor.call("getUserId", expectedUsername);
+			return !foundUser || foundUser === userId;
+		}
 	}
 });

rpg-docs/Routes/Routes.js

@@ -1,71 +1,95 @@
 Router.configure({
-	loadingTemplate: 'loading',
+	loadingTemplate: "loading",
-	layoutTemplate: 'layout'
+	layoutTemplate: "layout",
 });
 
-Router.map( function () {
+Router.plugin("ensureSignedIn", {
-	/*
+	only: [
-	this.route('home', {
+		"profile",
-		path: '/',
+		"characterList",
-		waitOn: function(){
+	]
-			return Meteor.subscribe("characterList", Meteor.userId());
+});
-		},
-		data: {
-			characters: function(){
-				return Characters.find({}, {fields: {_id: 1}});
-			}
-		}
-	});*/ //add a home route and change characterList route
 
-	this.route('characterList', {
+Router.plugin("dataNotFound", {notFoundTemplate: "notFound"});
-		path: '/',
+
-		waitOn: function(){
+Router.map(function() {
-			return Meteor.subscribe("characterList", Meteor.userId());
+	this.route("/", {
+		name: "home",
+		onAfterAction: function() {
+			document.title = appName;
 		},
-		data: {
-			characters: function(){
-				return Characters.find({}, {fields: {_id: 1}});
-			}
-		}
 	});
 
-	this.route('characterSheet', {
+	this.route("characterList", {
-		path: '/character/:_id',
+		path: "/characterList",
+		waitOn: function(){
+			return subsManager.subscribe("characterList", Meteor.userId());
+		},
+		data: {
+			characters: function(){
+				return Characters.find({}, {fields: {_id: 1}, sort: {name: 1}});
+			}
+		},
+		onAfterAction: function() {
+			document.title = appName;
+		},
+	});
+
+	this.route("characterSheet", {
+		path: "/character/:_id",
 		waitOn: function(){
 			return [
-				Meteor.subscribe("singleCharacter", this.params._id, Meteor.userId()),
+				subsManager.subscribe("singleCharacter", this.params._id, Meteor.userId()),
 			];
 		},
 		data: function() {
-			var data = Characters.findOne({_id: this.params._id}, {fields: {_id: 1, name: 1, color: 1}});
+			var data = Characters.findOne(
+				{_id: this.params._id},
+				{fields: {_id: 1, name: 1, color: 1, writers: 1, readers: 1}}
+			);
 			return data;
-		}
+		},
+		onAfterAction: function() {
+			var char = Characters.findOne({_id: this.params._id}, {fields: {name: 1}});
+			var name = char && char.name;
+			if (name){
+				document.title = name;
+			}
+		},
 	});
 
-	this.route('inventory', {
+	this.route("loading", {
-		path: '/inventory/:_id',
+		path: "/loading"
+	});
+
+	this.route("profile", {
+		path: "/account",
+		onAfterAction: function() {
+			document.title = appName + " Account";
+		},
+	});
+
+	this.route("/changelog", {
+		name: "changeLog",
+		waitOn: function() {
+			return [
+				subsManager.subscribe("changeLog"),
+			]
+		},
 		data: {
-			containers: function() {
+			changeLogs: function() {
-				var containers = Containers.find({owner: data._id}, {fields: {_id: 1}});
+				return ChangeLogs.find({}, {sort: {version: -1}});
-				return containers;
+			}
-			},
+		},
-
+		onAfterAction: function() {
-		}
+			document.title = appName;
+		},
 	});
 
-	this.route('item', {
+	this.route("/guide", {
-		path: '/item/:_id',
+		name: "guide",
-		data: function() {
+		onAfterAction: function() {
-			var data = Items.findOne({_id: this.params._id});
+			document.title = appName;
-			return data;
+		},
-		}
 	});
-
+});
-	this.route('loading', {
-		path: '/loading'
-	});
-
-	this.route('profile', {
-		path: '/account'
-	});
-});

rpg-docs/bower.json

@@ -13,10 +13,9 @@
     "tests"
   ],
   "dependencies": {
-    "polymer": "Polymer/polymer#~0.5.4",
+    "polymer": "Polymer/polymer#~0.5.5",
-    "core-elements": "Polymer/core-elements#~0.5.4",
+    "core-elements": "Polymer/core-elements#~0.5.5",
-    "paper-elements": "Polymer/paper-elements#~0.5.4",
+    "paper-elements": "Polymer/paper-elements#~0.5.5"
-	"paper-fab-menu": "cwdoh/paper-fab-menu"
   },
   "resolutions": {
     "core-component-page": "^0.5.0",

rpg-docs/client/globalHelpers/GlobalUI.js

@@ -12,10 +12,10 @@ this.GlobalUI = (function() {
 		return toast.show();
 	};
 
-	GlobalUI.deletedToast = function(id, collection, itemName){
+	GlobalUI.deletedToast = function(id, collection, itemName) {
 		GlobalUI.toast({
-			text: itemName? itemName + " deleted" : "Deleted item from" + collection,
+			text: itemName ? itemName + " deleted" : "Deleted item from" + collection,
-			template: "undoToast", 
+			template: "undoToast",
 			data: {
 				id: id,
 				collection: collection
@@ -23,7 +23,7 @@ this.GlobalUI = (function() {
 		});
 	};
 
-	GlobalUI.setDialog = function(opts){
+	GlobalUI.setDialog = function(opts) {
 		this.dialog = $("[global-dialog]")[0];
 		Session.set("global.ui.dialogHeader", opts.heading);
 		Session.set("global.ui.dialogData", opts.data);
@@ -58,7 +58,7 @@ this.GlobalUI = (function() {
 		Session.set("global.ui.detailShow", true);
 	};
 
-	//if setting the detail rather than showing it, 
+	//if setting the detail rather than showing it,
 	//the template should contain the following in template.rendered
 	//
 	//if (!this.alreadyRendered){
@@ -69,30 +69,30 @@ this.GlobalUI = (function() {
 		Session.set("global.ui.detailData", opts.data);
 		Session.set("global.ui.detailTemplate", opts.template);
 		Session.set("global.ui.detailHeroId", opts.heroId);
-		if(!!(window.history && window.history.pushState)){
+		if (window.history && window.history.pushState) {
 			history.replaceState({detail: "closed", opts: opts}, "Detail Dialog");
 			history.pushState({detail: "opened", opts: opts}, "Detail Dialog");
 		}
 	};
 
-	var throttleBack = _.throttle(function(){
+	var throttleBack = _.throttle(function() {
 		history.back();
 	}, 800, {trailing: false});
 
-	GlobalUI.closeDetail = function(){
+	GlobalUI.closeDetail = function() {
-		if(!!(window.history && window.history.pushState)){
+		if (!!(window.history && window.history.pushState)) {
 			throttleBack();
-		} else{
+		} else {
 			Session.set("global.ui.detailShow", false);
 		}
 	};
 
-	GlobalUI.popStateHandler = function(e){
+	GlobalUI.popStateHandler = function(e) {
 		var state = e.originalEvent.state;
-		if(state) {
+		if (state) {
-			if(state.detail === "closed"){
+			if (state.detail === "closed") {
 				Session.set("global.ui.detailShow", false);
-			} else if(state.detail === "opened"){
+			} else if (state.detail === "opened") {
 				var opts = state.opts;
 				Session.set("global.ui.detailData", opts.data);
 				Session.set("global.ui.detailTemplate", opts.template);
@@ -115,22 +115,22 @@ Template.layout.helpers({
 	globalDialogFullOnMobile: function() {
 		return Session.get("global.ui.dialogFullOnMobile");
 	},
-	globalDialogHeader: function(){
+	globalDialogHeader: function() {
 		return Session.get("global.ui.dialogHeader");
 	},
-	globalDetailSelected: function(){
+	globalDetailSelected: function() {
 		return Session.get("global.ui.detailShow") ? 1 : 0;
 	},
-	globalDetailTemplate: function(){
+	globalDetailTemplate: function() {
 		return Session.get("global.ui.detailTemplate");
 	},
-	globalDetailData: function(){
+	globalDetailData: function() {
 		return Session.get("global.ui.detailData");
 	},
-	globalToastTemplate: function(){
+	globalToastTemplate: function() {
 		return Session.get("global.ui.toastTemplate");
 	},
-	globalToastData: function(){
+	globalToastData: function() {
 		return Session.get("global.ui.toastData");
 	}
 });
@@ -143,7 +143,7 @@ Template.layout.events({
 	},
 	"core-animated-pages-transition-end [detail-pages]": function(e) {
 		var detailOpened = Session.get("global.ui.detailShow");
-		if(!detailOpened){
+		if (!detailOpened) {
 			Session.set("global.ui.detailData", null);
 			Session.set("global.ui.detailTemplate", null);
 			Session.set("global.ui.detailHeroId", null);
@@ -151,14 +151,14 @@ Template.layout.events({
 	},
 	"core-animated-pages-transition-prepare": function(e) {
 		var detailOpened = Session.get("global.ui.detailShow");
-		if(detailOpened) {
+		if (detailOpened) {
 			//set up the transition
 		} else {
 			//undo hack
 			$("#mainContentSection").removeClass("fake-selected");
 		}
 	},
-	"tap #screenDim": function(e){
+	"tap #screenDim": function(e) {
 		GlobalUI.closeDetail();
 	}
 });

rpg-docs/client/globalHelpers/canCast.js

@@ -1,3 +1,3 @@
-Template.registerHelper("canCast", function(){
+Template.registerHelper("canCast", function() {
 	return Characters.find({_id: this._id, spells: {$size: 0}}).count() === 0;
-});
+});

rpg-docs/client/globalHelpers/canEditCharacter.js

@@ -0,0 +1,10 @@
+Template.registerHelper("canEditCharacter", function(charId) {
+	return canEditCharacter(charId);
+});
+
+canEditCharacter = function(charId) {
+	var char = Characters.findOne(charId)
+	var userId = Meteor.userId();
+	return char.owner === userId ||
+		_.contains(char.writers, userId);
+};

rpg-docs/client/globalHelpers/colorClass.js

@@ -1,7 +1,11 @@
-Template.registerHelper("colorClass", function(color){
+Template.registerHelper("colorClass", function(color) {
-	return color? getColorClass(color) : getColorClass(this.color);
+	if (color) {
+		return getColorClass(color);
+	} else if (this.color) {
+		return getColorClass(this.color);
+	}
 });
 
-Template.registerHelper("hexColor", function(color){
+Template.registerHelper("hexColor", function(color) {
 	return getHexColor(color);
 });

rpg-docs/client/globalHelpers/detailHero.js

@@ -1,7 +1,9 @@
-Template.registerHelper("detailHero", function(suffix, givenId){
+Template.registerHelper("detailHero", function(suffix, givenId) {
 	var id = givenId || this._id;
-	if(suffix) id += suffix;
+	if (suffix) {
-	if ( Session.equals("global.ui.detailHeroId", id) ) {
+		id += suffix;
+	}
+	if (Session.equals("global.ui.detailHeroId", id)) {
 		return "hero";
 	}
-});
+});

rpg-docs/client/globalHelpers/effectList.js

@@ -1,124 +0,0 @@
-/*Template.registerHelper(function("effectList", */var disabled = function(charId, fieldName){
-	var obj = Characters.findOne(charId, {fields: {_id: 1}}).getField(fieldName);
-	var result = $("<div>");
-	if(_.has(obj, "conditional") && obj.conditional.length > 0){
-		_.each(obj.conditional, function(cond){
-			var c = $("<div>")
-			.append("* ")
-			.append(evaluateString(charId, cond.name));
-			result.append(c);
-		});
-	}
-
-	if(obj.base > 0){
-		var c = $("<div>")
-		.append($("<span>").addClass("auditValue").append(obj.base))
-		.append("Base");
-		result.append(c);
-	}
-
-	if(_.has(obj, "proficiency") && obj.proficiency.length > 0){
-		var highestProf = {};
-		_.each(obj.proficiency, function(prof, i){
-			var value = evaluateEffect(charId, prof)
-			if(i === 0 || value > highestProf.value){
-				highestProf.value = value;
-				highestProf.name = prof.name;
-				highestProf.calculation = prof.calculation;
-			}
-		});
-		var c = $("<div>")
-		.append($("<span>").addClass("auditValue").append(highestProf.value).append(" x Proficiency Bonus"))
-		.append(highestProf.name);
-		result.append(c);
-	}
-
-	if(_.has(obj, "add") && obj.add.length > 0){
-		_.each(obj.add, function(a){
-			var value = signedString(evaluateEffect(charId, a));
-			var c = $("<div>")
-			.append($("<span>").addClass("auditValue").append(value))
-			.append(a.name);
-			result.append(c);
-		});
-	}
-
-	if(_.has(obj, "mul") && obj.mul.length > 0){
-		_.each(obj.mul, function(a){
-			var value = signedString(evaluateEffect(charId, a));
-			var c = $("<div>")
-			.append($("<span>").addClass("auditValue").append("&times;").append(value))
-			.append(a.name);
-			result.append(c);
-		});
-	}
-
-	if(_.has(obj, "min") && obj.min.length > 0){
-		var highestMin = {};
-		_.each(obj.min, function(m, i){
-			var value = evaluateEffect(charId, m)
-			if(i === 0 || value > highestMin.value){
-				highestMin.value = value;
-				highestMin.name = m.name;
-				highestMin.calculation = m.calculation;
-			}
-		});
-		var c = $("<div>")
-		.append($("<span>").addClass("auditValue").append(highestMin.value).append(" Minimum"))
-		.append(highestMin.name);
-		result.append(c);
-	}
-
-	if(_.has(obj, "max") && obj.max.length > 0){
-		var lowestMax = {};
-		_.each(obj.max, function(m, i){
-			var value = evaluateEffect(charId, m)
-			if(i === 0 || value < lowestMax.value){
-				lowestMax.value = value;
-				lowestMax.name = m.name;
-				lowestMax.calculation = m.calculation;
-			}
-		});
-		var c = $("<div>")
-		.append($("<span>").addClass("auditValue").append(lowestMax.value).append(" Maximum"))
-		.append(lowestMax.name);
-		result.append(c);
-	}
-
-	if(obj.base < 0){
-		var c = $("<div>")
-		.append($("<span>").addClass("auditValue").append(obj.base))
-		.append("Damage");
-		result.append(c);
-	}
-
-	if(_.has(obj, "advantage") && obj.advantage.length > 0){
-		_.each(obj.advantage, function(adv){
-			var c = $("<div>")
-			.append($("<span>").addClass("auditValue").append("Advantage"))
-			.append(adv.name);
-			result.append(c);
-		})
-	}
-
-	if(_.has(obj, "disadvantage") && obj.disadvantage.length > 0){
-		_.each(obj.disadvantage, function(disadv){
-			var c = $("<div>")
-			.append($("<span>").addClass("auditValue").append("Disadvantage"))
-			.append(disadv.name);
-			result.append(c);
-		})
-	}
-
-	if(_.has(obj, "fail") && obj.fail.length > 0){
-		_.each(obj.fail, function(f){
-			var c = $("<div>")
-			.append($("<span>").addClass("auditValue").append("Fail"))
-			.append(f.name);
-			result.append(c);
-		})
-	}
-	var string = result.html()
-	if (_.isString(string)) return Spacebars.SafeString(string);
-	return string;
-};

rpg-docs/client/globalHelpers/evaluate.js

@@ -1,25 +1,25 @@
-Template.registerHelper("evaluate", function(charId, string){
+Template.registerHelper("evaluate", function(charId, string) {
 	return evaluate(charId, string);
 });
 
-Template.registerHelper("evaluateSigned", function(charId, string){
+Template.registerHelper("evaluateSigned", function(charId, string) {
 	var number = evaluate(charId, string);
-	if(_.isFinite(number)){
+	if (_.isFinite(number)) {
-		return number > 0? "+" + number : "" + number;
+		return number > 0 ? "+" + number : "" + number;
-	} else{
+	} else {
 		return number;
 	}
 });
 
-Template.registerHelper("evaluateSignedSpaced", function(charId, string){
+Template.registerHelper("evaluateSignedSpaced", function(charId, string) {
 	var number = evaluate(charId, string);
-	if(_.isFinite(number)){
+	if (_.isFinite(number)) {
-		return number > 0? "+ " + number : "- " + (-1 * number);
+		return number > 0 ? "+ " + number : "- " + (-1 * number);
-	} else{
+	} else {
 		return number;
 	}
 });
 
-Template.registerHelper("evaluateString", function(charId, string){
+Template.registerHelper("evaluateString", function(charId, string) {
 	return evaluateString(charId, string);
 });

rpg-docs/client/globalHelpers/openParentDialog.js

@@ -0,0 +1,32 @@
+openParentDialog = function(parent, charId, heroId) {
+	var detail;
+	if (parent.collection === "Characters" && parent.group === "racial") {
+		detail = {
+			template: "raceDialog",
+			data: {charId: parent.id},
+		};
+	} else if (parent.collection === "Features") {
+		detail = {
+			template: "featureDialog",
+			data:     {featureId: parent.id},
+		};
+	} else if (parent.collection === "Classes") {
+		detail = {
+			template: "classDialog",
+			data: {classId: parent.id},
+		};
+	} else if (parent.collection === "Items") {
+		detail = {
+			template: "itemDialog",
+			data:     {itemId: parent.id},
+		};
+	} else if (parent.collection === "Spells") {
+		detail = {
+			template: "spellDialog",
+			data:     {spellId: parent.id},
+		};
+	}
+	detail.heroId = heroId;
+	detail.charId = charId;
+	GlobalUI.setDetail(detail);
+};

rpg-docs/client/globalHelpers/round.js

@@ -1,6 +1,6 @@
-Template.registerHelper("round", function(value, decimalPlaces){
+Template.registerHelper("round", function(value, decimalPlaces) {
 	decimalPlaces = +decimalPlaces || 2;
 	var num = +value;
-	var tens = Math.pow(10, decimalPlaces)
+	var tens = Math.pow(10, decimalPlaces);
 	return Math.round(num * tens) / tens;
-});
+});

rpg-docs/client/globalHelpers/session.js

@@ -1,3 +1,3 @@
-Template.registerHelper("session", function(key){
+Template.registerHelper("session", function(key) {
 	return Session.get(key);
-});
+});

rpg-docs/client/globalHelpers/signedString.js

@@ -1,3 +1,3 @@
-Template.registerHelper("signedString", function(number){
+Template.registerHelper("signedString", function(number) {
-	return number > 0? "+" + number : "" + number;
+	return number >= 0 ? "+" + number : "" + number;
-});
+});

rpg-docs/client/globalHelpers/valueString.js

@@ -1,24 +1,63 @@
-Template.registerHelper("valueString", function(value){
+Template.registerHelper("valueString", function(value) {
+	var intValue = Math.round(value * 100);
+	var cp = intValue % 10;
+	intValue -= cp;
+	cp = Math.round(cp);
+	sp = intValue % 100;
+	intValue -= sp;
+	sp = Math.round(sp / 10)
+	gp = Math.floor(value);
+
 	var resultArray = [];
-	//sp
+	if (gp > 0) {
-	var gp = Math.floor(value);
+		resultArray.push(gp + "gp");
-	if(gp > 0) resultArray.push(gp + "gp");
+	}
-	//sp
+	if (sp > 0) {
-	var sp = Math.floor(10 * (value % 1));
+		resultArray.push(sp + "sp");
-	if(sp > 0) resultArray.push(sp + "sp");
+	}
-	//cp
+	if (cp > 0) {
-	var cp = 10 * ((value * 10) % 1);
+		resultArray.push(cp + "cp");
-	cp = Math.round(cp * 1000) / 1000;
+	}
-	if(cp > 0) resultArray.push(cp + "cp");
 
 	//build string with correct spacing
 	var result = "";
-	for(var i = 0; i < resultArray.length; i++){
+	for (var i = 0, l = resultArray.length; i < l; i++) {
 		//add a space between values
-		if(i !== 0){
+		if (i !== 0) {
 			result += " ";
 		}
 		result += resultArray[i];
 	}
-	return result;	
+	return result;
-});
+});
+
+Template.registerHelper("longValueString", function(value) {
+	var resultArray = [];
+	//sp
+	var gp = Math.floor(value);
+	if (gp > 0) {
+		resultArray.push(gp + "gp");
+	}
+	//sp
+	var sp = Math.floor(10 * (value % 1));
+	if (sp > 0 || resultArray.length) {
+		resultArray.push(sp + "sp");
+	}
+	//cp
+	var cp = 10 * ((value * 10) % 1);
+	cp = Math.round(cp * 1000) / 1000;
+	if (cp > 0 || resultArray.length) {
+		resultArray.push(cp + "cp");
+	}
+
+	//build string with correct spacing
+	var result = "";
+	for (var i = 0; i < resultArray.length; i++) {
+		//add a space between values
+		if (i !== 0) {
+			result += " ";
+		}
+		result += resultArray[i];
+	}
+	return result;
+});

rpg-docs/client/style/cards.scss

@@ -0,0 +1,96 @@
+@import "bourbon/bourbon";
+
+$thickColumnWidth: 304px;
+$thinColumnWidth: 240px;
+
+//Column layouts of cards
+.column-container {
+	@include column-fill(balance);
+	@include column-gap(8px);
+	@include column-width($thickColumnWidth);
+	padding: 8px;
+
+	&.thin-columns {
+		@include column-count(4);
+		@include column-width($thinColumnWidth);
+	}
+}
+
+//Cards
+.card {
+	background: white;
+	border-radius: 2px;
+
+	.column-container & {
+		margin-bottom: 8px;
+		width: 100%;
+		//hack to stop flickering
+		-webkit-backface-visibility: hidden;
+		-webkit-transform: translateX(0);
+		//stop breaking over column divide
+		-webkit-column-break-inside: avoid;
+		page-break-inside: avoid;
+		break-inside: avoid;
+		//Fixes extra margin at top of columns
+		display: inline-block;
+	}
+
+	.top {
+		cursor: pointer;
+		padding: 16px;
+		border-radius: 2px 2px 0 0;
+		&.white {
+			cursor: auto;
+			padding: 16px;
+			border-bottom: rgba(0,0,0,0.12) solid 1px;
+		}
+		paper-checkbox::shadow #ink[checked] {
+			color: #ffffff;
+		}
+		paper-checkbox::shadow #ink {
+			color: #ffffff;
+		}
+		paper-checkbox::shadow #checkbox.checked {
+			background-color: #ffffff;
+			background-color: rgba(255,255,255,0.27);
+			border-color: #ffffff;
+			border-color: rgba(255,255,255,0.27);
+		}
+		paper-checkbox::shadow #checkbox {
+			border-color: #ffffff;
+			border-color: rgba(255,255,255,0.54);
+		}
+	}
+	.bottom {
+		padding: 16px;
+		border-radius: 0 0 2px 2px;
+		&.list {
+			padding: 0 0 16px 0;
+			.subhead {
+				color: rgba(0,0,0,0.54);
+				font-size: 14px;
+				font-weight: 500;
+				letter-spacing: 0.010em;
+				padding: 12px 16px 12px 16px;
+			}
+		}
+		&.text {
+			white-space: pre-wrap;
+		}
+	}
+	.left {
+		padding: 16px;
+		border-radius: 2px 0 0 2px;
+		text-align: center;
+		min-width: 72px;
+	}
+	.right {
+		padding: 16px;
+		border-radius: 0 2px 2px 0;
+	}
+}
+
+/* undo pointer cursor on detail box heading */
+#globalDetail.card .top {
+	cursor: auto;
+}

rpg-docs/client/style/colors.scss

@@ -70,8 +70,8 @@
 	background-color: #9E9E9E;
 }
 
-.blue-grey {
+.app-grey {
-	background-color: #607D8B;
+	background-color: #424242;
 }
 
 .white {

rpg-docs/client/style/listItem.scss

@@ -0,0 +1,37 @@
+/*
+List items
+*/
+.item-slot {
+	background-color: rgb(232, 232, 232);
+	background-color: rgba(0, 0, 0, 0.1);	
+}
+
+.item {
+	background: white;
+	cursor: pointer;
+	font-size: 16px;
+	height: 40px;
+	margin: 1px 0 1px 0;
+	padding: 0 16px 0 16px;
+	position: relative;
+	transition: box-shadow 0.3s ease, opacity 0.5s ease-in-out;
+	&.small {
+		height: 32px;
+	}
+	&.tall {
+		height: 56px;
+	}
+	&.flexible {
+		height: auto;
+		padding-top: 16px;
+		padding-bottom: 16px;
+	}
+	&[hero], &:active{
+		box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.37);
+		z-index: 10;
+	}
+	core-icon, paper-icon-button {
+		color: #747474;
+		color: rgba(0,0,0,0.54);
+	}
+}

rpg-docs/client/style/main.scss

@@ -0,0 +1,89 @@
+@import "bourbon/bourbon";
+@import "colors";
+
+//apply a natural box layout model to all elements
+*, *:before, *:after {
+	-moz-box-sizing: border-box;
+	-webkit-box-sizing: border-box;
+	box-sizing: border-box;
+}
+
+root {
+	display: block;
+}
+
+body {
+	font-family: 'Roboto', 'Helvetica Neue', Helvetica, Arial;
+	margin: 0;
+	overflow-x: hidden;
+	background-color: #E0E0E0;
+}
+
+//fix tabs and core-toolbar having box shadow
+core-toolbar {
+	box-shadow: none;
+}
+
+//give drawer panel a shadow always
+core-header-panel[drawer] {
+	box-shadow: 2px 0px 5px 0px rgba(0,0,0,0.2);
+}
+
+//Paragraphs
+p {
+	margin-bottom: 8px;
+}
+
+//Horizontal rule
+hr {
+	background-color: #444;
+	opacity: 0.12;
+	border-width: 0;
+	color: #444;
+	height: 1px;
+	line-height: 0;
+	margin: 16px 0;
+	text-align: center;
+}
+
+//FABs
+.floatyButton {
+	position: absolute;
+	bottom: 24px;
+	right: 24px;
+}
+
+//Buttons
+paper-button {
+	color: #000;
+	color: rgba(0,0,0,0.87);
+	font-size: 14px;
+	font-weight: 400;
+	letter-spacing: 0.010;
+	text-transform: uppercase;
+}
+
+//Style shortcuts
+.scroll-y {
+	overflow-y: auto;
+}
+
+.clickable, core-item, paper-tab {
+	cursor: pointer;
+}
+
+.pre-wrap, .prewrap{
+	white-space: pre-wrap;
+}
+
+.padded {
+	padding: 8px;
+}
+
+.fullwidth {
+	width: 100%;
+}
+
+.fab-buffer {
+    height: 100px;
+}

rpg-docs/client/style/shadowDom.css

@@ -0,0 +1,20 @@
+.card .left paper-icon-button {
+	display: block;
+	height: 32px;
+	padding: 0;
+	width: 32px;
+}
+
+.card .left paper-icon-button[disabled] {
+	color: rgba(255, 255, 255, 0.2);
+}
+
+.card .left paper-icon-button /deep/ core-icon {
+	height: 32px;
+	width: 32px;
+}
+
+/*fix paper-dropdowns*/
+body /deep/ core-menu {
+	overflow-x: hidden !important;
+}

rpg-docs/client/style/tables.scss

@@ -0,0 +1,21 @@
+td {
+	padding: 8px;
+}
+
+.strengthTable{
+	width: 100%;
+	td{
+		&:nth-child(2) {
+			text-align: right;
+		}
+		&:nth-child(3) {
+			width: 250px;
+		}
+	}
+}
+
+.summaryTable  {
+	&:nth-child(3){
+		text-align: right;
+	}
+}

rpg-docs/client/views/GeneralCSS/general.css

@@ -1,222 +0,0 @@
-root {
-	display: block;
-}
-
-body {
-	font-family: 'Roboto', 'Helvetica Neue', Helvetica, Arial;
-	margin: 0;
-	overflow-x: hidden;
-}
-
-body.core-narrow {
-	padding: 8px;
-}
-
-body /deep/ core-menu {
-	overflow-x: hidden !important;
-}
-
-.calculatedValue {
-	color: #021C33;
-	font-weight: bold;
-}
-
-* {
-	box-sizing: border-box;
-}
-
-td {
-	padding: 0;
-}
-
-table {
-	border-spacing: 0;
-}
-
-hr {
-	background-color: #444;
-	opacity: 0.12;
-	border-width: 0;
-	color: #444;
-	height: 1px;
-	line-height: 0;
-	margin: 0 -16px;
-	text-align: center;
-}
-
-paper-button {
-	font-size: 14px;
-	font-weight: 400;
-	text-transform: uppercase;
-	color: #000;
-	color: rgba(0,0,0,0.87);
-	letter-spacing: 0.010;
-}
-
-.listRow {
-	height: 32px;
-}
-
-.card {
-	margin-bottom: 8px;
-	/*hack to stop flickering*/
-	-webkit-backface-visibility: hidden;
-	-webkit-transform: translateX(0);
-	/*stop divs breaking over divide*/
-	-webkit-column-break-inside: avoid;
-	page-break-inside: avoid;
-	break-inside: avoid;
-	/*Fixes extra margin at top of columns*/
-	display: inline-block;
-
-	width: 100%;
-
-	font-size: 14px;
-	border-radius: 2px;
-	background-color: white;
-}
-
-.card.double {
-	padding: 0;
-}
-
-.card paper-button {
-	font-size: 14px;
-	letter-spacing: 0.01em;
-}
-
-.cardHeader {
-	height: 48px;
-	padding: 0 16px 0 16px;
-	align-content: center;
-	font-size: 14px;
-	font-weight: 400;
-	color: rgba(0, 0, 0, 0.54);
-}
-
-.statCard, .clickable {
-	cursor: pointer;
-}
-
-.resourceCards {
-	padding: 4px 4px 0 4px;
-	margin-bottom: -4px;
-}
-
-.resourceCards .card {
-	width: 180px;
-	margin: 4px;
-	flex-grow: 1;
-	flex-shrink: 1;
-}
-
-.grey-background, body {
-	background-color: #E0E0E0;
-}
-
-.center {
-	text-align: center;
-}
-
-.screen-center {
-	position: fixed;
-	top: 50%;
-	left: 50%;
-	-webkit-transform: translate(-50%, -50%);
-	transform: translate(-50%, -50%);
-}
-
-.scroll-y {
-	overflow-y: auto;
-}
-
-.fab-buffer {
-	height: 88px;
-	width: 100%;
-	order: 999;
-}
-
-*[hidden] {
-	visibility: hidden;
-}
-
-.hidden{
-	opacity: 0;
-}
-
-@media (max-width: 640px) {
-	html /deep/ paper-action-dialog[global-dialog] {
-		top: 0 !important;
-		left: 0 !important;
-		width: 100%;
-		height: 100%;
-		margin: 0;
-		border-radius: 0;
-	}
-}
-
-.floatyButton {
-	position: absolute;
-	bottom: 24px;
-	right: 24px;
-}
-
-paper-fab-menu /deep/ .container {
-	padding: 24px !important;
-}
-
-paper-slider {
-	margin-left: -8px;
-}
-
-.list-subhead {
-	color: rgba(0,0,0,0.54);
-	font-size: 14px;
-	height: 40px;
-	padding-left: 16px;
-	font-weight: 500;
-}
-
-.whiteTop {
-	border-bottom: rgba(0,0,0,0.12) solid 1px;
-	background: white;
-	padding: 16px;
-	position: relative;
-	border-radius: 2px 2px 0 0;
-}
-
-.whiteTop paper-icon-button {
-	margin: -8px;
-}
-
-.fullwidth {
-	width: 100%;
-}
-
-.padded {
-	padding: 16px;
-}
-
-.listPadded {
-	padding: 0 0 16px 0; 
-}
-
-.rightPadded {
-	padding-right: 16px;
-}
-
-.bottomPadded {
-	padding-bottom: 16px;
-}
-
-.s {
-	padding: 0 0 16px 0;
-}
-
-.leftRound{
-	border-radius: 2px 0 0 2px;
-}
-
-.preline {
-	white-space: pre-line;
-}

rpg-docs/client/views/GeneralCSS/typography.css

@@ -18,7 +18,7 @@
 	letter-spacing: 0;
 }
 
-.white-text .display1{
+.white-text .display1, .white-text.display1{
 	color: rgba(255,255,255,0.54);
 }
 
@@ -109,6 +109,5 @@ html /deep/ .white-text{
 
 .white54 {
 	color: #eee;
-	color: rgba(255,255,255,0.54)
+	color: rgba(255,255,255,0.54);
-	
 }

rpg-docs/client/views/character/attacks/attackEdit/attackEdit.html

@@ -3,36 +3,26 @@
 		<div layout vertical flex>
 			<div layout horizontal>
 				<!--attackBonus-->
-				<paper-input id="attackBonusInput" 
+				<paper-input class="attackBonusInput" 
 							 label="Attack Bonus"
 							 floatinglabel
 							 value={{attackBonus}}
 							 flex></paper-input>
 				<!--details-->
-				<paper-input id="detailInput"
+				<paper-input class="detailInput"
 							 label="Details"
 							 floatinglabel
 							 value={{details}}></paper-input>
 			</div>
 			<div layout horizontal>
-				<!--DamageType-->
-				<paper-dropdown-menu id="damageDiceDropdown" label="Damage Dice">
-					<paper-dropdown layered class="dropdown">
-						<core-menu class="menu"  selected={{damageDice}}>
-							{{#each DAMAGE_DICE}}
-								<paper-item name={{this}} class="containerMenuItem">{{this}}</paper-item>
-							{{/each}}
-						</core-menu>
-					</paper-dropdown>
-				</paper-dropdown-menu>
 				<!--damageBonus-->
-				<paper-input id="damageInput"
+				<paper-input class="damageInput"
-							 label="Damage Bonus"
+							 label="Damage"
 							 floatinglabel
-							 value={{damageBonus}}
+							 value={{damage}}
 							 flex></paper-input>
 				<!--DamageType-->
-				<paper-dropdown-menu id="damageTypeDropdown" label="Damage Type">
+				<paper-dropdown-menu class="damageTypeDropdown" label="Damage Type">
 					<paper-dropdown layered class="dropdown">
 						<core-menu class="menu"  selected={{damageType}}>
 							{{#each damageTypes}}
@@ -44,6 +34,6 @@
 			</div>
 		</div>
 		<!--Delete Button-->
-		<paper-icon-button id="deleteAttack" role="button" tabindex="0" icon="delete" aria-label="Delete"></paper-icon-button>
+		<paper-icon-button class="deleteAttack" role="button" tabindex="0" icon="delete" aria-label="Delete"></paper-icon-button>
 	</div>
 </template>

rpg-docs/client/views/character/attacks/attackEdit/attackEdit.js

@@ -1,44 +1,50 @@
-var damageTypes = ["bludgeoning", "piercing", "slashing", "acid", "cold", "fire", "force", "lightning", "necrotic", 
+var damageTypes = [
-				  "poison", "psychic", "radiant", "thunder"];
+	"bludgeoning",
+	"piercing",
+	"slashing",
+	"acid",
+	"cold",
+	"fire",
+	"force",
+	"lightning",
+	"necrotic",
+	"poison",
+	"psychic",
+	"radiant",
+	"thunder",
+];
 
 Template.attackEdit.events({
-	"tap #deleteAttack": function(event, instance){
+	"tap .deleteAttack": function(event, instance) {
 		Attacks.softRemoveNode(this._id);
 		GlobalUI.deletedToast(this._id, "Attacks", "Attack");
 	},
-	"change #attackBonusInput": function(event){
+	"change .attackBonusInput": function(event) {
 		var value = event.currentTarget.value;
 		Attacks.update(this._id, {$set: {attackBonus: value}});
 	},
-	"change #damageInput": function(event){
+	"change .damageInput": function(event) {
 		var value = event.currentTarget.value;
-		Attacks.update(this._id, {$set: {damageBonus: value}});
+		Attacks.update(this._id, {$set: {damage: value}});
 	},
-	"change #detailInput": function(event){
+	"change .detailInput": function(event) {
 		var value = event.currentTarget.value;
 		Attacks.update(this._id, {$set: {details: value}});
 	},
-	"core-select #damageTypeDropdown": function(event){
+	"core-select .damageTypeDropdown": function(event) {
 		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
+		if (!detail.isSelected) return;
 		var value = detail.item.getAttribute("name");
-		if(value == this.damageType) return;
+		if (value == this.damageType) return;
 		Attacks.update(this._id, {$set: {damageType: value}});
 	},
-	"core-select #damageDiceDropdown": function(event){
-		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
-		var value = detail.item.getAttribute("name");
-		if(value == this.damageDice) return;
-		Attacks.update(this._id, {$set: {damageDice: value}});
-	}
 });
 
 Template.attackEdit.helpers({
-	damageTypes: function(){
+	damageTypes: function() {
 		return damageTypes;
 	},
-	DAMAGE_DICE: function(){
+	DAMAGE_DICE: function() {
 		return DAMAGE_DICE;
-	}
+	},
-});
+});

rpg-docs/client/views/character/attacks/attackEditList/attackEditList.html

@@ -1,4 +1,4 @@
-<!--needs to be given charId, parentId and type-->
+<!--needs to be given charId, parentId and parentCollection-->
 <template name="attackEditList">
 	{{#if attacks.count}}
 		<hr style="margin: 16px 0 16px 0;">

rpg-docs/client/views/character/attacks/attackEditList/attackEditList.js

@@ -1,19 +1,18 @@
 Template.attackEditList.helpers({
-	attacks: function(){
+	attacks: function() {
-		var cursor = Attacks.find({"parent.id": this.parentId, type: this.type, charId: this.charId});
+		var cursor = Attacks.find({"parent.id": this.parentId, charId: this.charId});
 		return cursor;
 	}
 });
 
 Template.attackEditList.events({
-	"tap #addAttackButton": function(){
+	"tap #addAttackButton": function() {
 		Attacks.insert({
 			charId: this.charId,
 			parent: {
 				id: this.parentId,
 				collection: this.parentCollection
-			},
+			}
-			type: this.type,
 		});
 	},
 });

rpg-docs/client/views/character/attacks/attackView/attackView.html

@@ -0,0 +1,17 @@
+<template name="attackView">
+	<div class="attackView" layout horizontal>
+		<div class="headline" style="margin-right: 16px;" layout horizontal center>
+			{{evaluateSigned charId attackBonus}}
+		</div>
+		<div layout vertical>
+			<div>
+				{{evaluateString charId damage}}&nbsp;{{damageType}}
+			</div>
+			{{#if details}}
+			<div class="caption">
+				{{details}}
+			</div>
+			{{/if}}
+		</div>
+	</div>
+</template>

rpg-docs/client/views/character/attacks/attacksViewList/attacksViewList.html

@@ -0,0 +1,11 @@
+<template name="attacksViewList">
+	{{#if attacks.count}}
+		<hr style="margin: 16px 0 16px 0;">
+		<div class="attacks">
+			<h2 class="spaceAfter">Attacks</h2>
+			{{#each attacks}}
+				{{> attackView}}
+			{{/each}}
+		</div>
+	{{/if}}
+</template>

rpg-docs/client/views/character/attacks/attacksViewList/attacksViewList.js

@@ -0,0 +1,5 @@
+Template.attacksViewList.helpers({
+	attacks: function() {
+		return Attacks.find({"parent.id": this.parentId, charId: this.charId});
+	}
+});

rpg-docs/client/views/character/buffs/buffDialog/buffDialog.html

@@ -0,0 +1,15 @@
+<template name="buffDialog">
+	{{#with buff}}
+		{{#baseDialog title=name class=colorClass hideEdit=true}}
+			{{> buffDetails}}
+		{{/baseDialog}}
+	{{/with}}
+</template>
+
+<template name="buffDetails">
+	{{#if description}}
+		<div class="pre-wrap">{{evaluateString charId description}}</div>
+	{{/if}}
+
+	{{> effectsViewList charId=charId parentId=_id}}
+</template>

rpg-docs/client/views/character/buffs/buffDialog/buffDialog.js

@@ -0,0 +1,5 @@
+Template.buffDialog.helpers({
+	buff: function(){
+		return Buffs.findOne(this.buffId);
+	},
+});

rpg-docs/client/views/character/characterSettings/characterSettings.html

@@ -1,3 +1,27 @@
 <template name="characterSettings">
-
+	{{#with character}}
+	<div style="height: 100px;">
+		<table style="width: 100%;">
+			<tr>
+				<td>Hide Spells tab</td>
+				<td>
+					<paper-toggle-button id="hideSpellcasting"
+										 checked={{settings.hideSpellcasting}}
+										 touch-action="pan-y">
+					</paper-toggle-button>
+				</td>
+			</tr>
+			<tr>
+				<td>Use variant encumbrance</td>
+				<td>
+					<paper-toggle-button id="variantEncumbrance"
+										 checked={{settings.useVariantEncumbrance}}
+										 touch-action="pan-y">
+					</paper-toggle-button>
+				</td>
+			</tr>
+		</table>
+	</div>
+	{{/with}}
+	<paper-button id="doneButton" affirmative> Done </paper-button>
 </template>

rpg-docs/client/views/character/characterSettings/characterSettings.js

@@ -1,3 +1,26 @@
-Template.characterSettings.events({
+Template.characterSettings.helpers({
-	
+	character: function() {
+		return Characters.findOne(this._id, {fields: {settings: 1}});
+	}
+});
+
+Template.characterSettings.events({
+	"change #variantEncumbrance": function(event, instance){
+		var value = instance.find("#variantEncumbrance").checked;
+		if (this.settings.useVariantEncumbrance !== value){
+			Characters.update(
+				this._id,
+				{$set: {"settings.useVariantEncumbrance": value}}
+			);
+		}
+	},
+	"change #hideSpellcasting": function(event, instance){
+		var value = instance.find("#hideSpellcasting").checked;
+		if (this.settings.hideSpellcasting !== value){
+			Characters.update(
+				this._id,
+				{$set: {"settings.hideSpellcasting": value}}
+			);
+		}
+	},
 });

rpg-docs/client/views/character/characterSettings/deleteCharacterConfirmation.js

@@ -1,23 +1,25 @@
-Template.deleteCharacterConfirmation.onCreated(function(){
+Template.deleteCharacterConfirmation.onCreated(function() {
 	this.canDelete = new ReactiveVar(false);
 });
 
 Template.deleteCharacterConfirmation.helpers({
-	cantDelete: function(){
+	cantDelete: function() {
 		return !Template.instance().canDelete.get();
 	},
-	getStyle: function(){
+	getStyle: function() {
-		if(Template.instance().canDelete.get()) return "background: #d23f31; color: white;";
+		if (Template.instance().canDelete.get()) {
+			return "background: #d23f31; color: white;";
+		}
 	}
 });
 
 Template.deleteCharacterConfirmation.events({
-	"change #nameInput, input #nameInput": function(event, instance){
+	"change #nameInput, input #nameInput": function(event, instance) {
 		var canDel = instance.find("#nameInput").value === this.name;
 		instance.canDelete.set(canDel);
 	},
-	"tap #deleteButton": function(event, instance){
+	"tap #deleteButton": function(event, instance) {
-		if(instance.find("#nameInput").value === this.name){
+		if (instance.find("#nameInput").value === this.name) {
 			GlobalUI.closeDialog();
 			Router.go("/");
 			Characters.remove(this._id);

rpg-docs/client/views/character/characterSettings/shareDialog.html

@@ -1,26 +1,54 @@
 <template name="shareDialog">
-	<div>
+	<div style="width: 360px;">
-		<div>
+		<div layout horizontal center>
-			<div class="subhead">
+			<div>Who can view this character: </div>
-				Can View
+			<paper-dropdown-menu class="visibilityDropdown"
-			</div>
+								 label="Visibility">
-			{{#each readers}}
+				<paper-dropdown layered class="dropdown">
-				{{this}}<br>
+					<core-menu class="menu visibilityMenu" selected={{viewPermission}}>
-			{{/each}}
+						<paper-item name="whitelist">Only people I share with</paper-item>
-			<div class="subhead">
+						<paper-item name="public">Anyone with link</paper-item>
-				Can Edit
+					</core-menu>
-			</div>
+				</paper-dropdown>
-			{{#each writers}}
+			</paper-dropdown-menu>
-				{{this}}<br>
-			{{/each}}
 		</div>
-		<paper-input id="userNameOrEmailInput" label="Username or email" floatinglabel></paper-input><br>
+		<div>
-		{{#if userFindError}}<p style="color: red;">{{userFindError}}</p>{{/if}}
+			{{#if readers.count}}
+				<div style="font-weight: 500;">
+					Can View
+				</div>
+				{{#each readers}}
+					<div layout horizontal center>
+						<div flex>{{getUserName}}</div>
+						<paper-icon-button class="deleteShare" icon="delete"></paper-icon-button>
+					</div>
+				{{/each}}
+			{{/if}}
+			{{#if writers.count}}
+				<div style="font-weight: 500;">
+					Can Edit
+				</div>
+				{{#each writers}}
+					<div layout horizontal center>
+						<div flex>{{username}}</div>
+						<paper-icon-button class="deleteShare" icon="delete"></paper-icon-button>
+					</div>
+				{{/each}}
+			{{/if}}
+		</div>
+		<div layout horizontal center>
+			<paper-input flex id="userNameOrEmailInput" label="Username or email" floatinglabel></paper-input>
+			<paper-button id="shareButton"
+						  class="red-button"
+						  style="width: 80px; height: 37px; margin-top: 16px;"
+						  raised
+						  disabled={{shareButtonDisabled}}>Share</paper-button>
+		</div>
+		<p style="color: red;">{{userFindError}}</p>
 		<paper-radio-group id="accessLevelMenu" selected="read">
 			<paper-radio-button name="read" label="View Only"></paper-radio-button>
 			<paper-radio-button name="write" label="Can Edit"></paper-radio-button>
 		</paper-radio-group>
-		<br>
-		<paper-button id="shareButton" class="red-button" raised disabled={{shareButtonDisabled}}>Share</paper-button>
 	</div>
+	<paper-button id="doneButton" affirmative> Done </paper-button>
 </template>

rpg-docs/client/views/character/characterSettings/shareDialog.js

@@ -3,13 +3,17 @@ Template.shareDialog.onCreated(function(){
 });
 
 Template.shareDialog.helpers({
+	viewPermission: function() {
+		var char = Characters.findOne(this._id, {fields: {settings: 1}});
+		return char.settings.viewPermission || "whitelist";
+	},
 	readers: function(){
 		var char = Characters.findOne(this._id, {fields: {readers: 1}});
-		return char && char.readers;
+		return Meteor.users.find({_id: {$in: char.readers}});
 	},
 	writers: function(){
 		var char = Characters.findOne(this._id, {fields: {writers: 1}});
-		return char && char.writers;
+		return Meteor.users.find({_id: {$in: char.writers}});
 	},
 	shareButtonDisabled: function(){
 		return !Template.instance().userId.get();
@@ -18,17 +22,29 @@ Template.shareDialog.helpers({
 		if (!Template.instance().userId.get()){
 			return "User not found";
 		}
+	},
+	getUserName: function() {
+		return this.username || "user: " + this._id;
 	}
 });
 
 Template.shareDialog.events({
-	"input #userNameOrEmailInput, change #userNameOrEmailInput": function(event, instance){
+	"core-select .visibilityDropdown": function(event){
+		var detail = event.originalEvent.detail;
+		if (!detail.isSelected) return;
+		var value = detail.item.getAttribute("name");
+		var char = Characters.findOne(this._id, {fields: {settings: 1}});
+		if (value == char.settings.viewPermission) return;
+		Characters.update(this._id, {$set: {"settings.viewPermission": value}});
+	},
+	"input #userNameOrEmailInput":
+	function(event, instance){
 		var userName = instance.find("#userNameOrEmailInput").value;
 		instance.userId.set(undefined);
-		Meteor.call("getUserId", userName, function (err, result) {
+		Meteor.call("getUserId", userName, function(err, result) {
-			if(err){
+			if (err){
 				console.error(err);
-			} else{
+			} else {
 				console.log(result);
 				instance.userId.set(result);
 			}
@@ -37,19 +53,24 @@ Template.shareDialog.events({
 	"tap #shareButton": function(event, instance){
 		var self = this;
 		var permission = instance.find("#accessLevelMenu").selected;
-		if(!permission) throw "no permission set";
+		if (!permission) throw "no permission set";
 		var userId = instance.userId.get();
-		if(!userId) return;
+		if (!userId) return;
-		if(permission === "write"){
+		if (permission === "write"){
 			Characters.update(self._id, {
 				$addToSet: {writers: userId},
-				$pull: {readers: userId}
+				$pull: {readers: userId},
 			});
 		} else {
 			Characters.update(self._id, {
 				$addToSet: {readers: userId},
-				$pull: {writers: userId}
+				$pull: {writers: userId},
 			});
 		}
-	}
+	},
+	"tap .deleteShare": function(event, instance) {
+		Characters.update(instance.data._id, {
+			$pull: {writers: this._id, readers: this._id}
+		});
+	},
 });

rpg-docs/client/views/character/characterSheet.css

@@ -1,5 +1,4 @@
 paper-tabs, core-toolbar {
-	background-color: #795548;
 	box-shadow: 0px 3px 2px rgba(0, 0, 0, 0.2);
 }
 
@@ -21,18 +20,9 @@ paper-tabs ::shadow #ink {
 
 paper-tabs.transparent-brown {
 	background-color: transparent;
-	color: #795548;
 	box-shadow: none;
 }
 
-paper-tabs.transparent-brown::shadow #selectionBar {
-	background-color: #795548;
-}
-
-paper-tabs.transparent-brown paper-tab::shadow #ink {
-	color: #795548;
-}
-
 core-toolbar.medium-tall {
 	height: 108px;
 }

rpg-docs/client/views/character/characterSheet.html

@@ -5,24 +5,35 @@
 		<div flex>
 			{{name}}
 		</div>
-		<div>
+		{{#if canEditCharacter _id}}
-			{{> colorDropdown}}
+			<div>
-		</div>
+				{{> colorDropdown}}
-		<paper-menu-button>
+			</div>
-			<paper-icon-button icon="menu" noink></paper-icon-button>
+			<paper-menu-button>
-			<paper-dropdown class="dropdown" halign="right">
+				<paper-icon-button icon="more-vert" noink></paper-icon-button>
-				<core-menu class="menu" style="color: black; color: rgba(0,0,0,0.87);">
+				<paper-dropdown class="dropdown" halign="right">
-					<paper-item id="deleteCharacter"><core-icon icon="delete"></core-icon>Delete</paper-item>
+					<core-menu class="menu" style="color: black; color: rgba(0,0,0,0.87);">
-					<paper-item id="shareCharacter"><core-icon icon="social:share"></core-icon>Share</paper-item>
+						<paper-item id="deleteCharacter">
-				</core-menu>
+							<core-icon icon="delete"></core-icon>Delete
-			</paper-dropdown>
+						</paper-item>
-		</paper-menu-button>
+						<paper-item id="shareCharacter">
+							<core-icon icon="social:share"></core-icon>Share
+						</paper-item>
+						<paper-item id="characterSettings">
+							<core-icon icon="settings"></core-icon>Settings
+						</paper-item>
+					</core-menu>
+				</paper-dropdown>
+			</paper-menu-button>
+		{{/if}}
 		<div class="bottom fit" horizontal layout>
 			<paper-tabs flex horizontal center layout id="characterSheetTabs" selected={{selectedTab}} class="{{colorClass}}">
 				<paper-tab name="stats">Stats</paper-tab>
 				<paper-tab name="features">Features</paper-tab>
 				<paper-tab name="inventory">Inventory</paper-tab>
+				{{#unless hideSpellcasting}}
 				<paper-tab name="spells">Spells</paper-tab>
+				{{/unless}}
 				<paper-tab name="persona">Persona</paper-tab>
 				<paper-tab name="journal">Journal</paper-tab>
 			</paper-tabs>
@@ -33,7 +44,9 @@
 			<section flex name="stats">{{> stats}}</section>
 			<section flex name="features">{{> features}}</section>
 			<section flex name="inventory">{{> inventory}}</section>
+			{{#unless hideSpellcasting}}
 			<section flex name="spells">{{> spells}}</section>
+			{{/unless}}
 			<section flex name="persona">{{> persona}}</section>
 			<section flex name="journal">{{> journal}}</section>
 		</core-animated-pages>

rpg-docs/client/views/character/characterSheet.js

@@ -1,6 +1,9 @@
-Template.characterSheet.created = function(){
+Template.characterSheet.onCreated(function() {
+	//default to the first tab
 	Session.setDefault(this.data._id + ".selectedTab", "stats");
-};
+	//watch this character and make sure their encumbrance is updated
+	trackEncumbranceConditions(this.data._id, this);
+});
 
 var setTab = function(charId, tab){
 	return Session.set(charId + ".selectedTab", tab);
@@ -13,7 +16,11 @@ var getTab = function(charId){
 Template.characterSheet.helpers({
 	selectedTab: function(){
 		return getTab(this._id);
-	}
+	},
+	hideSpellcasting: function() {
+		var char = Characters.findOne(this._id);
+		return char && char.settings.hideSpellcasting;
+	},
 });
 
 Template.characterSheet.events({
@@ -40,4 +47,11 @@ Template.characterSheet.events({
 			template: "shareDialog",
 		});
 	},
+	"tap #characterSettings": function(event, instance){
+		GlobalUI.showDialog({
+			heading: this.name + " Settings",
+			data: this,
+			template: "characterSettings",
+		});
+	},
 });

rpg-docs/client/views/character/effects/effectEdit/effectEdit.css

@@ -1,21 +1,13 @@
-body /deep/ #statGroupDropDown {
+html /deep/ .operationDropDown {
-	width: 120px;
+	width: 152px;
 }
 
-body /deep/ #statDropDown {
+html /deep/ .statDropDown {
-	width: 120px;
+	width: 152px;
 }
 
-body /deep/ #operationDropDown {
+html /deep/ .damageMultiplierDropDown {
-	width: 100px;
+	width: 152px;
-}
-
-body /deep/ #damageMultiplierDropDown {
-	width: 120px;
-}
-
-body /deep/ #proficiencyDropDown {
-	width: 120px;
 }
 
 html /deep/ .effectEdit paper-input {
@@ -24,6 +16,7 @@ html /deep/ .effectEdit paper-input {
 }
 
 html /deep/ .effectEdit {
+	height: 64px;
 	display: flex;
 	align-items: flex-end;
 }

rpg-docs/client/views/character/effects/effectEdit/effectEdit.html

@@ -1,27 +1,23 @@
 <template name="effectEdit">
 	<div class="effectEdit" layout horizontal center>
-		<paper-dropdown-menu class="statGroupDropDown" label="Stat Group" flex>
+		<paper-dropdown-menu class="statDropDown"
-			<paper-dropdown layered class="dropdown">
+							 label="Stat">
-				<core-menu class="menu statGroupMenu" selected={{selectedStatGroup}}>
+			<paper-dropdown layered
-					{{#each statGroups}}
+							class="dropdown">
-						<paper-item class="statGroupSelect" name={{this}}>{{this}}</paper-item>
+					<core-menu class="menu statMenu" selected={{stat}}>
-					{{/each}}
+						{{#each statGroups}}
-				</core-menu>
+							<div style="font-weight: bold;
-			</paper-dropdown>
+										margin-top: 16px;">{{this}}</div>
-		</paper-dropdown-menu>
+							{{#each stats}}
-		{{#if stats}}
+								<paper-item name={{stat}}>{{name}}</paper-item>
-			<paper-dropdown-menu class="statDropDown" label="Stat" flex>
+							{{/each}}
-				<paper-dropdown layered class="dropdown">
-					<core-menu class="menu statMenu"  selected={{stat}} on-tap="onStatMenuTap">
-						{{#each stats}}
-							<paper-item name={{stat}}>{{name}}</paper-item>
 						{{/each}}
 					</core-menu>
-				</paper-dropdown>
+			</paper-dropdown>
-			</paper-dropdown-menu>
+		</paper-dropdown-menu>
-		{{/if}}
 		{{#if operations}}
-			<paper-dropdown-menu class="operationDropDown" label="Operation" flex>
+			<paper-dropdown-menu class="operationDropDown"
+								 label="Operation">
 				<paper-dropdown layered class="dropdown">
 					<core-menu class="menu operationMenu" selected={{operation}}>
 						{{#each operations}}
@@ -31,36 +27,39 @@
 				</paper-dropdown>
 			</paper-dropdown-menu>
 		{{/if}}
-		{{> Template.dynamic template=effectValueTemplate}}
+		{{#if effectValueTemplate}}
-		<paper-icon-button class="deleteEffect" role="button" tabindex="0" icon="delete" aria-label="Delete"></paper-icon-button>
+			{{> Template.dynamic template=effectValueTemplate}}
+		{{else}}
+			<div flex></div>
+		{{/if}}
+		<paper-icon-button class="deleteEffect"
+						   icon="delete">
+		</paper-icon-button>
 		<br>
 	</div>
 </template>
 
 <template name="regularEffectValue">
-	<paper-input class="effectValueInput" label="Value" floatinglabel value={{effectValue}} flex></paper-input>
+	<paper-input class="effectValueInput" 
+				 label="Value" 
+				 floatinglabel 
+				 value={{effectValue}} 
+				 flex>
+	</paper-input>
 </template>
 
 <template name="multiplierEffectValue">
-	<paper-dropdown-menu class="damageMultiplierDropDown" label="Damage Multiplier" flex>
+	<paper-dropdown-menu class="damageMultiplierDropDown"
-		<paper-dropdown layered class="dropdown">
+						 label="Damage Multiplier">
-			<core-menu class="menu multiplierMenu" selected={{value}}>
+		<paper-dropdown layered
+						class="dropdown">
+			<core-menu class="menu multiplierMenu"
+					   selected={{value}}>
 				<paper-item name="0.5">Resistance</paper-item>
 				<paper-item name="2">Vulnerability</paper-item>
 				<paper-item name="0">Immunity</paper-item>
 			</core-menu>
 		</paper-dropdown>
 	</paper-dropdown-menu>
+	<div flex></div>
 </template>
-
-<template name="proficiencyEffectValue">
-	<paper-dropdown-menu class="proficiencyDropDown" label="Proficiency" flex>
-		<paper-dropdown layered class="dropdown">
-			<core-menu class="menu proficiencyMenu" selected={{value}}>
-				<paper-item name="1">Proficient</paper-item>
-				<paper-item name="0.5">Half Prof. Bonus</paper-item>
-				<paper-item name="2">Double Prof. Bonus</paper-item>
-			</core-menu>
-		</paper-dropdown>
-	</paper-dropdown-menu>
-</template>

rpg-docs/client/views/character/effects/effectEdit/effectEdit.js

@@ -82,7 +82,6 @@ var attributeOperations = [
 	{name: "Max", operation: "max"}
 ];
 var skillOperations = [
-	{name: "Proficiency", operation: "proficiency"},
 	{name: "Add", operation: "add"},
 	{name: "Multiply", operation: "mul"},
 	{name: "Min", operation: "min"},
@@ -94,26 +93,19 @@ var skillOperations = [
 	{name: "Conditional Benefit", operation: "conditional"}
 ];
 
-Template.effectEdit.created = function(){
-	var statGroup = statsDict[this.data.stat] && statsDict[this.data.stat].group;
-	this.selectedStatGroup = new ReactiveVar(statGroup);
-};
-
 Template.effectEdit.helpers({
-	selectedStatGroup: function(){
-		return Template.instance().selectedStatGroup.get();
-	},
 	statGroups: function(){
 		return statGroupNames;
 	},
 	stats: function(){
-		var group = Template.instance().selectedStatGroup.get();
+		var group = this;
 		return statGroups[group];
 	},
 	operations: function(){
-		var group = Template.instance().selectedStatGroup.get();
+		var stat = statsDict[this.stat];
-		if(group === "Weakness/Resistance") return null;
+		var group = stat && stat.group;
-		if(group === "Saving Throws" || group === "Skills"){
+		if (group === "Weakness/Resistance") return null;
+		if (group === "Saving Throws" || group === "Skills"){
 			return skillOperations;
 		} else {
 			return attributeOperations;
@@ -121,15 +113,14 @@ Template.effectEdit.helpers({
 	},
 	effectValueTemplate: function(){
 		//resistance/vulnerability template
-		var group = Template.instance().selectedStatGroup.get();
+		var stat = statsDict[this.stat];
-		if(group === "Weakness/Resistance") return "multiplierEffectValue";
+		var group = stat && stat.group;
+		if (group === "Weakness/Resistance") return "multiplierEffectValue";
 
 		var op = this.operation;
-		if(!op) return null;
+		if (!op) return null;
 		//operations that don't need templates
-		if(op === "advantage" || op === "disadvantage" || op === "fail") return null;
+		if (op === "advantage" || op === "disadvantage" || op === "fail") return null;
-		//proficiency template
-		if(op === "proficiency") return "proficiencyEffectValue";
 
 		//default template
 		return "regularEffectValue";
@@ -147,54 +138,35 @@ Template.effectEdit.events({
 		Effects.softRemoveNode(this._id);
 		GlobalUI.deletedToast(this._id, "Effects", "Effect");
 	},
-	"core-select .statGroupDropDown": function(event, instance){
-		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
-		var groupName = detail.item.getAttribute("name");
-		var oldName = Template.instance().selectedStatGroup.get();
-		if(oldName != groupName){
-			instance.selectedStatGroup.set(groupName);
-			if(groupName === "Skills" || groupName === "Saving Throws"){
-				Effects.update(this._id, {$set: {operation: "proficiency", value: 1, calculation: ""}, $unset: {stat: ""} });
-			} else if(groupName === "Weakness/Resistance"){
-				Effects.update(this._id, {$set: {value: 0.5, calculation: "", operation: "mul"}, $unset: {stat: ""} });
-			} else {
-				Effects.update(this._id, { $set: {operation: "add"}, $unset: {stat: "", value: "", calculation: ""} });
-			}
-		}
-	},
 	"core-select .statDropDown": function(event){
 		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
+		if (!detail.isSelected) return;
 		var statName = detail.item.getAttribute("name");
 		if (statName == this.stat) return;
 		Effects.update(this._id, {$set: {stat: statName}});
 	},
 	"core-select .operationDropDown": function(event){
 		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
+		if (!detail.isSelected) return;
 		var opName = detail.item.getAttribute("name");
 		if (opName == this.operation) return;
 		Effects.update(this._id, {$set: {operation: opName}});
 	},
 	"core-select .damageMultiplierDropDown": function(event){
 		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
+		if (!detail.isSelected) return;
 		var value = +detail.item.getAttribute("name");
 		if (value == this.value) return;
-		Effects.update(this._id, {$set: {value: value, calculation: "", operation: "mul"}});
+		Effects.update(this._id, {$set: {
-	},
+			value: value,
-	"core-select .proficiencyDropDown": function(event){
+			calculation: "",
-		var detail = event.originalEvent.detail;
+			operation: "mul"
-		if(!detail.isSelected) return;
+		}});
-		var value = +detail.item.getAttribute("name");
-		if (value == this.value) return;
-		Effects.update(this._id, {$set: {value: value, calculation: ""}});
 	},
 	"change .effectValueInput": function(event){
 		var value = event.currentTarget.value;
 		var numValue = +value;
-		if(_.isFinite(numValue)){
+		if (_.isFinite(numValue)){
 			if (this.value === numValue) return;
 			Effects.update(this._id, {$set: {value: numValue, calculation: ""}});
 		} else if (_.isString(value)){

rpg-docs/client/views/character/effects/effectView/effectView.html

@@ -1,12 +1,6 @@
 <template name="effectView">
-	<div class="effectView" layout horizontal center>
+	<tr>
-		{{#with statName}}
+		<td>{{statName}}</td>
-			<div flex>{{statName}}</div>
+		<td>{{operationName}}{{statValue}}</td>
-		{{else}}
+	</tr>
-			<div flex>{{sourceName}}</div>
-		{{/with}}
-		<div>{{operationName}}</div>
-		<div>{{statValue}}</div>
-		<br>
-	</div>
 </template>

rpg-docs/client/views/character/effects/effectView/effectView.js

@@ -6,35 +6,35 @@ var stats = {
 	"intelligence":{"name":"Intelligence"},
 	"wisdom":{"name":"Wisdom"},
 	"charisma":{"name":"Charisma"},
-	"strengthSave":{"name":"Strength Save",},
+	"strengthSave":{"name":"Strength Save"},
-	"dexteritySave":{"name":"Dexterity Save",},
+	"dexteritySave":{"name":"Dexterity Save"},
-	"constitutionSave":{"name":"Constitution Save",},
+	"constitutionSave":{"name":"Constitution Save"},
-	"intelligenceSave":{"name":"Intelligence Save",},
+	"intelligenceSave":{"name":"Intelligence Save"},
-	"wisdomSave":{"name":"Wisdom Save",},
+	"wisdomSave":{"name":"Wisdom Save"},
-	"charismaSave":{"name":"Charisma Save",},
+	"charismaSave":{"name":"Charisma Save"},
-	"acrobatics":{"name":"Acrobatics",},
+	"acrobatics":{"name":"Acrobatics"},
-	"animalHandling":{"name":"Animal Handling",},
+	"animalHandling":{"name":"Animal Handling"},
-	"arcana":{"name":"Arcana",},
+	"arcana":{"name":"Arcana"},
-	"athletics":{"name":"Athletics",},
+	"athletics":{"name":"Athletics"},
-	"deception":{"name":"Deception",},
+	"deception":{"name":"Deception"},
-	"history":{"name":"History",},
+	"history":{"name":"History"},
-	"insight":{"name":"Insight",},
+	"insight":{"name":"Insight"},
-	"intimidation":{"name":"Intimidation",},
+	"intimidation":{"name":"Intimidation"},
-	"investigation":{"name":"Investigation",},
+	"investigation":{"name":"Investigation"},
-	"medicine":{"name":"Medicine",},
+	"medicine":{"name":"Medicine"},
-	"nature":{"name":"Nature",},
+	"nature":{"name":"Nature"},
-	"perception":{"name":"Perception",},
+	"perception":{"name":"Perception"},
-	"performance":{"name":"Performance",},
+	"performance":{"name":"Performance"},
-	"persuasion":{"name":"Persuasion",},
+	"persuasion":{"name":"Persuasion"},
-	"religion":{"name":"Religion",},
+	"religion":{"name":"Religion"},
-	"sleightOfHand":{"name":"Sleight of Hand",},
+	"sleightOfHand":{"name":"Sleight of Hand"},
-	"stealth":{"name":"Stealth",},
+	"stealth":{"name":"Stealth"},
-	"survival":{"name":"Survival",},
+	"survival":{"name":"Survival"},
-	"initiative":{"name":"Initiative",},
+	"initiative":{"name":"Initiative"},
 	"hitPoints":{"name":"Hit Points"},
 	"armor":{"name":"Armor"},
-	"dexterityArmor":{"name":"Dexterity Armor Bonus"}
+	"dexterityArmor":{"name":"Dexterity Armor Bonus"},
-	,"speed":{"name":"Speed"},
+	"speed":{"name":"Speed"},
 	"proficiencyBonus":{"name":"Proficiency Bonus"},
 	"ki":{"name":"Ki Points"},
 	"sorceryPoints":{"name":"Sorcery Points"},
@@ -55,40 +55,63 @@ var stats = {
 	"d8HitDice":{"name":"d8 Hit Dice"},
 	"d10HitDice":{"name":"d10 Hit Dice"},
 	"d12HitDice":{"name":"d12 Hit Dice"},
-	"acidMultiplier":{"name":"Acid", "group": "Weakness/Resistance"},
+	"acidMultiplier":{"name":"Acid damage", "group": "Weakness/Resistance"},
-	"bludgeoningMultiplier":{"name":"Bludgeoning", "group": "Weakness/Resistance"},
+	"bludgeoningMultiplier":{
-	"coldMultiplier":{"name":"Cold", "group": "Weakness/Resistance"},
+		"name":"Bludgeoning damage", "group": "Weakness/Resistance",
-	"fireMultiplier":{"name":"Fire", "group": "Weakness/Resistance"},
+	},
-	"forceMultiplier":{"name":"Force", "group": "Weakness/Resistance"},
+	"coldMultiplier":{
-	"lightningMultiplier":{"name":"Lightning", "group": "Weakness/Resistance"},
+		"name":"Cold damage", "group": "Weakness/Resistance",
-	"necroticMultiplier":{"name":"Necrotic", "group": "Weakness/Resistance"},
+	},
-	"piercingMultiplier":{"name":"Piercing", "group": "Weakness/Resistance"},
+	"fireMultiplier":{
-	"poisonMultiplier":{"name":"Poison", "group": "Weakness/Resistance"},
+		"name":"Fire damage", "group": "Weakness/Resistance",
-	"psychicMultiplier":{"name":"Psychic", "group": "Weakness/Resistance"},
+	},
-	"radiantMultiplier":{"name":"Radiant", "group": "Weakness/Resistance"},
+	"forceMultiplier":{
-	"slashingMultiplier":{"name":"Slashing", "group": "Weakness/Resistance"},
+		"name":"Force damage", "group": "Weakness/Resistance",
-	"thunderMultiplier":{"name":"Thunder", "group": "Weakness/Resistance"}
+	},
+	"lightningMultiplier":{
+		"name":"Lightning damage", "group": "Weakness/Resistance",
+	},
+	"necroticMultiplier":{
+		"name":"Necrotic damage", "group": "Weakness/Resistance",
+	},
+	"piercingMultiplier":{
+		"name":"Piercing damage", "group": "Weakness/Resistance",
+	},
+	"poisonMultiplier":{
+		"name":"Poison damage", "group": "Weakness/Resistance",
+	},
+	"psychicMultiplier":{
+		"name":"Psychic damage", "group": "Weakness/Resistance",
+	},
+	"radiantMultiplier":{
+		"name":"Radiant damage", "group": "Weakness/Resistance",
+	},
+	"slashingMultiplier":{
+		"name":"Slashing damage", "group": "Weakness/Resistance",
+	},
+	"thunderMultiplier":{
+		"name":"Thunder damage", "group": "Weakness/Resistance",
+	},
 };
 
 var operations = {
-	base: {name: "Base Value"}, 
+	base: {name: "Base Value: "},
 	proficiency: {name: "Proficiency"},
-	add: {name: "Add"},
+	add: {name: "+"},
-	mul: {name: "Multiply"},
+	mul: {name: "x"},
-	min: {name: "Min"},
+	min: {name: "Min: "},
-	max: {name: "Max"},
+	max: {name: "Max: "},
 	advantage: {name: "Advantage"},
 	disadvantage: {name: "Disadvantage"},
-	passiveAdd: {name: "Passive Bonus"},
+	passiveAdd: {name: "Passive Bonus: "},
 	fail: {name: "Automatically Fail"},
-	conditional: {name: "Conditional Benefit"}
 };
 
 Template.effectView.helpers({
 	sourceName: function(){
 		var id = this.parent.id;
-		if(!id) return;
+		if (!id) return;
-		switch(this.parent.collection){
+		switch (this.parent.collection){
 			case "Features":
 				return "Feature - " + Features.findOne(id, {fields: {name: 1}}).name;
 			case "Classes":
@@ -100,34 +123,46 @@ Template.effectView.helpers({
 			case "Characters":
 				return Characters.findOne(this.charId, {fields: {race: 1}}).race;
 			default:
-				return "Inate"
+				return "Inate";
 		}
 	},
 	statName: function(){
-		return stats[this.stat] && stats[this.stat].name || "No Stat"
+		return stats[this.stat] && stats[this.stat].name || "No Stat";
 	},
 	operationName: function(){
-		if(this.operation === "proficiency") return null;
+		if (this.operation === "proficiency" ||
-		if(stats[this.stat].group === "Weakness/Resistance") return null;
+		   this.operation === "conditional") return null;
-		return operations[this.operation] && operations[this.operation].name || "No Operation"
+		if (stats[this.stat] && stats[this.stat].group === "Weakness/Resistance")
+			return null;
+		if (this.operation === "add" && evaluateEffect(this.charId, this) < 0)
+			return null;
+		return operations[this.operation] &&
+			operations[this.operation].name || "No Operation";
 	},
 	statValue: function(){
-		if(this.operation === "advantage" ||
+		if (this.operation === "advantage" ||
 		   this.operation === "disadvantage" ||
-		   this.operation === "fail" ||
+		   this.operation === "fail"){
-		   this.operation === "conditional"){
 			return null;
 		}
-		if(this.operation === "proficiency"){
+		if (this.operation === "proficiency"){
-			if(this.value == 0.5 || this.calculation == 0.5) return "Half Proficiency";
+			if (this.value == 0.5 || this.calculation == 0.5)
-			if(this.value == 1   || this.calculation == 1)   return "Proficiency";
+				return "Half Proficiency";
-			if(this.value == 2   || this.calculation == 2)   return "Double Proficiency";
+			if (this.value == 1   || this.calculation == 1)
+				return "Proficiency";
+			if (this.value == 2   || this.calculation == 2)
+				return "Double Proficiency";
 		}
-		if(stats[this.stat].group === "Weakness/Resistance"){
+		if (this.operation === "conditional"){
-			if(this.value == 0.5 || this.calculation == 0.5) return "Resistance";
+			return this.calculation || this.value;
-			if(this.value == 2   || this.calculation == 2)   return "Vulnerability";
-			if(this.value == 0   || this.calculation == 0)   return "Immunity";
 		}
+		if (stats[this.stat] && stats[this.stat].group === "Weakness/Resistance"){
+			if (this.value === 0.5) return "Resistance";
+			if (this.value === 2)   return "Vulnerability";
+			if (this.value === 0)   return "Immunity";
+		}
+		var value = evaluateEffect(this.charId, this);
+		if (_.isNumber(value)) return value;
 		return this.calculation || this.value;
-	}
+	},
 });

rpg-docs/client/views/character/effects/effectsEditList/effectsEditList.html

@@ -1,7 +1,7 @@
-<!--needs to be given charId, parentId, parentCollection and type-->
+<!--needs to be given charId, parentId and parentCollection-->
 <template name="effectsEditList">
 	{{#if effects.count}}
-		<hr style="margin: 16px 0 16px 0;">
+		<hr class="vertMargin">
 		<div id="effects">
 			<h2>Effects</h2>
 			{{#each effects}}

rpg-docs/client/views/character/effects/effectsEditList/effectsEditList.js

@@ -1,13 +1,21 @@
 Template.effectsEditList.helpers({
 	effects: function(){
-		var cursor = Effects.find({"parent.id": this.parentId, "parent.collection": this.parentCollection, type: this.type});
+		var selector = {
+			"parent.id": this.parentId,
+			"parent.collection": this.parentCollection,
+			"charId": this.charId,
+		};
+		if (this.parentGroup){
+			selector["parent.group"] = this.parentGroup;
+		}
+		var cursor = Effects.find(selector);
 		return cursor;
 	}
 });
 
 Template.effectsEditList.events({
 	"tap #addEffectButton": function(){
-		if ( !_.isBoolean(this.enabled) ) {
+		if (!_.isBoolean(this.enabled)) {
 			this.enabled = true;
 		}
 		Effects.insert({
@@ -15,11 +23,11 @@ Template.effectsEditList.events({
 			charId: this.charId,
 			parent: {
 				id: this.parentId,
-				collection: this.parentCollection
+				collection: this.parentCollection,
+				group: this.parentGroup,
 			},
 			operation: "add",
-			type: this.type,
+			enabled: this.enabled,
-			enabled: this.enabled
 		});
 	},
-});
+});

rpg-docs/client/views/character/effects/effectsViewList/effectsViewList.html

@@ -1,12 +1,14 @@
 <!--needs to be given charId, (parentId or stat) and type-->
 <template name="effectsViewList">
-	{{#if effects}}
+	{{#if effects.count}}
 		<hr style="margin: 16px 0 16px 0;">
-		<div id="effects">
+		<div class="effects">
-			<h2>Effects</h2>
+			<h2 class="spaceAfter">Effects</h2>
-			{{#each effects}}
+			<table class="wideTable">
-				{{>effectView}}
+				{{#each effects}}
-			{{/each}}
+					{{>effectView}}
+				{{/each}}
+			</table>
 		</div>
 	{{/if}}
 </template>

rpg-docs/client/views/character/effects/effectsViewList/effectsViewList.js

@@ -1,10 +1,12 @@
 Template.effectsViewList.helpers({
 	effects: function(){
-		if(this.parentId){
+		var selector = {
-			return Effects.find({"parent.id": this.parentId, type: this.type, charId: this.charId}, {fields: {parent: 0}});
+			"parent.id": this.parentId,
-		} else if(this.stat){
+			"charId": this.charId
-			return Effects.find({charId: this.charId, stat: this.stat});
+		};
+		if (this.parentGroup){
+			selector["parent.group"] = this.parentGroup;
 		}
-
+		return Effects.find(selector, {fields: {parent: 0}});
 	}
 });

rpg-docs/client/views/character/features/featureDialog/featureDialog.html

@@ -1,40 +1,85 @@
 <template name="featureDialog">
 	{{#with feature}}
-		{{#baseDialog title=name class=colorClass}}
+		{{#baseDialog title=name class=colorClass startEditing=../startEditing}}
-			<!--name-->
+			{{> featureDetails}}
-			<paper-input id="featureNameInput" label="Name" floatinglabel value={{name}}></paper-input>
+		{{else}}
-			<hr style="margin: 16px 0 16px 0;">
+			{{> featureEdit}}
-			<!--description-->
-			<paper-input-decorator label="Description" floatinglabel layout vertical>
-				<paper-autogrow-textarea>
-					<textarea id="featureDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
-				</paper-autogrow-textarea>
-			</paper-input-decorator>
-			<hr style="margin: 16px 0 16px 0;">
-			<div layout horizontal center style="height: 60px;">
-				<div class="caption">Limit Uses</div>
-				<paper-toggle-button id="limitUseCheck"
-									 checked={{usesSet}} 
-									 role="button" 
-									 aria-pressed="false" 
-									 tabindex="0" 
-									 touch-action="pan-y"
-									 style="margin-left: 8px; margin-right:8px;">
-				</paper-toggle-button>
-				{{#if usesSet}}
-				<paper-input id="usesInput" label="Uses" floatinglabel value={{uses}}></paper-input>
-				{{/if}}
-				<paper-dropdown-menu id="enabledDropdown" label="Enable Feature">
-					<paper-dropdown layered class="dropdown">
-						<core-menu id="enabledMenu" class="menu"  selected={{enabled}} on-tap="onStatMenuTap">
-							<paper-item name="alwaysEnabled"> Always Enabled </paper-item>
-							<paper-item name="enabled">       Enabled        </paper-item>
-							<paper-item name="disabled">      Disabled       </paper-item>
-						</core-menu>
-					</paper-dropdown>
-				</paper-dropdown-menu>
-			</div>
-			{{> effectsEditList parentId=_id parentCollection="Features" charId=charId type="feature" name=name enabled=isEnabled}}
 		{{/baseDialog}}
 	{{/with}}
-</template>
+</template>
+
+<template name="featureDetails">
+	{{#if or canEnable hasUses}}
+		<div layout horizontal center justified wrap>
+			{{#if canEnable}}
+				<div>enabled:</div>
+				<paper-checkbox class="sideMargin" checked={{enabled}}></paper-checkbox>
+			{{/if}}
+			{{#if hasUses}}
+				<div class="subhead" style="margin-right: 16px">
+					Uses: {{usesLeft}}/{{usesValue}}
+				</div>
+			{{/if}}
+			{{#if hasUses}}
+				<div layout horizontal>
+					<paper-button class="useFeature" disabled={{noUsesLeft}}>Use</paper-button>
+					<paper-button class="resetFeature" disabled={{usesFull}}>Reset</paper-button>
+				</div>
+			{{/if}}
+		</div>
+
+		<hr class="vertMargin">
+	{{/if}}
+
+	{{#if description}}
+		<div>{{#markdown}}{{evaluateString charId description}}{{/markdown}}</div>
+	{{/if}}
+
+	{{> effectsViewList charId=charId parentId=_id}}
+	{{> proficiencyViewList charId=charId parentId=_id}}
+</template>
+
+<template name="featureEdit">
+	<!--name-->
+	<paper-input id="featureNameInput" class="fullwidth" label="Name" floatinglabel value={{name}}></paper-input>
+
+	<hr class="vertMargin">
+
+	<div layout horizontal center style="height: 60px;">
+		<paper-dropdown-menu id="enabledDropdown" label="Enable Feature">
+			<paper-dropdown layered class="dropdown">
+				<core-menu id="enabledMenu" class="menu"  selected={{enabledSelection}} on-tap="onStatMenuTap">
+					<paper-item name="alwaysEnabled"> Always Enabled </paper-item>
+					<paper-item name="enabled">       Enabled        </paper-item>
+					<paper-item name="disabled">      Disabled       </paper-item>
+				</core-menu>
+			</paper-dropdown>
+		</paper-dropdown-menu>
+		<div layout horizontal center class="sideMargin">
+			<div>Limit Uses: </div>
+			<paper-toggle-button id="limitUseCheck"
+								 class="sideMargin"
+								 checked={{usesSet}}
+								 role="button" 
+								 aria-pressed="false"
+								 tabindex="0"
+								 touch-action="pan-y">
+			</paper-toggle-button>
+		</div>
+		{{#if usesSet}}
+			<paper-input flex id="usesInput" label="Uses" floatinglabel value={{uses}}></paper-input>
+		{{/if}}
+	</div>
+
+	<hr class="vertMargin">
+
+	<!--description-->
+	<paper-input-decorator label="Description" floatinglabel layout vertical>
+		<paper-autogrow-textarea>
+			<textarea id="featureDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
+		</paper-autogrow-textarea>
+	</paper-input-decorator>
+
+	{{> effectsEditList parentId=_id parentCollection="Features" charId=charId name=name enabled=enabled}}
+	{{> proficiencyEditList parentId=_id parentCollection="Features" charId=charId enabled=enabled}}
+</template>

rpg-docs/client/views/character/features/featureDialog/featureDialog.js

@@ -1,3 +1,9 @@
+Template.featureDialog.helpers({
+	feature: function(){
+		return Features.findOne(this.featureId);
+	},
+});
+
 Template.featureDialog.events({
 	"color-change": function(event, instance){
 		Features.update(instance.data.featureId, {$set: {color: event.color}});
@@ -7,6 +13,61 @@ Template.featureDialog.events({
 		GlobalUI.deletedToast(instance.data.featureId, "Features", "Feature");
 		GlobalUI.closeDetail();
 	},
+});
+
+Template.featureDetails.helpers({
+	or: function(a, b){
+		return a || b;
+	},
+	hasUses: function(){
+		return this.usesValue() > 0;
+	},
+	noUsesLeft: function(){
+		return this.usesLeft() <= 0;
+	},
+	usesFull: function(){
+		return this.usesLeft() >= this.usesValue();
+	},
+});
+
+Template.featureDetails.events({
+	"tap .useFeature": function(event){
+		var featureId = this._id;
+		Features.update(featureId, {$inc: {used: 1}});
+	},
+	"tap .resetFeature": function(event){
+		var featureId = this._id;
+		Features.update(featureId, {$set: {used: 0}});
+	},
+
+	"change .enabledCheckbox": function(event){
+		var enabled = !this.enabled;
+		Features.update(this._id, {$set: {enabled: enabled}});
+	},
+});
+
+Template.featureEdit.onRendered(function(){
+	updatePolymerInputs(this);
+});
+
+Template.featureEdit.helpers({
+	usesSet: function(){
+		return _.isString(this.uses);
+	},
+	enabledSelection: function(){
+		if (this.enabled){
+			if (this.alwaysEnabled){
+				return "alwaysEnabled";
+			} else {
+				return "enabled";
+			}
+		} else if (this.enabled === false){ //make sure it is false, not just falsey
+			return "disabled";
+		}
+	},
+});
+
+Template.featureEdit.events({
 	"change #featureNameInput": function(event){
 		var name = Template.instance().find("#featureNameInput").value;
 		Features.update(this._id, {$set: {name: name}});
@@ -18,7 +79,7 @@ Template.featureDialog.events({
 	"change #limitUseCheck": function(event){
 		var currentUses = this.uses;
 		var featureId = this._id;
-		if( event.target.checked && !_.isString(currentUses) ){
+		if (event.target.checked && !_.isString(currentUses)){
 			Features.update(featureId, {$set: {uses: ""}}, {removeEmptyStrings: false});
 		} else if (!event.target.checked && _.isString(currentUses)){
 			Features.update(featureId, {$unset: {uses: ""}});
@@ -31,29 +92,18 @@ Template.featureDialog.events({
 	},
 	"core-select #enabledDropdown": function(event){
 		var detail = event.originalEvent.detail;
-		if(!detail.isSelected) return;
+		if (!detail.isSelected) return;
 		var value = detail.item.getAttribute("name");
 		var setter;
-		if(value === "enabled"){
+		if (value === "enabled"){
 			setter = {enabled: true, alwaysEnabled: false};
 		} else if (value === "disabled"){
 			setter = {enabled: false, alwaysEnabled: false};
-		} else{
+		} else {
 			setter = {enabled: true, alwaysEnabled: true};
 		}
-		if (setter.enabled === this.enabled && setter.alwaysEnabled === this.alwaysEnabled) return;
+		if (setter.enabled === this.enabled &&
+			setter.alwaysEnabled === this.alwaysEnabled) return;
 		Features.update(this._id, {$set: setter});
 	},
 });
-
-Template.featureDialog.helpers({
-	feature: function(){
-		return Features.findOne(this.featureId);
-	},
-	usesSet: function(){
-		return _.isString(this.uses);
-	},
-	isEnabled: function(){
-		return this.enabled !== "disabled";
-	}
-});

rpg-docs/client/views/character/features/features.html

@@ -1,7 +1,7 @@
 <template name="features">
 	<div fit>
 		<div class="scroll-y" fit>
-			<div class="containers">
+			<div class="column-container">
 				<!--expertiseDice-->
 				{{>resource name="expertiseDice" title="Expertise Dice" color="teal" char=this}}
 				<!--ki-->
@@ -14,27 +14,27 @@
 				{{>resource name="superiorityDice" title="Superiority Dice" color="teal" char=this}}
 				
 				<!--Attacks-->
-				<paper-shadow class="card container"  hero-id="main" {{detailHero}}>
+				<paper-shadow class="card">
-					<div class="whiteTop" hero-id="toolbar" layout horizontal center {{detailHero}}>
+					<div class="top white">
-						<div flex>
+						Attacks
-							<div class="containerName subhead">Attacks</div>
-						</div>
-						<!--<paper-icon-button class="black54" id="addAttackButton" icon="add"></paper-icon-button>-->
 					</div>
-					<div class="containerMain listPadded">
+					<div class="bottom list">
 						{{#each attacks}}
-							<div class="itemSlot">
+							<div class="item-slot">
-								<paper-item class="white attack" hero-id="main" {{detailHero}}>
+								<div class="flexible attack item"
-									<div layout horizontal class="fullwidth">
+											hero-id="main" {{detailHero}}>
-										<div class="headline rightPadded" layout horizontal center>
+									<div layout horizontal>
+										<div class="headline"
+											 style="margin-right: 16px;"
+											 layout horizontal center>
 											{{evaluateSigned ../_id attackBonus}}
 										</div>
-										<div layout vertical flex>
+										<div flex layout vertical>
 											<div class="body2">
 												{{name}}
 											</div>
 											<div>
-												{{damageDice}}&nbsp;{{{evaluateSignedSpaced ../_id damageBonus}}}&nbsp;{{damageType}}
+												{{evaluateString ../_id damage}}&nbsp;{{damageType}}
 											</div>
 											{{#if details}}
 												<div class="caption">
@@ -43,43 +43,79 @@
 											{{/if}}
 										</div>
 									</div>
-								</paper-item>
+								</div>
 							</div>
 						{{/each}}
 					</div>
 				</paper-shadow>
-				
+
 				<!--Proficiencies-->
-				<paper-shadow class="card container"  hero-id="main" {{detailHero "proficiencies"}}>
+				<paper-shadow class="card">
-					<div id="proficiencies" 
+					<div class="white top">
-						 class="whiteTop" 
+						Proficiencies
-						 hero-id="toolbar" 
+					</div>
-						 layout horizontal center 
+					<div flex class="bottom list">
-						 {{detailHero "proficiencies"}}>
+						{{#if weaponProfs.count}}
-						<div class="containerName subhead">Proficiencies</div>
+							<div class="subhead">Weapons</div>
+						{{/if}}
+						{{#each weaponProfs}}
+							{{> proficiencyListItem}}
+						{{/each}}
+						{{#if armorProfs.count}}
+							<div class="subhead">Armor</div>
+						{{/if}}
+						{{#each armorProfs}}
+							{{> proficiencyListItem}}
+						{{/each}}
+						{{#if toolProfs.count}}
+							<div class="subhead">Tools</div>
+						{{/if}}
+						{{#each toolProfs}}
+							{{> proficiencyListItem}}
+						{{/each}}
 					</div>
-					<div flex class="containerMain padded preline">{{characterProficiencies}}</div>
 				</paper-shadow>
-				
+
 				<!--features-->
 				{{#each features}}
-					<paper-shadow class="card container featureCard"  hero-id="main" {{detailHero}}>
+					<paper-shadow class="card featureCard"
-						<div class="containerTop {{colorClass}}" hero-id="toolbar" layout horizontal center {{detailHero}}>
+								  hero-id="main" {{detailHero}}>
-							<paper-ripple fit></paper-ripple>
+						<div class="top {{colorClass}} subhead" 
-							<div class="containerName subhead" hero-id="title" flex {{detailHero}}>{{name}}</div>
+							 layout horizontal 
-							{{#if hasUses}}<div class="subhead" style="margin-right: 8px">{{usesLeft}}/{{usesValue}}</div>{{/if}}
+							 hero-id="toolbar" {{detailHero}}>
-							<paper-ripple fit></paper-ripple>
+							<div flex hero-id="title" {{detailHero}}>
+								{{name}}
+							</div>
+							{{#if hasUses}}
+								<div style="margin-right: 8px">
+									{{usesLeft}}/{{usesValue}}
+								</div>
+							{{/if}}
 							{{#if canEnable}}
-								<core-tooltip label="Feature enabled" position="left">
+								<core-tooltip label="Feature enabled"
-									<paper-checkbox class="enabledCheckbox" checked={{enabled}}></paper-checkbox>
+											  position="left">
+									<paper-checkbox class="enabledCheckbox" 
+													checked={{enabled}}
+													disabled={{#unless canEditCharacter charId}}true{{/unless}}>
+									</paper-checkbox>
 								</core-tooltip>
 							{{/if}}
 						</div>
-						{{#if description}}<div flex class="containerMain body1 featureDescription">{{description}}</div>{{/if}}
+						{{#if description}}
+							<div flex class="bottom">
+								{{#markdown}}{{evaluateString charId shortDescription}}{{/markdown}}
+							</div>
+						{{/if}}
 						{{#if hasUses}}
-							<div class="containerFoot" layout horizontal center end-justified>
+							<div layout horizontal center end-justified>
-								<paper-button class="useFeature" disabled={{noUsesLeft}}>Use</paper-button>
+								<paper-button class="useFeature" 
-								<paper-button class="resetFeature" disabled={{usesFull}}>Reset</paper-button>
+											  disabled={{noUsesLeft}}>
+									Use
+								</paper-button>
+								<paper-button class="resetFeature" 
+											  disabled={{usesFull}}>
+									Reset
+								</paper-button>
 							</div>
 						{{/if}}
 					</paper-shadow>
@@ -87,31 +123,43 @@
 			</div>
 			<div class="fab-buffer"></div>
 		</div>
-		<paper-fab id="addFeature" 
+		{{#if canEditCharacter _id}}
-				   class="floatyButton" 
+			<paper-fab id="addFeature" 
-				   icon="add" 
+					   class="floatyButton" 
-				   title="Add" 
+					   icon="add" 
-				   role="button" 
+					   title="Add" 
-				   tabindex="0" 
+					   role="button" 
-				   aria-label="Add" 
+					   tabindex="0" 
-				   hero-id="main"></paper-fab>
+					   aria-label="Add" 
+					   hero-id="main"></paper-fab>
+		{{/if}}
 	</div>
 </template>
 
 <template name="resource">
-	{{#if char.attributeBase name}}
+	{{#if characterCalculate "attributeBase" char._id name}}
-		<paper-shadow class="card container" hero-id="main" {{detailHero}} layout horizontal>
+		<paper-shadow class="card" 
-			<div class="containerLeft {{getColor}}">
+					  hero-id="main" {{detailHero name char._id}}
-				<div class="resourceValue">{{char.attributeValue name}}</div>
+					  layout horizontal>
-				<!--<div class="resourceMax">{{char.attributeBase name}}</div>-->
+			<div class="left {{getColor}} display1 white-text" 
-				<div class="resourceButtons">
+				 hero-id="toolbar" {{detailHero name char._id}}
-					<paper-icon-button class="resourceUp" icon="arrow-drop-up" disabled={{cantIncrement}}></paper-icon-button>
+				 layout horizontal center>
-					<paper-icon-button class="resourceDown" icon="arrow-drop-down" disabled={{cantDecrement}}></paper-icon-button>
+				<div style="margin-right: 8px;">
+					<paper-icon-button class="resourceUp" 
+									   icon="arrow-drop-up" 
+									   disabled={{cantIncrement}}>
+					</paper-icon-button>
+					<paper-icon-button class="resourceDown"
+									   icon="arrow-drop-down"
+									   disabled={{cantDecrement}}>
+					</paper-icon-button>
 				</div>
+				<div>{{characterCalculate "attributeValue" char._id name}}</div>
+				<!--<div>/{{char.attributeBase name}}</div>-->
 			</div>
-			<div class="containerRight" flex relative horizontal layout center>
+			<div class="right clickable" 
+				 flex layout horizontal center>
 				{{title}}
-				<paper-ripple fit></paper-ripple>
 			</div>
 		</paper-shadow>
 	{{/if}}

rpg-docs/client/views/character/features/features.js

@@ -3,73 +3,84 @@ Template.features.helpers({
 		var features = Features.find({charId: this._id}, {sort: {color: 1, name: 1}});
 		return features;
 	},
+	shortDescription: function() {
+		if (_.isString(this.description)){
+			return this.description.split(/^( *[-*_]){3,} *(?:\n+|$)/m)[0];
+		}
+	},
 	hasUses: function(){
 		return this.usesValue() > 0;
 	},
 	noUsesLeft: function(){
-		return this.usesLeft() <= 0;
+		return this.usesLeft() <= 0 || !canEditCharacter(this.charId);
 	},
 	usesFull: function(){
-		return this.usesLeft() >= this.usesValue();
+		return this.usesLeft() >= this.usesValue() || !canEditCharacter(this.charId);
 	},
 	colorClass: function(){
-		return getColorClass(this.color)
+		return getColorClass(this.color);
 	},
 	featureOrder: function(){
 		return _.indexOf(_.keys(colorOptions), this.color);
 	},
 	attacks: function(){
-		return Attacks.find({charId: this._id, enabled: true}, {sort: {color: 1, name: 1}});
+		return Attacks.find(
-	},
+			{charId: this._id, enabled: true},
-	characterProficiencies: function(){
+			{sort: {color: 1, name: 1}});
-		var char = Characters.findOne(this._id);
-		return char && char.proficiencies;
 	},
 	canEnable: function(){
 		return !this.alwaysEnabled;
-	}
+	},
+	weaponProfs: function(){
+		return Proficiencies.find({charId: this._id, type: "weapon"});
+	},
+	armorProfs: function(){
+		return Proficiencies.find({charId: this._id, type: "armor"});
+	},
+	toolProfs: function(){
+		return Proficiencies.find({charId: this._id, type: "tool"});
+	},
 });
 
 Template.features.events({
 	"tap #addFeature": function(event){
-		var featureId = Features.insert({name: "New Feature", charId: this._id});
+		var featureId = Features.insert({
+			name: "New Feature",
+			charId: this._id,
+			enabled: true,
+			alwaysEnabled: true,
+		});
 		GlobalUI.setDetail({
 			template: "featureDialog",
-			data:     {featureId: featureId, charId: this._id},
+			data:     {featureId: featureId, charId: this._id, startEditing: true},
-			heroId:   featureId
+			heroId:   featureId,
-		})
+		});
 	},
 	"tap #addAttackButton": function(event){
 		var charId = this._id;
 		Attacks.insert({
 			charId: charId
 		}, function(error, id){
-			if(!error){
+			if (!error){
 				GlobalUI.setDetail({
 					template: "attackDialog",
 					data:     {attackId: id, charId: charId},
-					heroId:   id
+					heroId:   id,
 				});
 			}
 		});
 	},
-	"tap .featureCard .containerTop": function(event){
+	"tap .featureCard .top": function(event){
 		var featureId = this._id;
 		var charId = Template.parentData()._id;
 		GlobalUI.setDetail({
 			template: "featureDialog",
 			data:     {featureId: featureId, charId: charId},
-			heroId:   featureId
+			heroId:   featureId,
 		});
 	},
 	"tap .attack": function(event){
-		var attackId = this._id;
+		openParentDialog(this.parent, this.charId, this._id);
-		var charId = Template.parentData()._id;
-		GlobalUI.setDetail({
-			template: "attackDialog",
-			data:     {attackId: attackId, charId: charId},
-			heroId:   attackId
-		});
 	},
 	"tap .useFeature": function(event){
 		var featureId = this._id;
@@ -79,52 +90,60 @@ Template.features.events({
 		var featureId = this._id;
 		Features.update(featureId, {$set: {used: 0}});
 	},
-	"tap #proficiencies": function(event){
-		var charId = this._id;
-		GlobalUI.setDetail({
-			template: "textDialog",
-			data:     {charId: charId, field: "proficiencies", title: "Proficiencies", color: "q"},
-			heroId:   this._id + "proficiencies"
-		});
-	},
 	"tap .enabledCheckbox": function(event){
 		event.stopPropagation();
 	},
 	"change .enabledCheckbox": function(event){
 		var enabled = !this.enabled;
 		Features.update(this._id, {$set: {enabled: enabled}});
-	}
+	},
 });
 
 Template.resource.helpers({
 	cantIncrement: function(){
-		return !(this.char.attributeValue(this.name) < this.char.attributeBase(this.name));
+		var value = Characters.calculate.attributeValue(this.char._id, this.name);
+		var base = Characters.calculate.attributeBase(this.char._id, this.name);
+		var baseBigger = value < base;
+		return !baseBigger || !canEditCharacter(this.char._id);
 	},
 	cantDecrement: function(){
-		return !(this.char.attributeValue(this.name) > 0);
+		var value = Characters.calculate.attributeValue(this.char._id, this.name);
+		var valuePositive = value > 0;
+		return !valuePositive || !canEditCharacter(this.char._id);
 	},
 	getColor: function(){
-		if(this.char.attributeValue(this.name) > 0){
+		var value = Characters.calculate.attributeValue(this.char._id, this.name);
+		if (value > 0){
 			return this.color;
 		} else {
 			return "grey";
 		}
-	}
+	},
 });
 
 Template.resource.events({
 	"tap .resourceUp": function(event){
-		if(this.char.attributeValue(this.name) < this.char.attributeBase(this.name)){
+		var value = Characters.calculate.attributeValue(this.char._id, this.name);
+		var base = Characters.calculate.attributeBase(this.char._id, this.name);
+		if (value < base){
 			var modifier = {$inc: {}};
 			modifier.$inc[this.name + ".adjustment"] = 1;
 			Characters.update(this.char._id, modifier, {validate: false});
 		}
 	},
 	"tap .resourceDown": function(event){
-		if(this.char.attributeValue(this.name) > 0){
+		var value = Characters.calculate.attributeValue(this.char._id, this.name);
+		if (value > 0){
 			var modifier = {$inc: {}};
 			modifier.$inc[this.name + ".adjustment"] = -1;
 			Characters.update(this.char._id, modifier, {validate: false});
 		}
-	}
+	},
+	"tap .right": function(event, instance) {
+		GlobalUI.setDetail({
+			template: "attributeDialog",
+			data:     {name: this.title, statName: this.name, charId: this.char._id},
+			heroId:   this.char._id + this.name,
+		});
+	},
 });

rpg-docs/client/views/character/inventory/carryCapacityBar/carryCapacityBar.html

@@ -0,0 +1,22 @@
+<template name="carryCapacityBar">
+	<div class="carryCapacityBar">
+		<div class="carriedWeightBar"
+			 style="width: {{carriedPercent}}%;
+					background-color: {{carriedColor}}">
+		</div>
+		<div class="tick"
+			 style="width: 33.333%;">
+		</div>
+		<div class="tick"
+			 style="width: 66.666%;">
+		</div>
+	</div>
+	{{#if overCarriedPercent}}
+	<div class="carryCapacityBar">
+		<div class="carriedWeightBar"
+			 style="width: {{overCarriedPercent}}%;
+					background-color: {{overCarriedColor}}">
+		</div>
+	</div>
+	{{/if}}
+</template>

rpg-docs/client/views/character/inventory/carryCapacityBar/carryCapacityBar.js

@@ -0,0 +1,65 @@
+var getFractionCarried = function(char) {
+	//find out the weight
+	var weight = 0;
+	Containers.find(
+		{charId: char._id, isCarried: true}
+	).forEach(function(container){
+		weight += container.totalWeight();
+	});
+	Items.find(
+		{charId: char._id, "parent.id": char._id},
+		{fields: {weight : 1, quantity: 1}}
+	).forEach(function(item){
+		weight += item.totalWeight();
+	});
+	//get strength
+	var strength = Characters.calculate.attributeValue(char._id, "strength");
+	var capacity = strength * 15;
+	return weight / capacity;
+};
+
+Template.carryCapacityBar.onCreated(function() {
+	var self = this;
+	self.carriedFraction = new ReactiveVar(0);
+	self.autorun(function() {
+		self.carriedFraction.set(getFractionCarried(self.data));
+	});
+});
+
+Template.carryCapacityBar.helpers({
+	carriedPercent: function() {
+		var percent = 100 * Template.instance().carriedFraction.get();
+		return percent > 100 ? 100 : percent;
+	},
+	overCarriedPercent: function() {
+		var percent = 100 * Template.instance().carriedFraction.get();
+		var overPercent = percent - 100;
+		if (overPercent < 0) return 0;
+		if (overPercent > 100) return 100;
+		return overPercent;
+	},
+	carriedColor: function() {
+		var frac = Template.instance().carriedFraction.get();
+		if (frac < 1 / 3){
+			return "#2196F3";
+		} else if (frac < 2 / 3){
+			return "#CDDC39";
+		} else if (frac < 1) {
+			return "#FFC107";
+		} else {
+			return "#F44336";
+		}
+	},
+	overCarriedColor: function() {
+		var frac = Template.instance().carriedFraction.get();
+		if (frac < 1 / 3){
+			return "#2196F3";
+		} else if (frac < 2 / 3){
+			return "#CDDC39";
+		} else if (frac < 1) {
+			return "#FFC107";
+		} else {
+			return "#F44336";
+		}
+	},
+});

rpg-docs/client/views/character/inventory/carryCapacityBar/carryCapacityBar.scss

@@ -0,0 +1,14 @@
+.carryCapacityBar {
+	background-color: #7DC580;
+	background-color: rgba(255,255,255,0.27);
+	position: relative;
+	height: 4px;
+	div{
+		height: 100%;
+		position: absolute;
+	}
+	.tick {
+		border-right: solid 2px #E5E5E5;
+		border-right-color: rgba(255,255,255,0.54);
+	}
+}

rpg-docs/client/views/character/inventory/carryDialog/carryDialog.html

@@ -0,0 +1,17 @@
+<template name="carryDialog">
+	{{#baseDialog title="Weight Carried" class=color hideEdit=true}}
+	<div layout horizontal center-justified end>
+		<div class="display2">
+			{{round carriedWeight 1}}
+		</div>
+		<div class="display1">
+			lbs
+		</div>
+	</div>
+
+	<hr class="vertMargin">
+	
+	{{> carryCapacityTable}}
+
+	{{/baseDialog}}
+</template>

rpg-docs/client/views/character/inventory/carryDialog/carryDialog.js

@@ -0,0 +1,20 @@
+Template.carryDialog.helpers({
+	carriedWeight: function() {
+		var weight = 0;
+		Containers.find(
+			{charId: this.charId, isCarried: true}
+		).forEach(function(container){
+			weight += container.totalWeight();
+		});
+		Items.find(
+			{charId: this.charId, "parent.id": this.charId},
+			{fields: {weight : 1, quantity: 1}}
+		).forEach(function(item){
+			weight += item.totalWeight();
+		});
+		return weight;
+	},
+	color: function() {
+		if (this.color) return this.color + " white-text";
+	},
+});

rpg-docs/client/views/character/inventory/containerDialog/containerDialog.html

@@ -1,22 +1,46 @@
 <template name="containerDialog">
 	{{#with container}}
-		{{#baseDialog title=name class=colorClass}}
+		{{#baseDialog title=name class=colorClass startEditing=../startEditing}}
-			<!--Name and plural name-->
+			{{> containerView}}
-			<paper-input id="containerNameInput" label="Name" floatinglabel value={{name}}></paper-input>
+		{{else}}
-			<!--Weight-->
+			{{> containerEdit}}
-			<paper-input-decorator label="Weight" floatinglabel>
-				<input id="weightInput" type="number" value={{weight}}>
-			</paper-input-decorator>
-			<!--Value-->
-			<paper-input-decorator label="Value" floatinglabel>
-				<input id="valueInput" type="number" value={{value}}>
-			</paper-input-decorator>
-			<!--Description-->
-			<paper-input-decorator label="Description" floatinglabel layout vertical>
-				<paper-autogrow-textarea>
-					<textarea id="containerDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
-				</paper-autogrow-textarea>
-			</paper-input-decorator>
 		{{/baseDialog}}
 	{{/with}}
-</template>
+</template>
+
+<template name="containerEdit">
+	<paper-input id="containerNameInput"
+				 label="Name"
+				 floatinglabel
+				 value={{name}}></paper-input>
+	<div layout horizontal around-justified wrap>
+		<paper-input-decorator label="Weight" floatinglabel>
+			<input id="weightInput" type="number" value={{weight}}>
+		</paper-input-decorator>
+		<paper-input-decorator label="Value" floatinglabel>
+			<input id="valueInput" type="number" value={{value}}>
+		</paper-input-decorator>
+	</div>
+
+	<hr class="vertMargin">
+
+	<paper-input-decorator label="Description" floatinglabel layout vertical>
+		<paper-autogrow-textarea>
+			<textarea id="containerDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
+		</paper-autogrow-textarea>
+	</paper-input-decorator>
+</template>
+
+<template name="containerView">
+	<div layout horizontal wrap center justified>
+		<table class="summaryTable fullwidth">
+			<tr><td>Container</td><td>{{round weight}}lbs</td><td>{{longValueString value}}</td></tr>
+			<tr><td>Contents</td><td>{{round contentsWeight}}lbs</td><td>{{longValueString contentsValue}}</td></tr>
+			<tr class="body2"><td>Total</td><td>{{round totalWeight}}lbs</td><td>{{longValueString totalValue}}</td></tr>
+		</table>
+	</div>
+	{{#if description}}
+		<hr class="vertMargin">
+		<div>{{#markdown}}{{evaluateString charId description}}{{/markdown}}</div>
+	{{/if}}
+</template>

rpg-docs/client/views/character/inventory/containerDialog/containerDialog.js

@@ -10,11 +10,21 @@ Template.containerDialog.events({
 	},
 	"tap #deleteButton": function(event, instance){
 		Containers.softRemoveNode(instance.data.containerId);
-		GlobalUI.deletedToast(instance.data.containerId, "Containers", "Container and contents");
+		GlobalUI.deletedToast(
+			instance.data.containerId,
+			"Containers", "Container and contents"
+		);
 		GlobalUI.closeDetail();
 	},
+});
+
+Template.containerEdit.onRendered(function(){
+	updatePolymerInputs(this);
+});
+
+Template.containerEdit.events({
 	//TODO validate input (integer, non-negative, etc) for these inputs and give validation errors
-	"change #containerNameInput, input #containerNameInput": function(event){
+	"change #containerNameInput": function(event){
 		var name = Template.instance().find("#containerNameInput").value;
 		Containers.update(this._id, {$set: {name: name}});
 	},
@@ -26,8 +36,8 @@ Template.containerDialog.events({
 		var value = +Template.instance().find("#valueInput").value;
 		Containers.update(this._id, {$set: {value: value}});
 	},
-	"change #containerDescriptionInput": function(event){
+	"change #containerDescriptionInput": function(event, instance){
-		var description = Template.instance().find("#containerDescriptionInput").value;
+		var description = instance.find("#containerDescriptionInput").value;
 		Containers.update(this._id, {$set: {description: description}});
-	}
+	},
 });

rpg-docs/client/views/character/inventory/inventory.css

@@ -1,153 +0,0 @@
-div#stats {
-	-webkit-column-width: 200px;
-	-moz-column-width: 200px;
-	column-width: 200px;
-	-webkit-column-count: 4;
-	-moz-column-count: 4;
-	column-count: 4;
-}
-
-.containers {
-	-webkit-column-width: 300px;
-	-moz-column-width: 300px;
-	column-width: 300px;
-	-webkit-column-gap: 8px;
-	-moz-column-gap: 8px;
-	column-gap: 8px;
-	-moz-column-fill: balance;
-	column-fill: balance;
-	padding: 8px;
-}
-
-.containerLeft {
-	padding: 16px 16px 16px 24px;
-	display: flex;
-	justify-content: center;
-	flex-direction: row;
-	border-radius: 2px 0 0 2px;
-
-	/* same style as display-1 */
-	font-size: 34px;
-	font-weight: 400;
-	color: #ffffff;
-	color: rgba(255,255,255,0.54);
-	letter-spacing: 0;
-}
-
-.statCard .containerLeft {
-	padding: 16px;
-}
-
-.containerRight {
-	padding: 16px;
-	cursor: pointer;
-
-	/* same style as subhead */
-	font-size: 16px;
-	font-weight: 400;
-	margin: 0;
-	color: #000;
-	color: rgba(0,0,0,0.87);
-	letter-spacing: 0.010em;
-}
-
-.resourceValue {
-	display: inline-block;
-}
-
-.resourceMax {
-	display: inline-block;
-	align-self: flex-end;
-
-	/* same style as subhead */
-	font-size: 16px;
-	font-weight: 400;
-	margin: 0;
-	color: #fff;
-	color: rgba(255,255,255,0.54);
-	letter-spacing: 0.010em;
-}
-
-.resourceMax:before {
-	content: "/";
-}
-
-.resourceButtons {
-	margin: -16px -16px -16px 8px;
-	align-self: center;
-}
-
-.resourceButtons paper-icon-button{
-	width: 32px;
-	height: 32px;
-	padding: 0;
-	display: block;
-}
-
-.resourceButtons paper-icon-button[disabled]{
-	color: rgba(255, 255, 255, 0.26);
-}
-
-.resourceButtons /deep/ core-icon {
-	width: 32px;
-	height: 32px;
-}
-
-.containerTop {
-	cursor: pointer;
-	padding: 16px;
-	position: relative;
-	border-radius: 2px 2px 0 0;
-}
-
-.equipmentTop {
-	padding: 16px;
-	border-bottom: rgba(0,0,0,0.12) solid 1px;
-}
-
-.containerMain {
-	padding: 16px;
-}
-
-.equipmentMain {
-	padding-bottom: 16px;
-}
-
-.inventoryItem {
-	background: white;
-	transition: box-shadow 0.3s ease,
-		opacity 0.5s ease-in-out;
-	height: 40px;
-	margin: 1px 0 1px 0;
-	font-size: 16px;
-	color: rgba(0,0,0,0.87);
-	letter-spacing: 0.010em;
-}
-
-.inventoryItem core-icon, .inventoryItem paper-icon-button {
-	color: rgba(0,0,0,0.54);
-}
-
-.inventoryItem core-icon {
-	margin-right: 16px;
-}
-
-.inventoryItem /deep/ .button-content {
-	-webkit-flex: 1;
-	flex: 1;
-	-webkit-flex-basis: 0.000000001px;
-	flex-basis: 0.000000001px;
-}
-
-.inventoryItem[hero] {
-	box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.37);
-}
-
-.itemSlot {
-	background-color: rgb(232, 232, 232);
-	background-color: rgba(0, 0, 0, 0.1);
-}
-
-#inventory .containerMain {
-	padding: 0 0 16px 0;
-}

rpg-docs/client/views/character/inventory/inventory.html

@@ -1,73 +1,124 @@
 <template name="inventory">
 	<div fit>
 		<div id="inventory" class="scroll-y" fit>
-			<div class="containers">
+			<div class="column-container">
 				<!--Net Worth-->
-				<paper-shadow class="card container" hero-id="main" {{detailHero}} layout horizontal>
+				<paper-shadow class="card">
-					<div class="indigo white-text subhead padded leftRound" layout horizontal center>
+					<div class="white top" layout horizontal center>
-						Net Worth
+						<div class="subhead" flex>
-					</div>
+							Net Worth
-					<div class="padded" layout horizontal center>
+						</div>
-						{{valueString netWorth}}
+						<div>
+							{{valueString netWorth}}
+						</div>
 					</div>
 				</paper-shadow>
 				<!--Weight Carried-->
-				<paper-shadow class="card container" hero-id="main" {{detailHero}} layout horizontal>
+				<paper-shadow class="card"
-					<div class="green white-text subhead padded leftRound" layout horizontal center>
+							  hero-id="main" {{detailHero "weightCarried" _id}}>
-						Weight Carried
+					<div class="top green white-text weightCarried"
+						 hero-id="toolbar" {{detailHero "weightCarried" _id}}
+						 layout horizontal center>
+						<div class="subhead" flex>
+							Weight Carried
+						</div>
+						<div>
+							{{round weightCarried}}lbs
+						</div>
 					</div>
-					<div class="padded" layout horizontal center>
+					<div class="bottom green" style="padding: 0;">
-						{{round weightCarried}}lbs
+						{{> carryCapacityBar}}
 					</div>
+					{{#if encumberedBuffs.count}}
+					<div class="bottom list">
+						{{#each encumberedBuffs}}
+						<div class="item-slot">
+							<div class="item buff"
+								 hero-id="main" {{detailHero}}
+								 layout horizontal center>
+								<div flex>
+									<core-icon icon="work"
+											   style="margin-right: 16px">
+									</core-icon>
+									{{name}}
+								</div>
+							</div>
+						</div>
+						{{/each}}
+					</div>
+					{{/if}}
 				</paper-shadow>
 				<!--Equipment-->
-				<paper-shadow class="card container equipmentContainer">
+				<paper-shadow class="card equipmentContainer">
-					<div class="equipmentTop" layout horizontal center>
+					<div class="white top" layout horizontal center>
-						<div class="containerName subhead" flex>
+						<div class="subhead" flex>
 							Equipment
 						</div>
-						<div class="caption" style="margin-right: 8px">{{valueString equipmentValue}}</div>
+						<div class="caption" style="margin-right: 8px">
-						<div class="caption">{{round equipmentWeight}}lbs</div>
+							{{valueString equipmentValue}}
+						</div>
+						<div class="caption">
+							{{round equipmentWeight}}lbs
+						</div>
 					</div>
-					<div flex class="equipmentMain">
+					<div flex class="bottom list">
 						{{#if attuned.count}}
-							<div class="list-subhead" layout horizontal center>Attuned</div>
+							<div class="subhead">Attuned</div>
 						{{/if}}
 						{{#each attuned}}
 							{{>inventoryItem}}
 						{{/each}}
-						{{#if attuned.count}}<div class="list-subhead" layout horizontal center>Equipment</div>{{/if}}
+						{{#if attuned.count}}
+							<div class="subhead">Equipment</div>
+						{{/if}}
 						{{#each equipment}}
 							{{>inventoryItem}}
 						{{/each}}
 					</div>
 				</paper-shadow>
 				<!--Carried Items-->
-				<paper-shadow class="card container carriedContainer">
+				<paper-shadow class="card carriedContainer">
-					<div class="equipmentTop" layout horizontal center>
+					<div class="white top" layout horizontal center>
-						<div class="containerName subhead" flex>
+						<div class="subhead" flex>
 							Carried
 						</div>
-						<div class="caption" style="margin-right: 8px">{{valueString carriedValue}}</div>
+						<div class="caption" style="margin-right: 8px">
-						<div class="caption">{{round carriedWeight}}lbs</div>
+							{{valueString carriedValue}}
+						</div>
+						<div class="caption">
+							{{round carriedWeight}}lbs
+						</div>
 					</div>
-					<div flex class="containerMain">
+					<div flex class="bottom list">
 						{{#each carriedItems}}
 							{{>inventoryItem}}
 						{{/each}}
 					</div>
 				</paper-shadow>
 				{{#each containers}}
-					<paper-shadow class="card container itemContainer"  hero-id="main" {{detailHero}} style="order: {{containerOrder}};">
+					<paper-shadow class="card itemContainer" 
-						<div class="containerTop {{colorClass}}" hero-id="toolbar" layout horizontal center {{detailHero}}>
+								  hero-id="main" {{detailHero}}>
-							<div class="containerName subhead" hero-id="title" flex {{detailHero}}>{{name}}</div>
+						<div class="top {{colorClass}}"
-							<div class="caption" style="margin-right: 8px">{{valueString totalValue}}</div>
+							 hero-id="toolbar" {{detailHero}}
-							<div class="caption" style="margin-right: 8px">{{round totalWeight}}lbs</div>
+							 layout horizontal center>
+							<div class="subhead" flex
+								 hero-id="title" {{detailHero}}>
+								{{name}}
+							</div>
+							<div class="caption" style="margin-right: 8px">
+								{{valueString totalValue}}
+							</div>
+							<div class="caption" style="margin-right: 8px">
+								{{round totalWeight}}lbs
+							</div>
 							<core-tooltip label="Container carried" position="left">
-								<paper-checkbox class="carriedCheckbox" checked={{isCarried}}></paper-checkbox>
+								<paper-checkbox class="carriedCheckbox"
+												disabled={{#unless canEditCharacter charId}}true{{/unless}}
+												checked={{isCarried}}>
+								</paper-checkbox>
 							</core-tooltip>
 						</div>
-						<div flex class="containerMain">
+						<div class="bottom list">
 							{{#each items ../_id _id}}
 								{{>inventoryItem}}
 							{{/each}}
@@ -77,17 +128,45 @@
 			</div>
 			<div class="fab-buffer"></div>
 		</div>
-		<paper-fab-menu id="inventoryAddMenu" icon="add" closeIcon="close" duration="0.3">
+		{{#if canEditCharacter _id}}
-			<paper-fab-menu-item id="addItem" icon="note-add" color="#d23f31" tooltip="Item"></paper-fab-menu-item>
+			{{#fabMenu}}
-			<paper-fab-menu-item id="addContainer" icon="work" color="#d23f31" tooltip="Container"></paper-fab-menu-item>
+				<core-tooltip label="New container" position="left">
-		</paper-fab-menu>
+					<paper-fab icon="work"
+							   class="addContainer"
+							   mini>
+					</paper-fab>
+				</core-tooltip>
+				<core-tooltip label="New item" position="left">
+					<paper-fab icon="note-add"
+							   class="addItem"
+							   mini>
+					</paper-fab>
+				</core-tooltip>
+			{{/fabMenu}}
+		{{/if}}
 	</div>
 </template>
 
 <template name="inventoryItem">
-	<div class="itemSlot">
+	<div class="item-slot">
-		<paper-item class="inventoryItem {{hidden}}" hero-id="main" noink {{detailHero}} layout horizontal draggable="true">
+		<div class="item {{hidden}} inventoryItem"
-			{{#if ne1 quantity}}{{quantity}}&nbsp;{{/if}}{{pluralName}}
+					hero-id="main" {{detailHero}}
-		</paper-item>
+					layout horizontal center
+			 		draggable={{canEditCharacter charId}}>
+			<div flex class="itemName">
+				{{#if ne1 quantity}}{{quantity}}&nbsp;{{/if}}{{pluralName}}
+			</div>
+			{{#if settings.showIncrement}}{{#if canEditCharacter charId}}
+			<div class="incrementButtons">
+				<paper-icon-button class="addItemQuantity"
+								   icon="add"
+								   style="margin-right: -8px"></paper-icon-button>
+				<paper-icon-button class="subItemQuantity"
+								   disabled={{lt1 quantity}}
+								   icon="remove"
+								   style="margin-right: -8px"></paper-icon-button>
+			</div>
+			{{/if}}{{/if}}
+		</div>
 	</div>
 </template>

rpg-docs/client/views/character/inventory/inventory.js

@@ -7,16 +7,28 @@ Template.inventory.helpers({
 		return Containers.find({charId: this._id}, {sort: {color: 1, name: 1}});
 	},
 	items: function(charId, containerId){
-		return Items.find({charId: charId, "parent.id": containerId }, {sort: {color: 1, name: 1}});
+		return Items.find(
+			{charId: charId, "parent.id": containerId},
+			{sort: {color: 1, name: 1}}
+		);
 	},
 	attuned: function(){
-		return Items.find({ charId: this._id, enabled: true, requiresAttunement: true  }, {sort: {color: 1, name: 1}});
+		return Items.find(
+			{charId: this._id, enabled: true, requiresAttunement: true},
+			{sort: {color: 1, name: 1}}
+		);
 	},
 	equipment: function(){
-		return Items.find({ charId: this._id, enabled: true, requiresAttunement: false }, {sort: {color: 1, name: 1}});
+		return Items.find(
+			{charId: this._id, enabled: true, requiresAttunement: false},
+			{sort: {color: 1, name: 1}}
+		);
 	},
 	carriedItems: function(){
-		return Items.find({charId: this._id, enabled: false, "parent.id": this._id}, {sort: {color: 1, name: 1}});
+		return Items.find(
+			{charId: this._id, enabled: false, "parent.id": this._id},
+			{sort: {color: 1, name: 1}}
+		);
 	},
 	showAddButtons: function(){
 		return Template.instance().showAddButtons.get();
@@ -26,45 +38,82 @@ Template.inventory.helpers({
 	},
 	netWorth: function(){
 		var worth = 0;
-		Items.find({charId: this._id}, {fields: {value : 1, quantity: 1}}).forEach(function(item){
+		Items.find(
+			{charId: this._id},
+			{fields: {value : 1, quantity: 1}}
+		).forEach(function(item){
 			worth += item.totalValue();
 		});
+		Containers.find(
+			{charId: this._id},
+			{fields: {value : 1}}
+		).forEach(function(container) {
+			if (container.value) worth += container.value;
+		});
 		return worth;
 	},
 	weightCarried: function(){
 		var weight = 0;
-		Containers.find({charId: this._id, isCarried: true}).forEach(function(container){
+		Containers.find(
+			{charId: this._id, isCarried: true}
+		).forEach(function(container){
 			weight += container.totalWeight();
 		});
-		Items.find({charId: this._id, "parent.id": this._id}, {fields: {weight : 1, quantity: 1}}).forEach(function(item){
+		Items.find(
+			{charId: this._id, "parent.id": this._id},
+			{fields: {weight : 1, quantity: 1}}
+		).forEach(function(item){
 			weight += item.totalWeight();
 		});
 		return weight;
 	},
+	encumberedBuffs: function(){
+		return Buffs.find({
+			charId: this._id,
+			type: "inate",
+			name: {$in: [
+				"Encumbered",
+				"Heavily encumbered",
+				"Over encumbered",
+				"Can't move load",
+			]},
+		});
+	},
 	equipmentValue: function(){
 		var value = 0;
-		Items.find({charId: this._id, enabled: true}, {fields: {value : 1, quantity: 1}}).forEach(function(item){
+		Items.find(
+			{charId: this._id, enabled: true},
+			{fields: {value : 1, quantity: 1}}
+		).forEach(function(item){
 			value += item.totalValue();
 		});
 		return value;
 	},
 	equipmentWeight: function(){
 		var weight = 0;
-		Items.find({charId: this._id, enabled: true}, {fields: {weight : 1, quantity: 1}}).forEach(function(item){
+		Items.find({charId: this._id, enabled: true},
+				   {fields: {weight : 1, quantity: 1}}
+				  ).forEach(function(item){
 			weight += item.totalWeight();
 		});
 		return weight;
 	},
 	carriedValue: function(){
 		var value = 0;
-		Items.find({charId: this._id, enabled: false, "parent.id": this._id}, {fields: {value : 1, quantity: 1}}).forEach(function(item){
+		Items.find(
+			{charId: this._id, enabled: false, "parent.id": this._id},
+			{fields: {value : 1, quantity: 1}}
+		).forEach(function(item){
 			value += item.totalValue();
 		});
 		return value;
 	},
 	carriedWeight: function(){
 		var weight = 0;
-		Items.find({charId: this._id, enabled: false, "parent.id": this._id}, {fields: {weight : 1, quantity: 1}}).forEach(function(item){
+		Items.find(
+			{charId: this._id, enabled: false, "parent.id": this._id},
+			{fields: {weight : 1, quantity: 1}}
+		).forEach(function(item){
 			weight += item.totalWeight();
 		});
 		return weight;
@@ -72,29 +121,54 @@ Template.inventory.helpers({
 });
 
 Template.inventory.events({
-	"tap #addItem": function(event){
+	"tap .addItem": function(event){
 		var charId = this._id;
 		Items.insert({
 			charId: charId,
 			parent:{
 				id: charId,
-				collection: "Characters"
+				collection: "Characters",
-			}
+			},
 		}, function(err, itemId){
-			if(err) throw err;
+			if (err) throw err;
 			GlobalUI.setDetail({
 				template: "itemDialog",
-				data:     {itemId: itemId, charId: charId},
+				data:     {itemId: itemId, charId: charId, startEditing: true},
-				heroId:   itemId
+				heroId:   itemId,
 			});
 		});
 	},
-	"tap #addContainer": function(event){
+	"tap .addContainer": function(event){
-		var containerId = Containers.insert({name: "New Container", isCarried: true, charId: this._id});
+		var containerId = Containers.insert({
+			name: "New Container",
+			isCarried: true,
+			charId: this._id,
+		});
 		GlobalUI.setDetail({
 			template: "containerDialog",
-			data:     {containerId: containerId, charId: this.charId},
+			data:     {
-			heroId:   containerId
+				containerId: containerId,
+				charId: this.charId,
+				startEditing: true,
+			},
+			heroId:   containerId,
+		});
+	},
+	"tap .weightCarried": function(event) {
+		var charId = this._id;
+		GlobalUI.setDetail({
+			template: "carryDialog",
+			data:     {charId: charId, color: "green"},
+			heroId:   charId + "weightCarried",
+		});
+	},
+	"tap .buff": function(event){
+		var buffId = this._id;
+		var charId = Template.parentData()._id;
+		GlobalUI.setDetail({
+			template: "buffDialog",
+			data:     {buffId: buffId, charId: charId},
+			heroId:   buffId,
 		});
 	},
 	"tap .inventoryItem": function(event){
@@ -103,14 +177,39 @@ Template.inventory.events({
 		GlobalUI.setDetail({
 			template: "itemDialog",
 			data:     {itemId: itemId, charId: charId},
-			heroId:   itemId
+			heroId:   itemId,
 		});
 	},
-	"tap .containerTop": function(event){
+	"hold .inventoryItem": function(event, instance) {
+		var itemId = this._id;
+		var charId = Template.parentData()._id;
+		var containerId = this.parent.id;
+		GlobalUI.showDialog({
+			template: "moveItemDialog",
+			data:     {
+				charId: charId,
+				itemId: itemId,
+				containerId: containerId,
+			},
+			heading:   "Move " + this.pluralName(),
+		});
+	},
+	"tap .incrementButtons": function(event) {
+		event.stopPropagation();
+	},
+	"tap .addItemQuantity": function(event) {
+		var itemId = this._id;
+		Items.update(itemId, {$set: {quantity: this.quantity + 1}});
+	},
+	"tap .subItemQuantity": function(event) {
+		var itemId = this._id;
+		Items.update(itemId, {$set: {quantity: this.quantity - 1}});
+	},
+	"tap .itemContainer .top": function(event){
 		GlobalUI.setDetail({
 			template: "containerDialog",
 			data:     {containerId: this._id, charId: this.charId},
-			heroId:   this._id
+			heroId:   this._id,
 		});
 	},
 	"tap .carriedCheckbox": function(event){
@@ -118,88 +217,113 @@ Template.inventory.events({
 	},
 	"change .carriedCheckbox": function(event){
 		var carried;
-		if(this.isCarried) carried = false;
+		if (this.isCarried) carried = false;
 		else carried = true;
 		Containers.update(this._id, {$set: {isCarried: carried}});
-	}
+	},
 });
 
 Template.inventoryItem.helpers({
 	ne1: function(num){
 		return num !== 1;
 	},
+	lt1: function(num) {
+		return num < 1;
+	},
 	hidden: function(){
-		return Session.equals("inventory.dragItemId", this._id)? "hidden" : null;
+		return Session.equals("inventory.dragItemId", this._id) ? "hidden" : null;
-	}
+	},
 });
 
 Template.layout.events({
 	"dragstart .inventoryItem": function(event, instance){
+		event.originalEvent.dataTransfer.setData("dicecloud-id/items", this._id);
 		Session.set("inventory.dragItemId", this._id);
-		Session.set("inventory.dragItemOriginalContainer", this.container);
+	},
-		Session.set("inventory.dragItemOriginalCharacter", this.charId);
+	"dragover .itemContainer, dragenter .itemContainer":
+	function(event, instance){
+		if (_.contains(event.originalEvent.dataTransfer.types, "dicecloud-id/items")){
+			event.preventDefault();
+		}
+	},
+	"dragover .equipmentContainer, dragenter .equipmentContainer":
+	function(event, instance){
+		if (_.contains(event.originalEvent.dataTransfer.types, "dicecloud-id/items")){
+			event.preventDefault();
+		}
+	},
+	"dragover .carriedContainer, dragenter .carriedContainer":
+	function(event, instance){
+		if (_.contains(event.originalEvent.dataTransfer.types, "dicecloud-id/items")){
+			event.preventDefault();
+		}
+	},
+	"dragover .characterRepresentative, dragenter .characterRepresentative":
+	function(event, instance){
+		if (_.contains(event.originalEvent.dataTransfer.types, "dicecloud-id/items")){
+			event.preventDefault();
+		}
 	},
 	"dragend .inventoryItem": function(event, instance){
-		resetInvetorySession(); //this is a valid drop zone
+		Session.set("inventory.dragItemId", null);
 	},
-	"dragover .itemContainer": function(event, instance){
+	"drop .itemContainer": function(event, instance){
-		event.preventDefault();
+		var itemId = event.originalEvent.dataTransfer.getData("dicecloud-id/items");
-	},
+		if (event.ctrlKey){
-	"dragover .equipmentContainer": function(event, instance){
-		event.preventDefault();
-	},
-	"dragover .carriedContainer": function(event, instance){
-		event.preventDefault();
-	},
-	"drop .itemContainer": function(event, instacne){
-		var item = Items.findOne(Session.get("inventory.dragItemId"));
-		if(event.ctrlKey){
 			//split the stack to the container
 			GlobalUI.showDialog({
 				template: "splitStackDialog",
 				data: {
-					id: item._id,
+					id: itemId,
 					parentCollection: "Containers",
-					parentId: this._id
+					parentId: this._id,
-				}
+				},
 			});
-		} else{
+		} else {
 			//move item to the container
-			item.moveToContainer(this._id);
+			Meteor.call("moveItemToContainer", itemId, this._id);
 		}
-		resetInvetorySession();
+		Session.set("inventory.dragItemId", null);
 	},
 	"drop .equipmentContainer": function(event, instance){
-		var charId = Session.get("inventory.dragItemOriginalCharacter");
+		var itemId = event.originalEvent.dataTransfer.getData("dicecloud-id/items");
-		var item = Items.findOne(Session.get("inventory.dragItemId"));
+		Meteor.call("equipItem", itemId, this._id);
-		item.equip(charId);
+		Session.set("inventory.dragItemId", null);
-		resetInvetorySession();
 	},
 	"drop .carriedContainer": function(event, instance){
-		var charId = Session.get("inventory.dragItemOriginalCharacter");
+		var itemId = event.originalEvent.dataTransfer.getData("dicecloud-id/items");
-		var item = Items.findOne(Session.get("inventory.dragItemId"));
+		if (event.ctrlKey){
-		if(event.ctrlKey){
 			//split the stack to the container
 			GlobalUI.showDialog({
 				template: "splitStackDialog",
 				data: {
-					id: item._id,
+					id: itemId,
 					parentCollection: "Characters",
-					parentId: this._id
+					parentId: this._id,
-				}
+				},
 			});
-		} else{
+		} else {
 			//move item to the character
-			item.moveToCharacter(this._id);
+			Meteor.call("moveItemToCharacter", itemId, this._id);
 		}
-		resetInvetorySession();
-	}
-});
-
-var resetInvetorySession = function(){
-	_.defer(function(){
 		Session.set("inventory.dragItemId", null);
-		Session.set("inventory.dragItemOriginalContainer", null);
+	},
-		Session.set("inventory.dragItemOriginalCharacter", null);
+	"drop .characterRepresentative": function(event, instance) {
-	});
+		var itemId = event.originalEvent.dataTransfer.getData("dicecloud-id/items");
-};
+		if (event.ctrlKey){
+			//split the stack to the container
+			GlobalUI.showDialog({
+				template: "splitStackDialog",
+				data: {
+					id: itemId,
+					parentCollection: "Characters",
+					parentId: this._id,
+				},
+			});
+		} else {
+			//move item to the character
+			Meteor.call("moveItemToCharacter", itemId, this._id);
+		}
+		Session.set("inventory.dragItemId", null);
+	},
+});

rpg-docs/client/views/character/inventory/itemDialog/itemDialog.html

@@ -1,57 +1,113 @@
 <template name="itemDialog">
 	{{#with item}}
-		{{#baseDialog title=name class=colorClass}}
+		{{#baseDialog title=itemHeading class=colorClass startEditing=../startEditing}}
-			<!--Name and plural name-->
+			{{> itemDetails}}
-			<paper-input id="itemNameInput" class="fullwidth" label="Name" floatinglabel value={{name}}></paper-input>
+		{{else}}
-			{{# if ne1 quantity}}<paper-input id="itemPluralInput" label="Plural Name" floatinglabel value={{plural}}></paper-input>{{/if}}
+			{{> itemEdit}}
-			<!--Container dropdown-->
-			<paper-dropdown-menu id="containerDropDown" label="Container">
-				<paper-dropdown layered class="dropdown">
-					<core-menu class="menu"  selected={{parent.id}}>
-						{{#each containers}}
-							<paper-item name={{_id}} class="containerMenuItem">{{name}}</paper-item>
-						{{/each}}
-					</core-menu>
-				</paper-dropdown>
-			</paper-dropdown-menu>
-			<!--Equipped-->
-			<div center horizontal layout>
-				<div flex>Equipped</div>
-				<paper-toggle-button id="equippedInput"
-									 checked={{enabled}}
-									 role="button" 
-									 aria-pressed="false"
-									 tabindex="0" 
-									 touch-action="pan-y">
-				</paper-toggle-button>
-			</div>
-			<!--Equipped-->
-			<div center horizontal layout>
-				<div flex>Requires Attunement</div>
-				<paper-checkbox id="attunementCheckbox" checked={{requiresAttunement}}></paper-checkbox>
-			</div>
-			<!--Quantity-->
-			<paper-input-decorator label="Quantity" floatinglabel>
-				<input id="quantityInput" type="number" value={{quantity}}>
-			</paper-input-decorator>
-			<!--Weight-->
-			<paper-input-decorator label="Weight Each (lbs)" floatinglabel>
-				<input id="weightInput" type="number" value={{weight}}>
-			</paper-input-decorator>
-			<!--Value-->
-			<paper-input-decorator label="Value Each (GP)" floatinglabel>
-				<input id="valueInput" type="number" value={{value}}>
-			</paper-input-decorator>
-			<!--Description-->
-			<paper-input-decorator label="Description" floatinglabel layout vertical>
-				<paper-autogrow-textarea>
-					<textarea id="itemDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
-				</paper-autogrow-textarea>
-			</paper-input-decorator>
-			<!--Effects-->
-			{{> effectsEditList parentId=_id parentCollection="Items" charId=charId type="equipment" enabled=equipped name=name}}
-			<!--Attacks-->
-			{{> attackEditList  parentId=_id parentCollection="Items" charId=charId type="equipment" enabled=equipped name=name}}
 		{{/baseDialog}}
 	{{/with}}
-</template>
+</template>
+
+<template name="itemDetails">
+	<div layout horizontal wrap center justified class="headline">
+		{{#if weight}}<div class="sideMargin">{{round totalWeight}}lbs</div>{{/if}}
+		{{#if value}}<div>{{valueString totalValue}}</div>{{/if}}
+	</div>
+	<div layout horizontal wrap class="caption">
+		{{#if enabled}}<div class="vertMargin" style="margin-right: 16px">Equipped</div>{{/if}}
+		{{#if requiresAttunement}}<div class="vertMargin">Requires Attunement</div>{{/if}}
+	</div>
+	{{#if description}}
+		<hr style="margin: 16px 0 16px 0;">
+		<div>{{#markdown}}{{evaluateString charId description}}{{/markdown}}</div>
+	{{/if}}
+	{{> effectsViewList charId=charId parentId=_id}}
+	{{> attacksViewList charId=charId parentId=_id}}
+</template>
+
+<template name="itemEdit">
+	<paper-input class="fullwidth" id="itemNameInput" label="Name" floatinglabel value={{name}}></paper-input>
+	<div layout horizontal wrap>
+		<paper-input-decorator label="Quantity"
+							   floatinglabel
+							   style="width: 80px">
+			<input id="quantityInput"
+				   type="number"
+				   value={{quantity}}>
+		</paper-input-decorator>
+		{{# if ne1 quantity}}
+		<paper-input flex id="itemPluralInput" 
+					 label="Plural Name" 
+					 floatinglabel
+					 value={{plural}}></paper-input>
+		{{/if}}
+	</div>
+	<div center horizontal layout>
+		<div class="padded">Show increment buttons</div>
+		<paper-checkbox id="incrementCheckbox"
+						checked={{settings.showIncrement}}>
+		</paper-checkbox>
+	</div>
+
+	<hr class="vertMargin">
+
+	<div layout horizontal wrap justified>
+		<div center horizontal layout>
+			<div class="padded">Container</div>
+			{{> containerDropdown}}
+		</div>
+		<div center horizontal layout>
+			<div class="padded">Equipped</div>
+			<paper-toggle-button id="equippedInput"
+								 checked={{enabled}}
+								 role="button"
+								 aria-pressed="false"
+								 tabindex="0"
+								 touch-action="pan-y">
+			</paper-toggle-button>
+		</div>
+		<div center horizontal layout>
+			<div class="padded">Requires Attunement</div>
+			<paper-checkbox id="attunementCheckbox"
+							checked={{requiresAttunement}}>
+			</paper-checkbox>
+		</div>
+	</div>
+
+	<hr class="vertMargin">
+
+	<div layout horizontal around-justified>
+		<paper-input-decorator label="Weight Each (lbs)" floatinglabel>
+			<input id="weightInput" type="number" value={{weight}}>
+		</paper-input-decorator>
+		<!--Value-->
+		<paper-input-decorator label="Value Each (GP)" floatinglabel>
+			<input id="valueInput" type="number" value={{value}}>
+		</paper-input-decorator>
+	</div>
+
+	<hr class="vertMargin">
+
+	<!--Description-->
+	<paper-input-decorator label="Description" floatinglabel layout vertical>
+		<paper-autogrow-textarea>
+			<textarea id="itemDescriptionInput" placeholder aria-label="Description" value={{description}}></textarea>
+		</paper-autogrow-textarea>
+	</paper-input-decorator>
+	<!--Effects-->
+	{{> effectsEditList parentId=_id parentCollection="Items" charId=charId enabled=equipped name=name}}
+	<!--Attacks-->
+	{{> attackEditList  parentId=_id parentCollection="Items" charId=charId enabled=equipped name=name}}
+</template>
+
+<template name="containerDropdown">
+	<paper-dropdown-menu id="containerDropDown" label="Container">
+		<paper-dropdown layered class="dropdown">
+			<core-menu class="menu"  selected={{parent.id}}>
+				{{#each containers}}
+					<paper-item name={{_id}} class="containerMenuItem">{{name}}</paper-item>
+				{{/each}}
+			</core-menu>
+		</paper-dropdown>
+	</paper-dropdown-menu>
+</template>

rpg-docs/client/views/character/inventory/itemDialog/itemDialog.js

@@ -1,20 +1,38 @@
 var getContainers = function(charId){
-	return Containers.find({charId: charId}, {sort: {name: 1, _id: 1}, fields: {name: 1}}).fetch();
+	return Containers.find(
+		{charId: charId},
+		{sort: {name: 1, _id: 1}, fields: {name: 1}}
+	);
 };
 
+Template.itemDialog.onCreated(function(){
+	this.editing = new ReactiveVar(!!this.data.startEditing);
+});
+
 Template.itemDialog.helpers({
 	item: function(){
 		return Items.findOne(this.itemId);
 	},
-	containers: function(){
+	editing: function(){
-		return getContainers(this.charId);
+		return Template.instance().editing.get();
+	},
+	itemHeading: function(){
+		if (this.quantity === 1){
+			return this.name;
+		} else {
+			var pName = this.plural || this.name;
+			return this.quantity + " " + pName;
+		}
 	},
-	ne1: function(num){
-		return num != 1;
-	}
 });
 
 Template.itemDialog.events({
+	"tap #editButton": function(event, instance){
+		instance.editing.set(true);
+	},
+	"tap #doneEditingButton": function(event, instance){
+		instance.editing.set(false);
+	},
 	"color-change": function(event, instance){
 		Items.update(instance.data.itemId, {$set: {color: event.color}});
 	},
@@ -23,6 +41,19 @@ Template.itemDialog.events({
 		GlobalUI.deletedToast(instance.data.itemId, "Items", "Item");
 		GlobalUI.closeDetail();
 	},
+});
+
+Template.itemEdit.onRendered(function(){
+	updatePolymerInputs(this);
+});
+
+Template.itemEdit.helpers({
+	ne1: function(num){
+		return num != 1;
+	},
+});
+
+Template.itemEdit.events({
 	//TODO validate input (integer, non-negative, etc) for these inputs and give validation errors
 	"change #itemNameInput": function(event){
 		var name = Template.instance().find("#itemNameInput").value;
@@ -50,24 +81,33 @@ Template.itemDialog.events({
 	},
 	"change #equippedInput": function(event){
 		var equipped = Template.instance().find("#equippedInput").checked;
-		var item = Items.findOne(this._id);
+		if (equipped){
-		if(item){
+			Meteor.call("equipItem", this._id, this.charId);
-			if(equipped){
+		} else {
-				item.equip();
+			Meteor.call("unequipItem", this._id, this.charId);
-			} else {
-				item.unequip();
-			}
 		}
 	},
+	"change #incrementCheckbox": function(event){
+		var value = event.currentTarget.checked;
+		Items.update(this._id, {$set: {"settings.showIncrement": value}});
+	},
 	"change #attunementCheckbox": function(event){
 		var value = event.currentTarget.checked;
 		Items.update(this._id, {$set: {requiresAttunement: value}});
 	},
-	"core-select #containerDropDown": function(event){
+});
-		var detail = event.originalEvent.detail;
+
-		if(!detail.isSelected) return;
+Template.containerDropdown.helpers({
-		var containerId = detail.item.getAttribute("name");
+	containers: function(){
-		var item = Items.findOne(Template.currentData().itemId);
+		return getContainers(this.charId);
-		item.moveToContainer(containerId);
+	}
+});
+
+Template.containerDropdown.events({
+	"core-select #containerDropDown": function(event){
+		var detail = event.originalEvent.detail;
+		if (!detail.isSelected) return;
+		var containerId = detail.item.getAttribute("name");
+		Meteor.call("moveItemToContainer", Template.currentData()._id, containerId);
 	}
 });

rpg-docs/client/views/character/inventory/moveItemDialog/moveItemDialog.css

@@ -0,0 +1,7 @@
+html /deep/ .moveItemDialog paper-tabs::shadow #selectionBar {
+	background-color: #D50000;
+}
+
+html /deep/ .moveItemDialog paper-tab::shadow #ink {
+	color: #D50000;
+}

rpg-docs/client/views/character/inventory/moveItemDialog/moveItemDialog.html

@@ -0,0 +1,49 @@
+<template name="moveItemDialog">
+	<div class="moveItemDialog">
+		<paper-tabs selected="{{selectedTab}}">
+			<paper-tab name="containers"
+					   class="clickable">
+				Containers
+			</paper-tab>
+			<paper-tab name="characters"
+					   class="clickable">
+				Characters
+			</paper-tab>
+		</paper-tabs>
+		<core-animated-pages selected="{{selectedTab}}"
+							 transitions="slide-from-right"
+							 style="width: 250px;
+									height: 200px;
+									overflow-y: auto;
+									overflow-x: hidden;">
+			<section name="containers">
+				<core-menu id="containerMenu" style="margin: 0;">
+					{{#each containers}}
+						<paper-item name={{_id}}
+									layout horizontal center>
+							<core-icon icon="image:brightness-1"
+									   style="color: {{hexColor color}};
+											  margin-right: 16px;">
+							</core-icon>
+							<div>{{name}}</div>
+						</paper-item>
+					{{/each}}
+				</core-menu>
+			</section>
+			<section name="characters">
+				<core-menu id="characterMenu"  style="margin: 0;">
+					{{#each characters}}
+					<paper-item name={{_id}}
+								layout horizontal center>
+						<div class="item small">
+							{{name}}
+						</div>
+					</paper-item>
+					{{/each}}
+				</core-menu>
+			</section>
+		</core-animated-pages>
+	</div>
+	<paper-button id="cancelButton" affirmative> Cancel </paper-button>
+	<paper-button id="moveButton" affirmative> Move </paper-button>
+</template>

rpg-docs/client/views/character/inventory/moveItemDialog/moveItemDialog.js

@@ -0,0 +1,56 @@
+Template.moveItemDialog.onCreated(function() {
+	Session.setDefault("moveItemDialogTab", "containers");
+});
+
+Template.moveItemDialog.helpers({
+	selectedTab: function() {
+		return Session.get("moveItemDialogTab");
+	},
+	characters: function() {
+		var userId = Meteor.userId();
+		return Characters.find(
+			{
+				$or: [
+					{readers: userId},
+					{writers: userId},
+					{owner: userId},
+				],
+				_id: {$ne: this.charId},
+			},
+			{fields: {name: 1}}
+		);
+	},
+	containers: function(){
+		return Containers.find(
+			{
+				charId: this.charId,
+				_id: {$ne: this.containerId},
+			},
+			{
+				fields: {color: 1, name: 1},
+				sort: {color: 1, name: 1},
+			}
+		);
+	},
+});
+
+Template.moveItemDialog.events({
+	"tap paper-tab": function(event) {
+		Session.set("moveItemDialogTab", event.currentTarget.getAttribute("name"));
+	},
+	"tap #moveButton": function(event, instance) {
+		var tab = Session.get("moveItemDialogTab");
+		if (tab === "containers"){
+			var containerId = instance.find("#containerMenu").selected;
+			if (!containerId) throw "no menu selection";
+			Meteor.call("moveItemToContainer", this.itemId, containerId);
+		} else if (tab === "characters"){
+			var characterId = instance.find("#characterMenu").selected;
+			if (!characterId) throw "no menu selection";
+			Meteor.call("moveItemToCharacter", this.itemId, characterId);
+		} else {
+			throw "Move item dialog tab is not set to containers or character," +
+				" it is set to " + tab;
+		}
+	},
+});

rpg-docs/client/views/character/inventory/splitStackDialog/splitStackDialog.js

@@ -1,27 +1,27 @@
 Template.splitStackDialog.helpers({
 	quantity: function(){
 		var item = Items.findOne(this.id);
-		if(item) return Math.round(item.quantity/2);
+		if (item) return Math.round(item.quantity / 2);
 	}
 });
 
 Template.splitStackDialog.events({
-	'tap #moveButton': function(event, instance){
+	"tap #moveButton": function(event, instance){
-		var item = Items.findOne(this.id);
+		Meteor.call(
-		if(item){
+			"splitItemToParent",
-			item.splitToParent(
+			this.id,
-				{collection: this.parentCollection , id: this.parentId}, 
+			+instance.find("#quantityInput").value,
-				+instance.find('#quantityInput').value
+			{collection: this.parentCollection , id: this.parentId}
-			);
+		);
-		}
 	},
-	'tap #oneButton':function(event, instance){
+	"tap #oneButton":function(event, instance){
-		instance.find('#quantityInput').value = 1;
+		instance.find("#quantityInput").value = 1;
 	},
-	'tap #halfButton':function(event, instance){
+	"tap #halfButton":function(event, instance){
-		instance.find('#quantityInput').value = Math.round(Items.findOne(this.id).quantity/2);
+		var val = Math.round(Items.findOne(this.id).quantity / 2);
+		instance.find("#quantityInput").value = val;
+	},
+	"tap #allButton":function(event, instance){
+		instance.find("#quantityInput").value = Items.findOne(this.id).quantity;
 	},
-	'tap #allButton':function(event, instance){
-		instance.find('#quantityInput').value = Items.findOne(this.id).quantity;
-	}
 });

rpg-docs/client/views/character/journal/classDialog/classDialog.html

@@ -1,12 +1,25 @@
 <template name="classDialog">
 	{{#with class}}
-		{{#baseDialog title=name class=colorClass hideColor="true"}}
+		{{#baseDialog title=name class=colorClass startEditing=../startEditing}}
+			<div layout vertical center>
+				<div class="display2">
+					{{level}}
+				</div>
+				<div>
+					level
+				</div>
+			</div>
+
+			{{> effectsViewList charId=charId parentId=_id}}
+			{{> proficiencyViewList charId=charId parentId=_id}}
+		{{else}}
 			<!--Name-->
 			<paper-input id="classNameInput" label="Class Name" floatinglabel value={{name}}></paper-input>
 			<!--Level-->
 			<paper-input id="levelValueInput" label="Level" floatinglabel value={{level}}></paper-input>
 			<!--Effects-->
-			{{> effectsEditList parentId=_id parentCollection="Classes" charId=charId type="class"}}
+			{{> effectsEditList parentId=_id parentCollection="Classes" charId=charId}}
+			{{> proficiencyEditList parentId=_id parentCollection="Classes" charId=charId}}
 		{{/baseDialog}}
 	{{/with}}
 </template>

rpg-docs/client/views/character/journal/classDialog/classDialog.js

@@ -1,4 +1,11 @@
+Template.classDialog.onRendered(function(){
+	updatePolymerInputs(this);
+});
+
 Template.classDialog.events({
+	"color-change": function(event, instance){
+		Classes.update(instance.data.classId, {$set: {color: event.color}});
+	},
 	"tap #deleteButton": function(event, instance){
 		Classes.softRemoveNode(instance.data.classId);
 		GlobalUI.deletedToast(instance.data.classId, "Classes", "Class");
@@ -11,11 +18,11 @@ Template.classDialog.events({
 	"change #levelValueInput": function(event){
 		var value = event.currentTarget.value;
 		Classes.update(this._id, {$set: {level: value}});
-	}
+	},
 });
 
 Template.classDialog.helpers({
 	class: function(){
 		return Classes.findOne(this.classId);
 	}
-});
+});