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