');
}
}
catch (e) {
reporter.reportError('JSON parse error, please see log for more information');
logger.error(e.toString());
logger.error(e.stack);
}
}
};
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
/* globals state:false, createObj, findObjs, filterObjs, getObj, getAttrByName, sendChat, on, log, Campaign, playerIsGM, spawnFx, spawnFxBetweenPoints */
'use strict';
var _ = __webpack_require__(2);
//noinspection JSUnusedGlobalSymbols
module.exports = {
getState: function (module) {
if (!state[module]) {
state[module] = {};
}
return state[module];
},
createObj: function (type, attributes) {
return createObj(type, attributes);
},
findObjs: function (attributes) {
return findObjs(attributes);
},
filterObjs: function (callback) {
return filterObjs(callback);
},
getObj: function (type, id) {
return getObj(type, id);
},
getOrCreateObj: function (type, attributes) {
var newAttributes = _.extend(_.clone(attributes), { type: type });
var existing = this.findObjs(newAttributes);
switch (existing.length) {
case 0:
return this.createObj(type, newAttributes);
case 1:
return existing[0];
default:
throw new Error('Asked for a single ' + type + ' but more than 1 was found matching attributes: ' +
JSON.stringify(attributes));
}
},
getAttrByName: function (character, attrName) {
return getAttrByName(character, attrName);
},
getAttrObjectByName: function (character, attrName) {
var attr = this.findObjs({ type: 'attribute', characterid: character, name: attrName });
return attr && attr.length > 0 ? attr[0] : null;
},
getOrCreateAttr: function (characterId, attrName) {
return this.getOrCreateObj('attribute', { characterid: characterId, name: attrName });
},
setAttrByName: function (characterId, attrName, value) {
this.getOrCreateAttr(characterId, attrName).set('current', value);
},
processAttrValue: function (characterId, attrName, cb) {
var attribute = this.getOrCreateAttr(characterId, attrName);
attribute.set('current', cb(attribute.get('current')));
},
getRepeatingSectionAttrs: function (characterId, sectionName) {
var prefix = 'repeating_' + sectionName;
return _.filter(this.findObjs({ type: 'attribute', characterid: characterId }), function (attr) {
return attr.get('name').indexOf(prefix) === 0;
});
},
getRepeatingSectionItemIdsByName: function (characterId, sectionName) {
var re = new RegExp('repeating_' + sectionName + '_([^_]+)_name$');
return _.reduce(this.getRepeatingSectionAttrs(characterId, sectionName),
function (lookup, attr) {
var match = attr.get('name').match(re);
if (match) {
lookup[attr.get('current').toLowerCase()] = match[1];
}
return lookup;
}, {});
},
getCurrentPage: function (playerId) {
var pageId;
if (this.playerIsGM(playerId)) {
pageId = this.getObj('player', playerId).get('lastpage');
}
else {
pageId = this.getCampaign().get('playerspecificpages')[playerId] || this.getCampaign().get('playerpageid');
}
return pageId ? this.getObj('page', pageId) : null;
},
spawnFx: function (pointsArray, fxType, pageId) {
switch (pointsArray.length) {
case 1:
spawnFx(pointsArray[0].x, pointsArray[0].y, fxType, pageId);
break;
case 2:
spawnFxBetweenPoints(pointsArray[0], pointsArray[1], fxType, pageId);
break;
default:
throw new Error('Wrong number of points supplied to spawnFx: $$$', pointsArray);
}
},
playerIsGM: function (playerId) {
return playerIsGM(playerId);
},
getCampaign: function () {
return Campaign(); //jshint ignore: line
},
sendChat: function (sendAs, message, callback, options) {
return sendChat(sendAs, message, callback, options);
},
on: function (event, callback) {
return on(event, callback);
},
log: function (msg) {
return log(msg);
},
logWrap: 'roll20'
};
/***/ },
/* 2 */
/***/ function(module, exports) {
module.exports = _;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
var _ = __webpack_require__(2);
/**
* A specification of a field that can appear
* in the format that this parser processes
* @typedef {Object} FieldSpec
* @property {FieldSpec[]} [contentModel] - list of child fieldSpecs for complex content
* @property {boolean} [bare] - if true this field appears as a bare value with no parseToken in front of it
* @property {string} [parseToken] - the token that defines the beginning of this field (usually case insensitive). Not used for bare tokens.
* @property {string} [pattern] - a pattern that defines the value of this field. For bare properties this will determine
* if the field matches at all, whereas for normal ones this will just be used to validate them
* @property {number} [forNextMatchGroup] - the 1-based index of the match group from the supplied pattern that will contain text that
* should be handed to the next parser rather than used as part of this field.
* @property {number} [forPreviousMatchGroup] - the 1-based index of the match group from the supplied pattern that will contain text that
* should be handed to the previous parser to complete its value rather than used as part of this field.
* Only applicable to
* bare properties, since ones with a token have a clearly defined start based on the parseToken
* @property {number} [matchGroup=0] - the index of the capturing group in the supplied pattern to use as the value for this field. If left at the
* default of 0, the whole match will be used.
* @property {boolean} [caseSensitive=false] - If true, the pattern used for the value of this field will be made case sensitive. Note
* that parseToken matching is always case insensitive.
* @property {string} type - the type of this field. Currently valid values are [orderedContent, unorderedContent, string, enumType, integer, abililty]
* @property {string[]} enumValues - an array of valid values for this field if the type is enumType
* @property {number} [minOccurs=1] - the minimum number of times this field should occur in the parent content model.
* @property {number} [maxOccurs=1] - the maximum number of times this field should occur in the parent content model.
*/
/**
*
* @param {FieldSpec} formatSpec - Root format specification for this parser
* @param logger - Logger object to use for reporting errors etc.
* @returns {{parse:parse}} - A parser that will process text in the format specified by the supplied formatSpec into JSON objects
*/
function getParser(formatSpec, logger) {
'use strict';
//noinspection JSUnusedGlobalSymbols
var parserModule = {
makeContentModelParser: function (fieldSpec, ordered) {
var module = this;
return {
parse: function (stateManager, textLines, resume) {
var parseState = stateManager.enterChildParser(this, resume),
someMatch = false,
canContinue,
stopParser = null;
parseState.subParsers = parseState.subParsers || module.makeParserList(fieldSpec.contentModel);
if (parseState.resumeParser) {
if (!parseState.resumeParser.resumeParse(stateManager, textLines)) {
stateManager.leaveChildParser(this);
return false;
}
someMatch = true;
}
var parseRunner = function (parser, index, parsers) {
if (!parser.parse(stateManager, textLines)) {
if (parser.required === 0 || !ordered) {
//No match but it's ok to keep looking
//through the rest of the content model for one
return false;
}
//No match but one was required here by the content model
}
else {
parser.justMatched = true;
if (parser.required > 0) {
parser.required--;
}
parser.allowed--;
if (ordered) {
//Set all the previous parsers to be exhausted since we've matched
//this one and we're in a strictly ordered content model.
_.each(parsers.slice(0, index), _.partial(_.extend, _, { allowed: 0 }));
}
}
return true;
};
do {
stopParser = _.find(parseState.subParsers, parseRunner);
logger.debug('Stopped at parser $$$', stopParser);
canContinue = stopParser && stopParser.justMatched;
if (stopParser) {
someMatch = someMatch || stopParser.justMatched;
stopParser.justMatched = false;
}
//Lose any parsers that have used up all their cardinality already
parseState.subParsers = _.reject(parseState.subParsers, { allowed: 0 });
} while (!_.isEmpty(parseState.subParsers) && !_.isEmpty(textLines) && canContinue);
stateManager.leaveChildParser(this, someMatch ? parseState : undefined);
return someMatch;
},
resumeParse: function (stateManager, textLines) {
return this.parse(stateManager, textLines, true);
},
complete: function (parseState, finalText) {
var missingContent = _.filter(parseState.subParsers, 'required');
if (!_.isEmpty(missingContent)) {
throw new MissingContentError(missingContent);
}
}
};
},
matchParseToken: function (myParseState, textLines) {
if (_.isEmpty(textLines) || this.bare) {
return !_.isEmpty(textLines);
}
var re = new RegExp('^(.*?)(' + this.parseToken + ')(?:[\\s.]+|$)', 'i');
var match = textLines[0].match(re);
if (match) {
logger.debug('Found match $$$', match[0]);
myParseState.forPrevious = match[1];
myParseState.text = '';
textLines[0] = textLines[0].slice(match[0].length).trim();
if (!textLines[0]) {
textLines.shift();
}
}
return !!match;
},
matchValue: function (myParseState, textLines) {
if (this.pattern && this.bare) {
//If this is not a bare value then we can take all the text up to next
//token and just validate it at the end. If it is, then the pattern itself
//defines whether this field matches and we must run it immediately.
if (_.isEmpty(textLines)) {
return false;
}
textLines[0] = textLines[0].trim();
var matchGroup = this.matchGroup || 0;
var re = new RegExp(this.pattern, this.caseSensitive ? '' : 'i');
logger.debug('$$$ attempting to match value [$$$] against regexp $$$', this.name, textLines[0], re.toString());
var match = textLines[0].match(re);
if (match) {
logger.debug('Successful match! $$$', match);
myParseState.text = match[matchGroup];
if (!myParseState.forPrevious && this.forPreviousMatchGroup) {
logger.debug('Setting forPrevious to $$$', match[this.forPreviousMatchGroup]);
myParseState.forPrevious = match[this.forPreviousMatchGroup];
}
textLines[0] = textLines[0].slice(match.index + match[0].length);
if (this.forNextMatchGroup && match[this.forNextMatchGroup]) {
textLines[0] = match[this.forNextMatchGroup] + textLines[0];
}
if (!textLines[0]) {
myParseState.text += '\n';
textLines.shift();
}
return true;
}
else {
logger.debug('Match failed');
}
return false;
}
else {
logger.debug('$$$ standard string match, not using pattern', this.name);
myParseState.text = '';
return true;
}
},
orderedContent: function (fieldSpec) {
return this.makeContentModelParser(fieldSpec, true);
},
unorderedContent: function (fieldSpec) {
return this.makeContentModelParser(fieldSpec, false);
},
string: function (fieldSpec) {
return this.makeSimpleValueParser();
},
enumType: function (fieldSpec) {
var parser = this.makeSimpleValueParser();
if (fieldSpec.bare) {
parser.matchValue = function (myParseState, textLines) {
var parser = this;
var firstMatch = _.chain(fieldSpec.enumValues)
.map(function (enumValue) {
logger.debug('Attempting to parse as enum property $$$', enumValue);
var pattern = '^(.*?)(' + enumValue + ')(?:[\\s.]+|$)';
var re = new RegExp(pattern, parser.caseSensitive ? '' : 'i');
return textLines[0].match(re);
})
.compact()
.sortBy(function (match) {
return match[1].length;
})
.first()
.value();
if (firstMatch) {
logger.debug('Finished trying to parse as enum property, match: $$$', firstMatch);
myParseState.text = firstMatch[2];
myParseState.forPrevious = firstMatch[1];
textLines[0] = textLines[0].slice(firstMatch.index + firstMatch[0].length);
if (!textLines[0]) {
textLines.shift();
}
return true;
}
return false;
};
}
return parser;
},
number: function (fieldSpec) {
var parser = this.makeSimpleValueParser();
parser.typeConvert = function (textValue) {
var parts = textValue.split('/');
var intVal;
if (parts.length > 1) {
intVal = parts[0] / parts[1];
}
else {
intVal = parseInt(textValue);
}
if (_.isNaN(intVal)) {
throw new BadValueError(fieldSpec.name, textValue, '[Integer]');
}
return intVal;
};
return parser;
},
ability: function (fieldSpec) {
var parser = this.number();
parser.matchValue = function (parseState, textLines) {
if (_.isEmpty(textLines)) {
return false;
}
var re = new RegExp('^([\\sa-z\\(\\)]*)(\\d+(?:\\s?\\([\\-+\\d]+\\))?)', 'i');
logger.debug('Attempting to match value [$$$] against regexp $$$', textLines[0].trim(), re.toString());
var match = textLines[0].trim().match(re);
if (match) {
logger.debug('Successful match $$$', match);
parseState.text = match[2];
textLines[0] = match[1] + textLines[0].slice(match.index + match[0].length);
if (!textLines[0]) {
textLines.shift();
}
return true;
}
return false;
};
return parser;
},
heading: function (fieldSpec) {
fieldSpec.bare = true;
var parser = this.makeSimpleValueParser();
parser.skipOutput = true;
return parser;
},
makeSimpleValueParser: function () {
var module = this;
return {
parse: function (stateManager, textLines) {
var parseState = stateManager.enterChildParser(this);
var match = this.matchParseToken(parseState, textLines) &&
this.matchValue(parseState, textLines);
if (match) {
stateManager.completeCurrentStack(parseState.forPrevious);
delete parseState.forPrevious;
stateManager.leaveChildParser(this, parseState);
}
else {
stateManager.leaveChildParser(this);
}
return match;
},
complete: function (parseState, finalText) {
parseState.text += finalText ? finalText : '';
if (parseState.text) {
parseState.value = this.extractValue(parseState.text);
parseState.value = this.typeConvert(parseState.value);
parseState.setOutputValue();
}
},
extractValue: function (text) {
text = text.trim();
if (this.pattern && !this.bare) {
var regExp = new RegExp(this.pattern, this.caseSensitive ? '' : 'i');
var match = text.match(regExp);
if (match) {
var matchGroup = this.matchGroup || 0;
return match[matchGroup];
}
else {
throw new BadValueError(this.name, text, regExp);
}
}
else {
return text;
}
},
typeConvert: function (textValue) {
return textValue;
},
resumeParse: function (stateManager, textLines) {
if (_.isEmpty(textLines)) {
return false;
}
var parseState = stateManager.enterChildParser(this, true);
parseState.text += textLines.shift() + '\n';
stateManager.leaveChildParser(this, parseState);
return true;
},
matchParseToken: module.matchParseToken,
matchValue: module.matchValue
};
},
makeBaseParseState: function (skipOutput, propertyPath, outputObject, completedObjects) {
return {
text: '',
getObjectValue: function () {
var value = outputObject;
var segments = _.clone(propertyPath);
while (segments.length) {
var prop = segments.shift();
if (prop.flatten) {
continue;
}
value = value[prop.name];
if (_.isArray(value)) {
value = _.last(value);
}
}
return value;
},
setOutputValue: function () {
if (skipOutput) {
return;
}
var outputTo = outputObject;
var segments = _.clone(propertyPath);
while (segments.length > 0) {
var prop = segments.shift();
if (prop.flatten) {
continue;
}
var currentValue = outputTo[prop.name];
var newValue = segments.length === 0 ? this.value : {};
if (_.isUndefined(currentValue) && prop.allowed > 1) {
currentValue = [];
outputTo[prop.name] = currentValue;
}
if (_.isArray(currentValue)) {
var arrayItem = _.find(currentValue, _.partial(_.negate(_.contains), completedObjects));
if (!arrayItem) {
currentValue.push(newValue);
arrayItem = _.last(currentValue);
}
newValue = arrayItem;
}
else if (_.isUndefined(currentValue)) {
outputTo[prop.name] = newValue;
}
else if (segments.length === 0) {
throw new Error('Simple value property somehow already had value when we came to set it');
}
else {
newValue = currentValue;
}
outputTo = newValue;
}
},
logWrap: 'parseState[' + _.pluck(propertyPath, 'name').join('/') + ']',
toJSON: function () {
return _.extend(_.clone(this), { propertyPath: propertyPath });
}
};
},
makeParseStateManager: function () {
var incompleteParserStack = [];
var currentPropertyPath = [];
var completedObjects = [];
var module = this;
return {
outputObject: {},
leaveChildParser: function (parser, state) {
currentPropertyPath.pop();
if (state) {
state.resumeParser = _.isEmpty(incompleteParserStack) ? null : _.last(incompleteParserStack).parser;
incompleteParserStack.push({ parser: parser, state: state });
}
},
completeCurrentStack: function (finalText) {
while (!_.isEmpty(incompleteParserStack)) {
var incomplete = incompleteParserStack.shift();
incomplete.parser.complete(incomplete.state, finalText);
var value = incomplete.state.getObjectValue();
if (_.isObject(value) && !incomplete.parser.flatten) {
//Crude but this list is unlikely to get that big
completedObjects.push(value);
}
}
},
enterChildParser: function (parser, resume) {
currentPropertyPath.push({
name: parser.name,
allowed: parser.allowed,
flatten: parser.flatten
});
if (!resume || _.isEmpty(incompleteParserStack) || parser !== _.last(incompleteParserStack).parser) {
return module.makeBaseParseState(parser.skipOutput, _.clone(currentPropertyPath), this.outputObject, completedObjects);
}
return incompleteParserStack.pop().state;
},
logWrap: 'parserState',
toJSON: function () {
return _.extend(_.clone(this), {
incompleteParsers: incompleteParserStack,
propertyPath: currentPropertyPath
});
}
};
},
parserId: 0,
parserAttributes: [
'forPreviousMatchGroup', 'forNextMatchGroup',
'parseToken', 'flatten', 'pattern', 'matchGroup', 'bare', 'caseSensitive',
'name', 'skipOutput'
],
getParserFor: function (fieldSpec) {
logger.debug('Making parser for field $$$', fieldSpec);
var parserBuilder = this[fieldSpec.type];
if (!parserBuilder) {
throw new Error('Can\'t make parser for type ' + fieldSpec.type);
}
var parser = parserBuilder.call(this, fieldSpec);
parser.required = _.isUndefined(fieldSpec.minOccurs) ? 1 : fieldSpec.minOccurs;
parser.allowed = _.isUndefined(fieldSpec.maxOccurs) ? 1 : fieldSpec.maxOccurs;
_.extend(parser, _.pick(fieldSpec, this.parserAttributes));
_.defaults(parser, {
parseToken: parser.name
});
parser.id = this.parserId++;
parser.logWrap = 'parser[' + parser.name + ']';
return parser;
},
makeParserList: function (contentModelArray) {
var module = this;
return _.chain(contentModelArray)
.reject('noParse')
.reduce(function (parsers, fieldSpec) {
parsers.push(module.getParserFor(fieldSpec));
return parsers;
}, [])
.value();
},
logWrap: 'parseModule'
};
logger.wrapModule(parserModule);
var parser = parserModule.getParserFor(formatSpec);
return {
parse: function (text) {
logger.debug('Text: $$$', text);
var textLines = _.chain(text.split('\n'))
.invoke('trim')
.compact()
.value();
logger.debug(parser);
var stateManager = parserModule.makeParseStateManager();
var success = parser.parse(stateManager, textLines);
while (success && !_.isEmpty(textLines)) {
parser.resumeParse(stateManager, textLines);
}
stateManager.completeCurrentStack(textLines.join('\n'));
if (success && textLines.length === 0) {
stateManager.outputObject.version = formatSpec.formatVersion;
logger.info(stateManager.outputObject);
return stateManager.outputObject;
}
return null;
}
};
}
/**
* @constructor
*/
function ParserError(message) {
'use strict';
//noinspection JSUnusedGlobalSymbols
this.message = message;
}
ParserError.prototype = new Error();
/**
* @constructor
*/
function MissingContentError(missingFieldParsers) {
'use strict';
this.missingFieldParsers = missingFieldParsers;
//noinspection JSUnusedGlobalSymbols
this.message = _.reduce(this.missingFieldParsers, function (memo, parser) {
return memo + '
Field ' + parser.parseToken + ' should have appeared ' + parser.required + ' more times
';
}, '
') + '
';
}
MissingContentError.prototype = new ParserError();
/**
* @constructor
*/
function BadValueError(name, value, pattern) {
'use strict';
this.name = name;
this.value = value;
this.pattern = pattern;
//noinspection JSUnusedGlobalSymbols
this.message = 'Bad value [' + this.value + '] for field [' + this.name + ']. Should have matched pattern: ' +
this.pattern;
}
BadValueError.prototype = new ParserError();
module.exports = {
getParser: getParser,
MissingContentError: MissingContentError,
BadValueError: BadValueError,
ParserError: ParserError
};
/***/ },
/* 4 */
/***/ function(module, exports) {
module.exports = {
"formatVersion": "0.2",
"name": "monsters",
"maxOccurs": "Infinity",
"type": "orderedContent",
"bare": true,
"contentModel": [
{
"name": "coreInfo",
"type": "orderedContent",
"flatten": true,
"contentModel": [
{
"name": "name",
"type": "string",
"bare": "true"
},
{
"name": "size",
"enumValues": [
"Tiny",
"Small",
"Medium",
"Large",
"Huge",
"Gargantuan"
],
"type": "enumType",
"bare": "true"
},
{
"name": "type",
"type": "string",
"bare": "true",
"pattern": "^([\\w\\s\\(\\),-]+),",
"matchGroup": 1
},
{
"name": "alignment",
"type": "enumType",
"enumValues": [
"lawful good",
"lawful neutral",
"lawful evil",
"neutral good",
"neutral evil",
"neutral",
"chaotic good",
"chaotic neutral",
"chaotic evil",
"unaligned",
"any alignment",
"any good alignment",
"any non-good alignment",
"any evil alignment",
"any non-evil alignment",
"any lawful alignment",
"any non-lawful alignment",
"any chaotic alignment",
"any non-chaotic alignment",
"construct",
"(?:lawful|neutral|chaotic) (?:good|neutral|evil) \\(\\d+%\\) or (?:lawful|neutral|chaotic) (?:good|neutral|evil) \\(\\d+%\\)"
],
"bare": true
}
]
},
{
"name": "attributes",
"type": "unorderedContent",
"flatten": true,
"contentModel": [
{
"name": "AC",
"parseToken": "armor class",
"pattern": "\\d+\\s*(?:\\([^)]*\\))?",
"type": "string"
},
{
"name": "HP",
"parseToken": "hit points",
"type": "string",
"pattern": "\\d+(?:\\s?\\(\\s?\\d+d\\d+(?:\\s?[-+]\\s?\\d+)?\\s?\\))?"
},
{
"name": "speed",
"minOccurs": 0,
"type": "string",
"pattern": "^\\d+\\s?ft[\\.]?(,\\s?(fly|swim|burrow|climb)\\s\\d+\\s?ft[\\.]?)*(\\s?\\([^\\)]+\\))?$"
},
{
"name": "strength",
"parseToken": "str",
"type": "ability"
},
{
"name": "dexterity",
"parseToken": "dex",
"type": "ability"
},
{
"name": "constitution",
"parseToken": "con",
"type": "ability"
},
{
"name": "intelligence",
"parseToken": "int",
"type": "ability"
},
{
"name": "wisdom",
"parseToken": "wis",
"type": "ability"
},
{
"name": "charisma",
"parseToken": "cha",
"type": "ability"
},
{
"name": "savingThrows",
"minOccurs": 0,
"parseToken": "saving throws",
"type": "string",
"pattern": "(?:(?:^|,\\s*)(?:Str|Dex|Con|Int|Wis|Cha)\\s+[\\-\\+]\\d+)+"
},
{
"name": "skills",
"minOccurs": 0,
"type": "string",
"pattern": "(?:(?:^|,\\s*)(?:Acrobatics|Animal Handling|Arcana|Athletics|Deception|History|Insight|Intimidation|Investigation|Medicine|Nature|Perception|Performance|Persuasion|Religion|Sleight of Hand|Stealth|Survival)\\s+[\\-\\+]\\d+)+"
},
{
"minOccurs": 0,
"type": "string",
"name": "damageVulnerabilities",
"parseToken": "damage vulnerabilities"
},
{
"minOccurs": 0,
"type": "string",
"name": "damageResistances",
"parseToken": "damage resistances"
},
{
"minOccurs": 0,
"type": "string",
"name": "damageImmunities",
"parseToken": "damage immunities"
},
{
"minOccurs": 0,
"type": "string",
"name": "conditionImmunities",
"parseToken": "condition immunities"
},
{
"name": "senses",
"type": "string",
"minOccurs": 0,
"pattern": "(?:(?:^|,\\s*)(?:blindsight|darkvision|tremorsense|truesight)\\s+\\d+\\s*ft\\.?(?: or \\d+ ft\\. while deafened)?(?:\\s?\\([^\\)]+\\))?)+"
},
{
"name": "passivePerception",
"parseToken": ",?\\s*passive Perception",
"minOccurs": 0,
"type": "number",
"skipOutput": true
},
{
"name": "spells",
"minOccurs": 0,
"type": "string"
},
{
"name": "languages",
"minOccurs": 0,
"type": "string"
}
]
},
{
"name": "challenge",
"type": "string",
"pattern": "^\\s*(\\d+(?:\\s*\\/\\s*\\d)?)\\s*(?:\\(\\s*[\\d,]+\\s*XP\\s*\\)\\s*)?$",
"matchGroup": 1
},
{
"name": "traitSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "traits",
"type": "orderedContent",
"minOccurs": 1,
"maxOccurs": "Infinity",
"contentModel": [
{
"name": "name",
"type": "string",
"pattern": "(^|.*?[a-z]\\.\\s?)((?:[A-Z][\\w\\-']+[,:!]?|A)(?:\\s(?:[A-Z][\\w\\-']+[,:!]?|of|to|in|the|with|and|or|a)+)*)(\\s?\\([^\\)]+\\))?\\.(?!$)",
"matchGroup": 2,
"forPreviousMatchGroup": 1,
"forNextMatchGroup": 3,
"bare": true,
"caseSensitive": true
},
{
"name": "recharge",
"type": "string",
"pattern": "^\\(([^\\)]+)\\)",
"bare": true,
"matchGroup": 1,
"minOccurs": 0
},
{
"name": "text",
"bare": true,
"type": "string"
}
]
}
]
},
{
"name": "actionSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "actionHeader",
"type": "heading",
"bare": true,
"pattern": "^Actions$"
},
{
"name": "actions",
"type": "orderedContent",
"minOccurs": 1,
"maxOccurs": "Infinity",
"contentModel": [
{
"name": "name",
"type": "string",
"pattern": "(^|.*?[a-z]\\.\\s?)((?:\\d+\\.\\s?)?(?:[A-Z][\\w\\-']+[,:!]?|A)(?:\\s(?:[A-Z][\\w\\-']+[,:!]?|of|in|to|with|the|and|or|a|\\+\\d+)+)*)(\\s?\\([^\\)]+\\))?\\.(?!$)",
"matchGroup": 2,
"forPreviousMatchGroup": 1,
"forNextMatchGroup": 3,
"bare": true,
"caseSensitive": true
},
{
"name": "recharge",
"type": "string",
"bare": true,
"pattern": "^\\(([^\\)]+)\\)",
"matchGroup": 1,
"minOccurs": 0
},
{
"name": "text",
"bare": true,
"type": "string"
}
]
}
]
},
{
"name": "reactionSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "reactionHeader",
"type": "heading",
"bare": true,
"pattern": "^Reactions$"
},
{
"name": "reactions",
"type": "orderedContent",
"minOccurs": 1,
"maxOccurs": "Infinity",
"contentModel": [
{
"name": "name",
"type": "string",
"pattern": "(^|.*?[a-z]\\.\\s?)((?:[A-Z][\\w\\-']+[,:!]?|A)(?:\\s(?:[A-Z][\\w\\-']+[,:!]?|of|in|to|with|the|and|or|a)+)*)(\\s?\\([^\\)]+\\))?\\.(?!$)",
"matchGroup": 2,
"forPreviousMatchGroup": 1,
"forNextMatchGroup": 3,
"bare": true,
"caseSensitive": true
},
{
"name": "recharge",
"type": "string",
"bare": true,
"pattern": "^\\(([^\\)]+)\\)",
"matchGroup": 1,
"minOccurs": 0
},
{
"name": "text",
"bare": true,
"type": "string"
}
]
}
]
},
{
"name": "legendaryActionSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "actionHeader",
"type": "heading",
"bare": true,
"pattern": "^Legendary Actions$"
},
{
"name": "legendaryPoints",
"type": "number",
"bare": true,
"pattern": "^The[ \\w]+can take (\\d+) legendary actions.*?start of its turn[.]?",
"matchGroup": 1
},
{
"name": "legendaryActions",
"type": "orderedContent",
"minOccurs": 1,
"maxOccurs": "Infinity",
"contentModel": [
{
"name": "name",
"type": "string",
"bare": true,
"pattern": "(^|.*?[a-z]\\.\\s?)((?:[A-Z][\\w\\-']+[,:!]?|A)(?:\\s(?:[A-Z][\\w\\-']+[,:!]?|of|with|to|the|and|or|a)+)*)(\\s?\\([^\\)]+\\))?\\.(?!$)",
"matchGroup": 2,
"forPreviousMatchGroup": 1,
"forNextMatchGroup": 3,
"caseSensitive": true
},
{
"name": "cost",
"type": "number",
"bare": true,
"pattern": "^\\s*\\(\\s*costs (\\d+) actions\\s*\\)",
"matchGroup": 1,
"minOccurs": 0
},
{
"name": "text",
"bare": true,
"type": "string"
}
]
}
]
},
{
"name": "lairActionSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "actionHeader",
"type": "heading",
"bare": true,
"pattern": "^Lair Actions$"
},
{
"name": "lairActions",
"type": "string",
"bare": true,
"minOccurs": 1,
"maxOccurs": "Infinity"
}
]
},
{
"name": "regionalEffectsSection",
"type": "orderedContent",
"minOccurs": 0,
"maxOccurs": 1,
"flatten": true,
"contentModel": [
{
"name": "actionHeader",
"type": "heading",
"bare": true,
"pattern": "^Regional Effects$"
},
{
"name": "regionalEffects",
"type": "string",
"minOccurs": 1,
"maxOccurs": "Infinity",
"bare": true
},
{
"name": "regionalEffectsFade",
"type": "string",
"bare": true
}
]
}
]
};
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
var _ = __webpack_require__(2);
var roll20 = __webpack_require__(1);
/**
*
* @param config
* @returns {{debug:function, error:function, info:function, trace:function, warn:function}}
*/
module.exports = function (config) {
'use strict';
var logger = {
OFF: 0,
ERROR: 1,
WARN: 2,
INFO: 3,
DEBUG: 4,
TRACE: 5,
prefixString: ''
},
stringify = function (object) {
if (object === undefined) {
return object;
}
return typeof object === 'string' ? object : JSON.stringify(object, function (key, value) {
if (key !== 'logWrap' && key !== 'isLogWrapped') {
return value;
}
});
},
shouldLog = function (level) {
var logLevel = logger.INFO;
if (config && config.logLevel) {
logLevel = logger[config.logLevel];
}
return level <= logLevel;
},
outputLog = function (level, message) {
if (!shouldLog(level)) {
return;
}
var args = arguments.length > 2 ? _.toArray(arguments).slice(2) : [];
message = stringify(message);
if (message) {
message = message.replace(/\$\$\$/g, function () {
return stringify(args.shift());
});
}
//noinspection NodeModulesDependencies
roll20.log('ShapedScripts ' + Date.now() + ' ' + logger.getLabel(level) + ' : ' +
(shouldLog(logger.TRACE) ? logger.prefixString : '') +
message);
};
logger.getLabel = function (logLevel) {
var logPair = _.chain(logger).pairs().find(function (pair) {
return pair[1] === logLevel;
}).value();
return logPair ? logPair[0] : 'UNKNOWN';
};
_.each(logger, function (level, levelName) {
logger[levelName.toLowerCase()] = _.partial(outputLog, level);
});
logger.wrapModule = function (modToWrap) {
if (shouldLog(logger.TRACE)) {
_.chain(modToWrap)
.functions()
.each(function (funcName) {
var origFunc = modToWrap[funcName];
modToWrap[funcName] = logger.wrapFunction(funcName, origFunc, modToWrap.logWrap);
});
modToWrap.isLogWrapped = true;
}
};
logger.getLogTap = function (level, messageString) {
return _.partial(outputLog, level, messageString);
};
logger.wrapFunction = function (name, func, moduleName) {
if (shouldLog(logger.TRACE)) {
if (name === 'toJSON' || moduleName === 'roll20' && name === 'log') {
return func;
}
return function () {
logger.trace('$$$.$$$ starting with this value: $$$ and args $$$', moduleName, name, this, arguments);
logger.prefixString = logger.prefixString + ' ';
var retVal = func.apply(this, arguments);
logger.prefixString = logger.prefixString.slice(0, -2);
logger.trace('$$$.$$$ ending with return value $$$', moduleName, name, retVal);
if (retVal && retVal.logWrap && !retVal.isLogWrapped) {
logger.wrapModule(retVal);
}
return retVal;
};
}
return func;
};
//noinspection JSValidateTypes
return logger;
};
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _ = __webpack_require__(2);
var utils = __webpack_require__(7);
module.exports = EntityLookup;
function EntityLookup() {
var entities = {},
noWhiteSpaceEntities = {},
entityProcessors = {},
versionCheckers = {},
self = this;
this.configureEntity = function (entityName, processors, versionChecker) {
entities[entityName] = {};
noWhiteSpaceEntities[entityName] = {};
entityProcessors[entityName] = processors;
versionCheckers[entityName] = versionChecker;
};
this.addEntities = function (entitiesObject) {
var results = {
errors: []
};
_.chain(entitiesObject)
.omit('version', 'patch')
.each(function (entityArray, type) {
results[type] = {
withErrors: [],
skipped: [],
deleted: [],
patched: [],
added: []
};
if (!entities[type]) {
results.errors.push({ entity: 'general', errors: ['Unrecognised entity type ' + type] });
return;
}
if (!versionCheckers[type](entitiesObject.version, results.errors)) {
return;
}
_.each(entityArray, function (entity) {
var key = entity.name.toLowerCase();
var operation = !!entities[type][key] ? (entitiesObject.patch ? 'patched' : 'skipped') : 'added';
if (operation === 'patched') {
entity = patchEntity(entities[type][key], entity);
if (!entity) {
operation = 'deleted';
delete entities[type][key];
delete noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
}
}
if (_.contains(['patched', 'added'], operation)) {
var processed = _.reduce(entityProcessors[type], utils.executor, {
entity: entity,
type: type,
version: entitiesObject.version,
errors: []
});
if (!_.isEmpty(processed.errors)) {
processed.entity = processed.entity.name;
results.errors.push(processed);
operation = 'withErrors';
}
else {
if (processed.entity.name.toLowerCase() !== key) {
results[type].deleted.push(key);
delete entities[type][key];
delete noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
key = processed.entity.name.toLowerCase();
}
entities[type][key] = processed.entity;
noWhiteSpaceEntities[type][key.replace(/\s+/g, '')] = processed.entity;
}
}
results[type][operation].push(key);
});
});
return results;
};
this.findEntity = function (type, name, tryWithoutWhitespace) {
var key = name.toLowerCase();
if (!entities[type]) {
throw new Error('Unrecognised entity type ' + type);
}
var found = entities[type][key];
if (!found && tryWithoutWhitespace) {
found = noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
}
return found && utils.deepClone(found);
};
this.getAll = function (type) {
if (!entities[type]) {
throw new Error('Unrecognised entity type: ' + type);
}
return utils.deepClone(_.values(entities[type]));
};
/**
* Gets all of the keys for the specified entity type
* @param {string} type - The entity type to retrieve keys for (either 'monster' or 'spell')
* @param {boolean} sort - True if the returned array should be sorted alphabetically; false otherwise
* @function
* @public
* @name EntityLookup#getKeys
* @return {Array} An array containing all keys for the specified entity type
*/
this.getKeys = function (type, sort) {
if (!entities[type]) {
throw new Error('Unrecognised entity type: ' + type);
}
var keys = _.keys(entities[type]);
if (sort) {
keys.sort();
}
return keys;
};
/**
* Gets spell hydrator
* @function
* @public
* @name EntityLookup#getSpellHydrator
* @return {function}
*/
this.getSpellHydrator = function () {
return function (monsterInfo) {
var monster = monsterInfo.entity;
if (monster.spells) {
monster.spells = _.map(monster.spells.split(', '), function (spellName) {
return self.findEntity('spells', spellName) || spellName;
});
}
return monsterInfo;
};
};
this.getMonsterSpellUpdater = function () {
return function (spellInfo) {
var spell = spellInfo.entity;
_.chain(entities.monsters)
.pluck('spells')
.compact()
.each(function (spellArray) {
var spellIndex = _.findIndex(spellArray, function (monsterSpell) {
if (typeof monsterSpell === 'string') {
return monsterSpell.toLowerCase() === spell.name.toLowerCase();
}
else {
return monsterSpell !== spell && monsterSpell.name.toLowerCase() === spell.name.toLowerCase();
}
});
if (spellIndex !== -1) {
spellArray[spellIndex] = spell;
}
});
return spellInfo;
};
};
this.toJSON = function () {
return { monsterCount: _.size(entities.monsters), spellCount: _.size(entities.spells) };
};
}
EntityLookup.prototype.logWrap = 'entityLookup';
EntityLookup.jsonValidatorAsEntityProcessor = function (jsonValidator) {
return function (entityInfo) {
var wrapper = {
version: entityInfo.version
};
wrapper[entityInfo.type] = [entityInfo.entity];
var errors = jsonValidator.validate(wrapper);
var flattenedErrors = _.chain(errors).values().flatten().value();
entityInfo.errors = entityInfo.errors.concat(flattenedErrors);
return entityInfo;
};
};
EntityLookup.jsonValidatorAsVersionChecker = function (jsonValidator) {
return EntityLookup.getVersionChecker(jsonValidator.getVersionNumber());
};
EntityLookup.getVersionChecker = function (requiredVersion) {
return function (version, errorsArray) {
var valid = version === requiredVersion;
if (!valid) {
errorsArray.push({
entity: 'general',
errors: ['Incorrect entity objects version: [' + version + ']. Required is: ' + requiredVersion]
});
}
return valid;
};
};
function patchEntity(original, patch) {
if (patch.remove) {
return undefined;
}
return _.mapObject(original, function (propVal, propName) {
if (propName === 'name' && patch.newName) {
return patch.newName;
}
return patch[propName] || propVal;
});
}
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _ = __webpack_require__(2);
//noinspection JSUnusedGlobalSymbols
module.exports = {
deepExtend: function (original, newValues) {
var self = this;
if (!original) {
original = _.isArray(newValues) ? [] : {};
}
_.each(newValues, function (value, key) {
if (_.isArray(original[key])) {
if (!_.isArray(value)) {
original[key].push(value);
}
else {
original[key] = _.map(value, function (item, index) {
if (_.isObject(item)) {
return self.deepExtend(original[key][index], item);
}
else {
return item !== undefined ? item : original[key][index];
}
});
}
}
else if (_.isObject(original[key])) {
original[key] = self.deepExtend(original[key], value);
}
else {
original[key] = value;
}
});
return original;
},
createObjectFromPath: function (pathString, value) {
var newObject = {};
_.reduce(pathString.split(/\./), function (object, pathPart, index, pathParts) {
var match = pathPart.match(/([^.\[]*)(?:\[(\d+)\])?/);
var newVal = index === pathParts.length - 1 ? value : {};
if (match[2]) {
object[match[1]] = [];
object[match[1]][match[2]] = newVal;
}
else {
object[match[1]] = newVal;
}
return newVal;
}, newObject);
return newObject;
},
getObjectFromPath: function (obj, path) {
path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
path = path.replace(/^\./, ''); // strip a leading dot
var a = path.split('.');
for (var i = 0, n = a.length; i < n; ++i) {
var k = a[i];
if (k in obj) {
obj = obj[k];
}
else {
return;
}
}
return obj;
},
deepClone: function (object) {
return JSON.parse(JSON.stringify(object));
},
executor: function () {
switch (arguments.length) {
case 0:
return;
case 1:
return arguments[0]();
default:
var args = Array.apply(null, arguments).slice(2);
args.unshift(arguments[0]);
return arguments[1].apply(null, args);
}
},
/**
* Gets a string as 'Title Case' capitalizing the first letter of each word (i.e. 'the grapes of wrath' -> 'The Grapes Of Wrath')
* @param {string} s - The string to be converted
* @return {string} the supplied string in title case
*/
toTitleCase: function (s) {
return s.replace(/\w\S*/g, function (txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});
},
/**
* Calculates a contrasting color using YIQ luma value
* @param {string} hexcolor - the color to calculate a contrasting color for
* @return {string} either 'white' or 'black' as determined to be the best contrasting text color for the input color
*/
getContrastYIQ: function (hexcolor) {
hexcolor = hexcolor.replace('#', '');
if (hexcolor.length === 3) {
hexcolor += hexcolor;
}
var r = parseInt(hexcolor.substr(0, 2), 16);
var g = parseInt(hexcolor.substr(2, 2), 16);
var b = parseInt(hexcolor.substr(4, 2), 16);
var yiq = (r * 299 + g * 587 + b * 114) / 1000;
return yiq >= 128 ? 'black' : 'white';
},
/**
* Builds an html element as a string using the specified options
* @param {string} tag - the html tag type
* @param innerHtml - can be a string to be used as the element inner html, or a {tag, innerHtml, attrs} object
* in order to build a child html element string
* @param attrs - a collection of attributes and their values to be applied to the html element
* @return {string} the full html element as a string
*/
buildHTML: function (tag, innerHtml, attrs) {
var self = this;
if (typeof innerHtml === 'object') {
var res = '';
_.each(innerHtml, function (html) {
if (!_.isUndefined(html)) {
res += '' + self.buildHTML(html.tag, html.innerHtml, html.attrs);
}
});
innerHtml = res;
}
var h = '<' + tag;
for (var attr in attrs) {
if (attrs.hasOwnProperty(attr)) {
if (attrs[attr] === false) {
continue;
}
h += ' ' + attr + '="' + attrs[attr] + '"';
}
}
h += innerHtml ? '>' + innerHtml + '' : '/>';
return h;
},
versionCompare: function (v1, v2) {
if (v1 === v2) {
return 0;
}
else if (v1 === undefined || v1 === null) {
return -1;
}
else if (v2 === undefined || v2 === null) {
return 1;
}
var v1parts = v1.split('.');
var v2parts = v2.split('.');
var isValidPart = function (x) {
return /^\d+$/.test(x);
};
if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {
return NaN;
}
v1parts = _.map(v1parts, Number);
v2parts = _.map(v2parts, Number);
for (var i = 0; i < v1parts.length; ++i) {
if (v2parts.length === i) {
return 1;
}
if (v1parts[i] > v2parts[i]) {
return 1;
}
else if (v1parts[i] < v2parts[i]) {
return -1;
}
}
if (v1parts.length !== v2parts.length) {
return -1;
}
return 0;
}
};
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _ = __webpack_require__(2);
//noinspection JSUnusedGlobalSymbols
var validatorFactories = {
orderedContent: function (spec) {
return makeContentModelValidator(spec);
},
unorderedContent: function (spec) {
return makeContentModelValidator(spec);
},
string: function (spec) {
if (spec.pattern) {
if (spec.matchGroup) {
return regExValidator(spec.name, extractRegexPart(spec.pattern, spec.matchGroup), spec.caseSensitive);
}
else {
return regExValidator(spec.name, spec.pattern, spec.caseSensitive);
}
}
return function () {
};
},
enumType: function (spec) {
return function (value, errors) {
if (!_.some(spec.enumValues, function (enumVal) {
return new RegExp('^' + enumVal + '$', 'i').test(value);
})) {
errors.add('Value "' + value + '" should have been one of [' + spec.enumValues.join(',') + ']');
}
};
},
ability: function (spec) {
return regExValidator(spec.name, '\\d+');
},
heading: function (spec) {
return function () {
};
},
number: function (spec) {
return function (value, errors) {
if (typeof value !== 'number') {
errors.add('Value "' + value + '" should have been a number');
}
};
}
};
function extractRegexPart(regexp, matchIndex) {
var braceCount = 0;
var startIndex = _.findIndex(regexp, function (character, index) {
if (character === '(' &&
(index < 2 || regexp[index - 1] !== '\\') &&
regexp[index + 1] !== '?') {
return ++braceCount === matchIndex;
}
});
if (startIndex === -1) {
throw new Error('Can\'t find matchgroup ' + matchIndex + ' in regular expression ' + regexp);
}
//Lose the bracket
startIndex++;
var openCount = 1;
var endIndex = _.findIndex(regexp.slice(startIndex), function (character, index, regexp) {
if (character === '(' && regexp[index - 1] !== '\\') {
openCount++;
}
if (character === ')' && regexp[index - 1] !== '\\') {
return --openCount === 0;
}
});
if (endIndex === -1) {
throw new Error('matchgroup ' + matchIndex + ' seems not to have closing brace in regular expression ' + regexp);
}
return regexp.slice(startIndex, startIndex + endIndex);
}
function regExValidator(fieldName, regexp, caseSensitive) {
var re = new RegExp('^' + regexp + '$', caseSensitive ? undefined : 'i');
return function (value, errors) {
if (!re.test(value)) {
errors.add('Value "' + value + '" doesn\'t match pattern /' + regexp + '/');
}
};
}
function makeValidator(spec) {
var validator = validatorFactories[spec.type](spec);
validator.max = _.isUndefined(spec.maxOccurs) ? 1 : spec.maxOccurs;
validator.min = _.isUndefined(spec.minOccurs) ? 1 : spec.minOccurs;
validator.fieldName = spec.name;
return validator;
}
function makeContentModelValidator(spec) {
var parts = _.chain(spec.contentModel)
.reject({ type: 'heading' })
.partition({ flatten: true })
.value();
var flattened = _.map(parts[0], makeValidator);
var subValidators = _.reduce(parts[1], function (subValidators, field) {
subValidators[field.name] = makeValidator(field);
return subValidators;
}, {});
return function (object, errors, isFlatten) {
var completed = _.reduce(object, function (completed, fieldValue, fieldName) {
var validator = subValidators[fieldName];
if (validator) {
completed.push(fieldName);
errors.pushPath(fieldName);
if (_.isArray(fieldValue)) {
if (fieldValue.length > validator.max) {
errors.add('Number of entries [' + fieldValue.length + '] exceeds maximum allowed: ' + validator.max);
}
else if (fieldValue.length < validator.min) {
errors.add('Number of entries [' + fieldValue.length + '] is less than minimum allowed: ' + validator.min);
}
else {
_.each(fieldValue, function (arrayItem, index) {
errors.pushIndex(arrayItem.name ? arrayItem.name : index);
validator(arrayItem, errors);
errors.popIndex();
});
}
}
else {
validator(fieldValue, errors);
}
errors.popPath();
}
return completed;
}, []);
var toValidate = _.omit(object, completed);
_.chain(flattened)
.map(function (validator) {
var subCompleted = validator(toValidate, errors, true);
if (subCompleted.length === 0) {
return validator;
}
else {
completed = completed.concat(subCompleted);
}
toValidate = _.omit(toValidate, completed);
})
.compact()
.each(function (validator) {
if (validator.min > 0) {
errors.pushPath(validator.fieldName);
errors.add('Section is missing');
errors.popPath();
}
});
//If we're a flattened validator (our content is injected directly into the parent content model)
//Then we should only report missing fields if there was some match in our content model - otherwise
//the parent content model will check the cardinality of this model as a whole
if (!isFlatten || !_.isEmpty(completed)) {
_.chain(subValidators)
.omit(completed)
.each(function (validator) {
if (validator.min > 0) {
errors.pushPath(validator.fieldName);
errors.add('Field is missing');
errors.popPath();
}
});
}
//Flattened content models shouldn't check for unrecognised fields since they're only parsing
//part of the current content model.
if (!isFlatten) {
_.chain(object)
.omit(completed)
.each(function (value, key) {
errors.pushPath(key);
errors.add('Unrecognised field');
errors.popPath();
});
}
return completed;
};
}
function Errors() {
var errors = [];
var currentPath = [];
this.pushPath = function (path) {
currentPath.push(path);
};
this.popPath = function () {
currentPath.pop();
};
this.pushIndex = function (index) {
currentPath[currentPath.length - 1] = currentPath[currentPath.length - 1] + '[' + index + ']';
};
this.popIndex = function (index) {
currentPath[currentPath.length - 1] = currentPath[currentPath.length - 1].replace(/\[[^\]]+\]/, '');
};
this.add = function (msg) {
errors.push({ msg: msg, path: _.clone(currentPath) });
};
this.getErrors = function () {
return _.chain(errors)
.groupBy(function (error) {
return error.path[0];
})
.mapObject(function (errorList) {
return _.map(errorList, function (error) {
return error.path.slice(1).join('.') + ': ' + error.msg;
});
})
.value();
};
}
module.exports = JSONValidator;
function JSONValidator(spec) {
var versionProp = {
type: 'string',
name: 'version',
pattern: '^' + spec.formatVersion.replace('.', '\\.') + '$'
};
var contentValidator = makeValidator({ type: 'unorderedContent', contentModel: [spec, versionProp] });
this.validate = function (object) {
var errors = new Errors();
contentValidator(object, errors);
return errors.getErrors();
};
this.getVersionNumber = function () {
return spec.formatVersion;
};
}
/***/ },
/* 9 */
/***/ function(module, exports) {
'use strict';
function Reporter(roll20, scriptName) {
this.report = function (heading, text) {
//Horrible bug with this at the moment - seems to generate spurious chat
//messages when noarchive:true is set
//sendChat('ShapedScripts', '' + msg, null, {noarchive:true});
roll20.sendChat('',
'/w gm
' +
'
' +
scriptName + ' ' + heading +
'
' +
text +
'
');
};
this.reportError = function (text) {
roll20.sendChat('',
'/w gm
' +
'
' +
scriptName +
'
' +
text +
'
');
};
}
module.exports = Reporter;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
/* globals unescape */
'use strict';
var _ = __webpack_require__(2);
var srdConverter = __webpack_require__(11);
var parseModule = __webpack_require__(3);
var cp = __webpack_require__(12);
var utils = __webpack_require__(7);
var mpp = __webpack_require__(13);
var AdvantageTracker = __webpack_require__(14);
var ConfigUI = __webpack_require__(15);
var schemaVersion = 1.0,
configDefaults = {
logLevel: 'INFO',
tokenSettings: {
number: false,
bar1: {
attribute: 'HP',
max: true,
link: false,
showPlayers: false
},
bar2: {
attribute: 'speed',
max: false,
link: true,
showPlayers: false
},
bar3: {
attribute: '',
max: false,
link: false,
showPlayers: false
},
aura1: {
radius: '',
color: '#FFFF99',
square: false
},
aura2: {
radius: '',
color: '#59e594',
square: false
},
light: {
radius: '',
dimRadius: '',
otherPlayers: false,
hasSight: false,
angle: 360,
losAngle: 360,
multiplier: 1
},
showName: true,
showNameToPlayers: false,
showAura1ToPlayers: true,
showAura2ToPlayers: true
},
newCharSettings: {
sheetOutput: '@{output_to_all}',
deathSaveOutput: '@{output_to_all}',
initiativeOutput: '@{output_to_all}',
showNameOnRollTemplate: '@{show_character_name_yes}',
rollOptions: '@{normal}',
initiativeRoll: '@{normal_initiative}',
initiativeToTracker: '@{initiative_to_tracker_yes}',
breakInitiativeTies: '@{initiative_tie_breaker_var}',
showTargetAC: '@{attacks_vs_target_ac_no}',
showTargetName: '@{attacks_vs_target_name_no}',
autoAmmo: '@{ammo_auto_use_var}'
},
advTrackerSettings: {
showMarkers: false
},
rollHPOnDrop: true,
autoHD: true,
genderPronouns: [
{
matchPattern: '^f$|female|girl|woman|feminine',
nominative: 'she',
accusative: 'her',
possessive: 'her',
reflexive: 'herself'
},
{
matchPattern: '^m$|male|boy|man|masculine',
nominative: 'he',
accusative: 'him',
possessive: 'his',
reflexive: 'himself'
},
{
matchPattern: '^n$|neuter|none|construct|thing|object',
nominative: 'it',
accusative: 'it',
possessive: 'its',
reflexive: 'itself'
}
],
defaultGenderIndex: 2
};
var configToAttributeLookup = {
sheetOutput: 'output_option',
deathSaveOutput: 'death_save_output_option',
initiativeOutput: 'initiative_output_option',
showNameOnRollTemplate: 'show_character_name',
rollOptions: 'roll_setting',
initiativeRoll: 'initiative_roll',
initiativeToTracker: 'initiative_to_tracker',
breakInitiativeTies: 'initiative_tie_breaker',
showTargetAC: 'attacks_vs_target_ac',
showTargetName: 'attacks_vs_target_name',
autoAmmo: 'ammo_auto_use'
};
var booleanValidator = function (value) {
var converted = value === 'true' || (value === 'false' ? false : value);
return {
valid: typeof value === 'boolean' || value === 'true' || value === 'false',
converted: converted
};
},
stringValidator = function (value) {
return {
valid: true,
converted: value
};
},
getOptionList = function (options) {
return function (value) {
if (value === undefined) {
return options;
}
return {
converted: options[value],
valid: options[value] !== undefined
};
};
},
integerValidator = function (value) {
var parsed = parseInt(value);
return {
converted: parsed,
valid: !isNaN(parsed)
};
},
colorValidator = function (value) {
return {
converted: value,
valid: /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(value)
};
},
sheetOutputValidator = getOptionList({
public: '@{output_to_all}',
whisper: '@{output_to_gm}'
}),
barValidator = {
attribute: stringValidator,
max: booleanValidator,
link: booleanValidator,
showPlayers: booleanValidator
},
auraValidator = {
radius: stringValidator,
color: colorValidator,
square: booleanValidator
},
lightValidator = {
radius: stringValidator,
dimRadius: stringValidator,
otherPlayers: booleanValidator,
hasSight: booleanValidator,
angle: integerValidator,
losAngle: integerValidator,
multiplier: integerValidator
},
regExpValidator = function (value) {
try {
new RegExp(value, 'i').test('');
return {
converted: value,
valid: true
};
}
catch (e) {
}
return {
converted: null,
valid: false
};
};
/**
* @typedef {Object} ChatMessage
* @property {string} content
* @property {string} type
* @property {SelectedItem[]} selected
* @property {string} rolltemplate
*/
/**
*
* @typedef {Object} SelectedItem
* @property {string} _id
* @property (string _type
*/
module.exports = ShapedScripts;
function ShapedScripts(logger, myState, roll20, parser, entityLookup, reporter) {
var sanitise = logger.wrapFunction('sanitise', __webpack_require__(16), '');
var addedTokenIds = [];
var report = reporter.report.bind(reporter);
var reportError = reporter.reportError.bind(reporter);
var self = this;
var chatWatchers = [];
var at = new AdvantageTracker(logger, myState);
/**
*
* @param {ChatMessage} msg
*/
this.handleInput = function (msg) {
logger.debug(msg);
if (msg.type !== 'api') {
this.triggerChatWatchers(msg);
return;
}
this.getCommandProcessor().processCommand(msg);
};
var configOptionsSpec = {
logLevel: function (value) {
var converted = value.toUpperCase();
return { valid: _.has(logger, converted), converted: converted };
},
tokenSettings: {
number: booleanValidator,
bar1: barValidator,
bar2: barValidator,
bar3: barValidator,
aura1: auraValidator,
aura2: auraValidator,
light: lightValidator,
showName: booleanValidator,
showNameToPlayers: booleanValidator,
showAura1ToPlayers: booleanValidator,
showAura2ToPlayers: booleanValidator
},
newCharSettings: {
sheetOutput: sheetOutputValidator,
deathSaveOutput: sheetOutputValidator,
initiativeOutput: sheetOutputValidator,
showNameOnRollTemplate: getOptionList({
true: '@{show_character_name_yes}',
false: '@{show_character_name_no}'
}),
rollOptions: getOptionList({
normal: '@{roll_1}',
advantage: '@{roll_advantage}',
disadvantage: '@{roll_disadvantage}',
two: '@{roll_2}'
}),
initiativeRoll: getOptionList({
normal: '@{normal_initiative}',
advantage: '@{advantage_on_initiative}',
disadvantage: '@{disadvantage_on_initiative}'
}),
initiativeToTracker: getOptionList({
true: '@{initiative_to_tracker_yes}',
false: '@{initiative_to_tracker_no}'
}),
breakInitiativeTies: getOptionList({
true: '@{initiative_tie_breaker_var}',
false: ''
}),
showTargetAC: getOptionList({
true: '@{attacks_vs_target_ac_yes}',
false: '@{attacks_vs_target_ac_no}'
}),
showTargetName: getOptionList({
true: '@{attacks_vs_target_name_yes}',
false: '@{attacks_vs_target_name_no}'
}),
autoAmmo: getOptionList({
true: '@{ammo_auto_use_var}',
false: ''
})
},
advTrackerSettings: {
showMarkers: booleanValidator,
},
rollHPOnDrop: booleanValidator,
autoHD: booleanValidator,
genderPronouns: [
{
matchPattern: regExpValidator,
nominative: stringValidator,
accusative: stringValidator,
possessive: stringValidator,
reflexive: stringValidator
}
],
defaultGenderIndex: integerValidator
};
/////////////////////////////////////////
// Command handlers
/////////////////////////////////////////
this.configure = function (options) {
utils.deepExtend(myState.config, options);
var cui = new ConfigUI();
logger.debug('options: ' + options);
var menu;
if (options.advTrackerSettings || options.atMenu) {
menu = cui.getConfigOptionGroupAdvTracker(myState.config, configOptionsSpec);
}
else if (options.tokenSettings || options.tsMenu) {
menu = cui.getConfigOptionGroupTokens(myState.config, configOptionsSpec);
}
else if (options.newCharSettings || options.ncMenu) {
menu = cui.getConfigOptionGroupNewCharSettings(myState.config, configOptionsSpec);
}
else {
menu = cui.getConfigOptionsMenu();
}
report('Configuration', menu);
};
this.applyTokenDefaults = function (options) {
var self = this;
_.each(options.selected.graphic, function (token) {
var represents = token.get('represents');
var character = roll20.getObj('character', represents);
if (character) {
self.getTokenConfigurer(token)(character);
}
});
};
this.importStatblock = function (options) {
logger.info('Importing statblocks for tokens $$$', options.selected.graphic);
var self = this;
_.each(options.selected.graphic, function (token) {
var text = token.get('gmnotes');
if (text) {
text = sanitise(unescape(text), logger);
var monsters = parser.parse(text).monsters;
mpp(monsters, entityLookup);
self.importMonsters(monsters, options, token, [
function (character) {
character.set('gmnotes', text.replace(/\n/g, ' '));
}
]);
}
});
};
this.importMonstersFromJson = function (options) {
if (options.all) {
options.monsters = entityLookup.getAll('monsters');
delete options.all;
}
if (_.isEmpty(options.monsters)) {
this.showEntityPicker('monster', 'monsters');
}
else {
this.importMonsters(options.monsters.slice(0, 20), options, options.selected.graphic, []);
options.monsters = options.monsters.slice(20);
var self = this;
if (!_.isEmpty(options.monsters)) {
setTimeout(function () {
self.importMonstersFromJson(options);
}, 200);
}
}
};
this.importMonsters = function (monsters, options, token, characterProcessors) {
var characterRetrievalStrategies = [];
if (token) {
characterProcessors.push(this.getAvatarCopier(token).bind(this));
if (_.size(monsters) === 1) {
characterProcessors.push(this.getTokenConfigurer(token).bind(this));
if (options.replace || options.overwrite) {
characterRetrievalStrategies.push(this.getTokenRetrievalStrategy(token).bind(this));
}
}
}
if (options.replace) {
characterRetrievalStrategies.push(this.nameRetrievalStrategy);
}
characterRetrievalStrategies.push(this.creationRetrievalStrategy.bind(this));
characterProcessors.push(this.monsterDataPopulator.bind(this));
var errors = [];
var importedList = _.chain(monsters)
.map(function (monsterData) {
var character = _.reduce(characterRetrievalStrategies, function (result, strategy) {
return result || strategy(monsterData.name, errors);
}, null);
if (!character) {
logger.error('Failed to find or create character for monster $$$', monsterData.name);
return null;
}
var oldAttrs = roll20.findObjs({ type: 'attribute', characterid: character.id });
_.invoke(oldAttrs, 'remove');
character.set('name', monsterData.name);
_.each(characterProcessors, function (proc) {
proc(character, monsterData);
});
return character && character.get('name');
})
.compact()
.value();
if (!_.isEmpty(importedList)) {
var monsterList = importedList.join('
');
report('Import Success', 'Added the following monsters:
' + monsterList + '
');
}
if (!_.isEmpty(errors)) {
var errorList = errors.join('
');
reportError('The following errors occurred on import:
' + errorList + '
');
}
};
this.importSpellsFromJson = function (options) {
if (_.isEmpty(options.spells)) {
this.showEntityPicker('spell', 'spells');
}
else {
this.addSpellsToCharacter(options.selected.character, options.spells);
}
};
this.showEntityPicker = function (entityName, entityNamePlural) {
var list = entityLookup.getKeys(entityNamePlural, true);
if (!_.isEmpty(list)) {
// title case the names for better display
list.forEach(function (part, index) {
list[index] = utils.toTitleCase(part);
});
// create a clickable button with a roll query to select an entity from the loaded json
report(utils.toTitleCase(entityName) + ' Importer', 'Click to select a ' + entityName + '');
}
else {
reportError('Could not find any ' + entityNamePlural + '. Please ensure you have a properly formatted ' +
entityNamePlural + ' json file.');
}
};
this.addSpellsToCharacter = function (character, spells, noreport) {
var gender = roll20.getAttrByName(character.id, 'gender');
var defaultIndex = Math.min(myState.config.defaultGenderIndex, myState.config.genderPronouns.length);
var defaultPronounInfo = myState.config.genderPronouns[defaultIndex];
var pronounInfo = _.clone(_.find(myState.config.genderPronouns, function (pronounDetails) {
return new RegExp(pronounDetails.matchPattern, 'i').test(gender);
}) || defaultPronounInfo);
_.defaults(pronounInfo, defaultPronounInfo);
var importData = {
spells: srdConverter.convertSpells(spells, pronounInfo)
};
this.getImportDataWrapper(character).mergeImportData(importData);
if (!noreport) {
report('Import Success', 'Added the following spells:
' + _.map(importData.spells, function (spell) {
return spell.name;
}).join('
') + '
');
}
};
this.monsterDataPopulator = function (character, monsterData) {
_.each(myState.config.newCharSettings, function (value, key) {
var attribute = roll20.getOrCreateAttr(character.id, configToAttributeLookup[key]);
attribute.set('current', _.isBoolean(value) ? (value ? 1 : 0) : value);
});
var converted = srdConverter.convertMonster(monsterData);
logger.debug('Converted monster data: $$$', converted);
var expandedSpells = converted.spells;
delete converted.spells;
this.getImportDataWrapper(character).setNewImportData({ npc: converted });
if (expandedSpells) {
this.addSpellsToCharacter(character, expandedSpells, true);
}
return character;
};
this.getTokenRetrievalStrategy = function (token) {
return function (name, errors) {
if (token) {
var character = roll20.getObj('character', token.get('represents'));
if (character && roll20.getAttrByName(character.id, 'locked')) {
errors.push('Character with name ' + character.get('name') + ' and id ' + character.id +
' was locked and cannot be overwritten');
return null;
}
return character;
}
};
};
this.nameRetrievalStrategy = function (name, errors) {
var chars = roll20.findObjs({ type: 'character', name: name });
if (chars.length > 1) {
errors.push('More than one existing character found with name "' + name + '". Can\'t replace');
}
else {
if (chars[0] && roll20.getAttrByName(chars[0].id, 'locked')) {
errors.push('Character with name ' + chars[0].get('name') + ' and id ' + chars[0].id +
' was locked and cannot be overwritten');
return null;
}
return chars[0];
}
};
this.creationRetrievalStrategy = function (name, errors) {
if (!_.isEmpty(roll20.findObjs({ type: 'character', name: name }))) {
errors.push('Can\'t create new character with name "' + name +
'" because one already exists with that name. Perhaps you want --replace?');
}
else {
return roll20.createObj('character', { name: name });
}
};
this.getAvatarCopier = function (token) {
return function (character) {
character.set('avatar', token.get('imgsrc'));
};
};
this.getTokenConfigurer = function (token) {
return function (character) {
token.set('represents', character.id);
token.set('name', character.get('name'));
var settings = myState.config.tokenSettings;
if (settings.number && token.get('name').indexOf('%%NUMBERED%%') === -1) {
token.set('name', token.get('name') + ' %%NUMBERED%%');
}
_.chain(settings)
.pick(['bar1', 'bar2', 'bar3'])
.each(function (bar, barName) {
if (!_.isEmpty(bar.attribute)) {
var attribute = roll20.getOrCreateAttr(character.id, bar.attribute);
if (attribute) {
token.set(barName + '_value', attribute.get('current'));
if (bar.max) {
token.set(barName + '_max', attribute.get('max'));
}
token.set('showplayers_' + barName, bar.showPlayers);
if (bar.link) {
token.set(barName + '_link', attribute.id);
}
}
}
});
// auras
_.chain(settings)
.pick(['aura1', 'aura2'])
.each(function (aura, auraName) {
token.set(auraName + '_radius', aura.radius);
token.set(auraName + '_color', aura.color);
token.set(auraName + '_square', aura.square);
});
logger.debug('Settings for tokens: $$$', settings);
token.set('showname', settings.showName);
token.set('showplayers_name', settings.showNameToPlayers);
token.set('showplayers_aura1', settings.showAura1ToPlayers);
token.set('showplayers_aura2', settings.showAura2ToPlayers);
token.set('light_radius', settings.light.radius);
token.set('light_dimradius', settings.light.dimRadius);
token.set('light_otherplayers', settings.light.otherPlayers);
token.set('light_hassight', settings.light.hasSight);
token.set('light_angle', settings.light.angle);
token.set('light_losangle', settings.light.losAngle);
token.set('light_multiplier', settings.light.multiplier);
};
};
this.getImportDataWrapper = function (character) {
return {
setNewImportData: function (importData) {
if (_.isEmpty(importData)) {
return;
}
roll20.setAttrByName(character.id, 'import_data', JSON.stringify(importData));
roll20.setAttrByName(character.id, 'import_data_present', 'on');
},
mergeImportData: function (importData) {
if (_.isEmpty(importData)) {
return;
}
var attr = roll20.getOrCreateAttr(character.id, 'import_data');
var dataPresentAttr = roll20.getOrCreateAttr(character.id, 'import_data_present');
var current = {};
try {
if (!_.isEmpty(attr.get('current').trim())) {
current = JSON.parse(attr.get('current'));
}
}
catch (e) {
logger.warn('Existing import_data attribute value was not valid JSON: [$$$]', attr.get('current'));
}
_.each(importData, function (value, key) {
var currentVal = current[key];
if (currentVal) {
if (!_.isArray(currentVal)) {
current[key] = [currentVal];
}
current[key] = current[key].concat(value);
}
else {
current[key] = value;
}
});
logger.debug('Setting import data to $$$', current);
attr.set('current', JSON.stringify(current));
dataPresentAttr.set('current', 'on');
return current;
},
logWrap: 'importDataWrapper'
};
};
this.applyAdvantageTracker = function (options) {
var type = 'normal';
if (options.advantage) {
type = 'advantage';
}
else if (options.disadvantage) {
type = 'disadvantage';
}
at.setMarkers(type, at.buildResources(at.getSelectedCharacters(options.selected.character)));
//roll20.log('in AT listener');
//roll20.log(at.buildResources(at.getSelectedCharacters(options.selected.character)));
};
/////////////////////////////////////////////////
// Event Handlers
/////////////////////////////////////////////////
this.handleAddToken = function (token) {
var represents = token.get('represents');
if (_.isEmpty(represents)) {
return;
}
var character = roll20.getObj('character', represents);
if (!character) {
return;
}
addedTokenIds.push(token.id);
var wrappedChangeToken = this.wrapHandler(this.handleChangeToken);
//URGH. Thanks Roll20.
setTimeout((function (id) {
return function () {
var token = roll20.getObj('graphic', id);
if (token) {
wrappedChangeToken(token);
}
};
}(token.id)), 100);
};
this.handleChangeToken = function (token) {
at.updateToken(token);
if (_.contains(addedTokenIds, token.id)) {
addedTokenIds = _.without(addedTokenIds, token.id);
this.rollHPForToken(token);
}
};
this.getHPBar = function () {
return _.chain(myState.config.tokenSettings)
.pick('bar1', 'bar2', 'bar3')
.findKey({ attribute: 'HP' })
.value();
};
this.rollHPForToken = function (token) {
var hpBar = this.getHPBar();
logger.debug('HP bar is $$$', hpBar);
if (!hpBar || !myState.config.rollHPOnDrop) {
return;
}
var represents = token.get('represents');
if (!represents) {
return;
}
var character = roll20.getObj('character', represents);
if (!character) {
return;
}
var hpBarLink = token.get(hpBar + '_link');
if (hpBarLink) {
return;
}
// Guard against characters that aren't properly configured - i.e. ones used for templates and system
// things rather than actual characters
if (_.isEmpty(roll20.getAttrByName(character.id, 'hp_formula'))) {
logger.debug('Ignoring character $$$ for rolling HP - has no hp_formula attribute', character.get('name'));
return;
}
var self = this;
roll20.sendChat('', '%{' + character.get('name') + '|npc_hp}', function (results) {
if (results && results.length === 1) {
var message = self.processInlinerolls(results[0]);
if (!results[0].inlinerolls || !results[0].inlinerolls[0]) {
logger.warn('HP roll didn\'t have the expected structure. This is what we got back: $$$', results[0]);
}
else {
var total = results[0].inlinerolls[0].results.total;
roll20.sendChat('HP Roller', '/w GM &{template:5e-shaped} ' + message);
token.set(hpBar + '_value', total);
token.set(hpBar + '_max', total);
}
}
});
};
this.registerChatWatcher = function (handler, triggerFields) {
var matchers = [];
if (triggerFields && !_.isEmpty(triggerFields)) {
matchers.push(function (msg, options) {
return _.intersection(triggerFields, _.keys(options)).length === triggerFields.length;
});
}
chatWatchers.push({ matchers: matchers, handler: handler.bind(this) });
};
this.triggerChatWatchers = function (msg) {
var options = this.getRollTemplateOptions(msg);
_.each(chatWatchers, function (watcher) {
if (_.every(watcher.matchers, function (matcher) {
return matcher(msg, options);
})) {
watcher.handler(options, msg);
}
});
};
/**
*
* @param options
* @param {ChatMessage} msg
*/
this.handleAmmo = function (options, msg) {
if (!roll20.getAttrByName(options.character.id, 'ammo_auto_use')) {
return;
}
var ammoAttr = _.chain(roll20.findObjs({ type: 'attribute', characterid: options.character.id }))
.filter(function (attribute) {
return attribute.get('name').indexOf('repeating_ammo') === 0;
})
.groupBy(function (attribute) {
return attribute.get('name').replace(/(repeating_ammo_[^_]+).*/, '$1');
})
.find(function (attributes) {
return _.find(attributes, function (attribute) {
return attribute.get('name').match(/.*name$/) && attribute.get('current') === options.ammoName;
});
})
.find(function (attribute) {
return attribute.get('name').match(/.*qty$/);
})
.value();
if (!ammoAttr) {
logger.error('No ammo attribute found corresponding to name $$$', options.ammoName);
return;
}
var ammoUsed = 1;
if (options.ammo) {
var rollRef = options.ammo.match(/\$\[\[(\d+)\]\]/);
if (rollRef) {
var rollExpr = msg.inlinerolls[rollRef[1]].expression;
var match = rollExpr.match(/\d+-(\d+)/);
if (match) {
ammoUsed = match[1];
}
}
}
var val = parseInt(ammoAttr.get('current'), 10) || 0;
ammoAttr.set('current', Math.max(0, val - ammoUsed));
};
this.handleHD = function (options, msg) {
var match = options.title.match(/(\d+)d(\d+) Hit Dice/);
if (match && myState.config.autoHD) {
var hdCount = match[1];
var hdSize = match[2];
var hdAttr = roll20.getAttrObjectByName(options.character.id, 'hd_d' + hdSize);
var hpAttr = roll20.getAttrObjectByName(options.character.id, 'HP');
var newHp = Math.min(parseInt(hpAttr.get('current')) + this.getRollValue(msg, options.roll1), hpAttr.get('max'));
if (hdAttr) {
if (hdCount <= hdAttr.get('current')) {
hdAttr.set('current', hdAttr.get('current') - hdCount);
hpAttr.set('current', newHp);
}
else {
report('HD Police', options.characterName + ' can\'t use ' + hdCount + 'd' + hdSize +
' hit dice because they only have ' + hdAttr.get('current') + ' left');
}
}
}
};
this.handleDeathSave = function (options, msg) {
//TODO: Do we want to output text on death/recovery?
var increment = function (val) {
return ++val;
};
//TODO: Advantage?
if (roll20.getAttrByName(options.character.id, 'roll_setting') !== '@{roll_2}') {
var result = this.getRollValue(msg, options.roll1);
var attributeToIncrement = result >= 10 ? 'death_saving_throw_successes' : 'death_saving_throw_failures';
roll20.processAttrValue(options.character.id, attributeToIncrement, increment);
}
};
this.handleFX = function (options, msg) {
var parts = options.fx.split(' ');
if (parts.length < 2 || _.some(parts.slice(0, 2), _.isEmpty)) {
logger.warn('FX roll template variable is not formated correctly: [$$$]', options.fx);
return;
}
var fxType = parts[0],
pointsOfOrigin = parts[1],
targetTokenId,
//sourceTokenId,
sourceCoords = {},
targetCoords = {},
fxCoords = [],
pageId;
//noinspection FallThroughInSwitchStatementJS
switch (pointsOfOrigin) {
case 'sourceToTarget':
case 'source':
targetTokenId = parts[2]; //jshint ignore: line
fxCoords.push(sourceCoords, targetCoords);
break;
case 'targetToSource':
case 'target':
targetTokenId = parts[2];
fxCoords.push(targetCoords, sourceCoords);
}
if (targetTokenId) {
var targetToken = roll20.getObj('graphic', targetTokenId);
pageId = targetToken.get('_pageid');
targetCoords.x = targetToken.get('left');
targetCoords.y = targetToken.get('top');
}
else {
pageId = roll20.getCurrentPage(msg.playerid).id;
}
var casterTokens = roll20.findObjs({ type: 'graphic', pageid: pageId, represents: options.character.id });
if (casterTokens.length) {
//If there are multiple tokens for the character on this page, then try and find one of them that is selected
//This doesn't work without a selected token, and the only way we can get this is to use @{selected} which is a pain
//for people who want to launch without a token selected
// if(casterTokens.length > 1) {
// var selected = _.findWhere(casterTokens, {id: sourceTokenId});
// if (selected) {
// casterTokens = [selected];
// }
// }
sourceCoords.x = casterTokens[0].get('left');
sourceCoords.y = casterTokens[0].get('top');
}
if (!fxCoords[0]) {
logger.warn('Couldn\'t find required point for fx for character $$$, casterTokens: $$$, fxSpec: $$$ ', options.character.id, casterTokens, options.fx);
return;
}
else if (!fxCoords[1]) {
fxCoords = fxCoords.slice(0, 1);
}
roll20.spawnFx(fxCoords, fxType, pageId);
};
this.getRollValue = function (msg, rollOutputExpr) {
var rollIndex = rollOutputExpr.match(/\$\[\[(\d+)\]\]/)[1];
return msg.inlinerolls[rollIndex].results.total;
};
/**
*
* @returns {*}
*/
this.getRollTemplateOptions = function (msg) {
if (msg.rolltemplate === '5e-shaped') {
var regex = /\{\{(.*?)\}\}/g;
var match;
var options = {};
while (!!(match = regex.exec(msg.content))) {
if (match[1]) {
var splitAttr = match[1].split('=');
var propertyName = splitAttr[0].replace(/_([a-z])/g, function (match, letter) {
return letter.toUpperCase();
});
options[propertyName] = splitAttr.length === 2 ? splitAttr[1] : '';
}
}
if (options.characterName) {
options.character = roll20.findObjs({
_type: 'character',
name: options.characterName
})[0];
}
return options;
}
return {};
};
this.processInlinerolls = function (msg) {
if (_.has(msg, 'inlinerolls')) {
return _.chain(msg.inlinerolls)
.reduce(function (previous, current, index) {
previous['$[[' + index + ']]'] = current.results.total || 0;
return previous;
}, {})
.reduce(function (previous, current, index) {
return previous.replace(index.toString(), current);
}, msg.content)
.value();
}
else {
return msg.content;
}
};
this.addAbility = function (options) {
if (_.isEmpty(options.abilities)) {
//TODO report some sort of error?
return;
}
var messages = _.map(options.selected.character, function (character) {
var operationMessages = _.chain(options.abilities)
.sortBy('sortKey')
.map(function (maker) {
return maker.run(character, options);
})
.value();
if (_.isEmpty(operationMessages)) {
return '
' + character.get('name') + ': Nothing to do
';
}
var message;
message = '
Configured the following abilities for character ' + character.get('name') + ':