489 lines
15 KiB
JavaScript
489 lines
15 KiB
JavaScript
//set up the collection for characters
|
|
Characters = new Mongo.Collection("characters");
|
|
|
|
Schemas.Character = new SimpleSchema({
|
|
//strings
|
|
name: {type: String, defaultValue: "", trim: false},
|
|
alignment: {type: String, defaultValue: "", trim: false},
|
|
gender: {type: String, defaultValue: "", trim: false},
|
|
race: {type: String, defaultValue: "", trim: false},
|
|
description: {type: String, defaultValue: "", trim: false},
|
|
personality: {type: String, defaultValue: "", trim: false},
|
|
ideals: {type: String, defaultValue: "", trim: false},
|
|
bonds: {type: String, defaultValue: "", trim: false},
|
|
flaws: {type: String, defaultValue: "", trim: false},
|
|
backstory: {type: String, defaultValue: "", trim: false},
|
|
|
|
//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},
|
|
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},
|
|
|
|
//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},
|
|
readers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: []},
|
|
writers: {type: [String], regEx: SimpleSchema.RegEx.Id, defaultValue: []},
|
|
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"],
|
|
},
|
|
});
|
|
|
|
Characters.attachSchema(Schemas.Character);
|
|
|
|
var attributeBase = function(charId, statName){
|
|
check(statName, String);
|
|
//if it's a damage multiplier, we treat it specially
|
|
if (_.contains(DAMAGE_MULTIPLIERS, statName)){
|
|
var effects = Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "mul"}
|
|
).fetch();
|
|
var resistCount = 0;
|
|
var vulnCount = 0;
|
|
var multiplierEvaluationFail = false;
|
|
_.each(effects, function(effect){
|
|
var val = evaluateEffect(charId, effect);
|
|
if (val === 0.5){ //resistance
|
|
resistCount += 1;
|
|
} else if (val === 2){ //vulnerability
|
|
vulnCount += 1;
|
|
} else if (val === 0){ //imunity
|
|
return 0; //imunity is absolute
|
|
} else {
|
|
multiplierEvaluationFail = true;
|
|
}
|
|
});
|
|
if (multiplierEvaluationFail){
|
|
//we can't work it out correctly, set the value to 1
|
|
//and try work it out using regular maths below
|
|
value = 1;
|
|
} else if (resistCount && !vulnCount){
|
|
return 0.5;
|
|
} else if (!resistCount && vulnCount){
|
|
return 2;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
var value = 0;
|
|
|
|
//start with the highest base value
|
|
Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "base"}
|
|
).forEach(function(effect){
|
|
var efv = evaluateEffect(charId, effect);
|
|
if (efv > value){
|
|
value = efv;
|
|
}
|
|
});
|
|
|
|
//add all the add values
|
|
Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "add"}
|
|
).forEach(function(effect){
|
|
value += evaluateEffect(charId, effect);
|
|
});
|
|
|
|
//multiply all the mul values
|
|
Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "mul"}
|
|
).forEach(function(effect){
|
|
value *= evaluateEffect(charId, effect);
|
|
});
|
|
|
|
//ensure value is >= all mins
|
|
Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "min"}
|
|
).forEach(function(effect){
|
|
var min = evaluateEffect(charId, effect);
|
|
value = value > min ? value : min;
|
|
});
|
|
|
|
//ensure value is <= all maxes
|
|
Effects.find(
|
|
{charId: charId, stat: statName, enabled: true, operation: "max"}
|
|
).forEach(function(effect){
|
|
var max = evaluateEffect(charId, effect);
|
|
value = value < max ? value : max;
|
|
});
|
|
return value;
|
|
};
|
|
|
|
//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){
|
|
var fieldSelector = {};
|
|
fieldSelector[fieldName] = 1;
|
|
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)){
|
|
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 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;
|
|
var attribute = this.getField(attributeName);
|
|
//base value
|
|
var value = this.attributeBase(attributeName);
|
|
//plus adjustment
|
|
value += attribute.adjustment;
|
|
return value;
|
|
},
|
|
|
|
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;
|
|
//return largest value in proficiency array
|
|
var prof = 0;
|
|
Proficiencies.find(
|
|
{charId: charId, name: skillName, enabled: true}
|
|
).forEach(function(proficiency){
|
|
var newProf = proficiency.value;
|
|
if (newProf > prof){
|
|
prof = newProf;
|
|
}
|
|
});
|
|
return prof;
|
|
},
|
|
|
|
passiveSkill: function(skillName){
|
|
if (_.isString(skillName)){
|
|
var skill = this.getField(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;
|
|
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(attribute){
|
|
return signedString(getMod(this.attributeValue(attribute)));
|
|
},
|
|
|
|
passiveAbility: function(attribute){
|
|
var mod = +getMod(this.attributeValue(attribute));
|
|
return 10 + mod;
|
|
},
|
|
|
|
xpLevel: function(){
|
|
var xp = this.experience();
|
|
for (var i = 0; i < 19; i++){
|
|
if (xp < XP_TABLE[i]){
|
|
return i;
|
|
}
|
|
}
|
|
if (xp > 355000) return 20;
|
|
return 0;
|
|
},
|
|
|
|
level: function(){
|
|
var level = 0;
|
|
Classes.find({charId: this._id}).forEach(function(cls){
|
|
level += cls.level;
|
|
});
|
|
return level;
|
|
},
|
|
|
|
experience: function(){
|
|
var xp = 0;
|
|
Experiences.find(
|
|
{charId: this._id},
|
|
{fields: {value: 1}}
|
|
).forEach(function(e){
|
|
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){
|
|
Actions .remove({charId: character._id});
|
|
Attacks .remove({charId: character._id});
|
|
Buffs .remove({charId: character._id});
|
|
Classes .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.allow({
|
|
insert: function(userId, doc) {
|
|
// the user must be logged in, and the document must be owned by the user
|
|
return (userId && doc.owner === userId);
|
|
},
|
|
update: function(userId, doc, fields, modifier) {
|
|
// can only change documents you have write access to
|
|
return doc.owner === userId ||
|
|
_.contains(doc.writers, userId);
|
|
},
|
|
remove: function(userId, doc) {
|
|
// can only remove your own documents
|
|
return doc.owner === userId;
|
|
},
|
|
fetch: ["owner", "writers"],
|
|
});
|
|
|
|
Characters.deny({
|
|
update: function(userId, docs, fields, modifier) {
|
|
// can't change owners
|
|
return _.contains(fields, "owner");
|
|
}
|
|
});
|