`);
}
}
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, createObj, findObjs, getObj, getAttrByName, sendChat, on, log, Campaign, playerIsGM, spawnFx,
spawnFxBetweenPoints, filterObjs */
'use strict';
const _ = __webpack_require__(2);
// noinspection JSUnusedLocalSymbols
module.exports = class Roll20Wrapper {
getState(module) {
if (!state[module]) {
state[module] = {};
}
return state[module];
}
createObj(type, attributes) {
return createObj(type, attributes);
}
findObjs(attributes) {
return findObjs(attributes);
}
filterObjs(attributes) {
return filterObjs(attributes);
}
getObj(type, id) {
return getObj(type, id);
}
getOrCreateObj(type, attributes) {
const newAttributes = _.extend(_.clone(attributes), { type });
const 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(character, attrName, valueType) {
return getAttrByName(character, attrName, valueType);
}
checkCharacterFlag(character, flag) {
const value = this.getAttrByName(character, flag);
switch (typeof value) {
case 'boolean':
return value;
case 'number':
return !!value;
default:
return value === '1' || value === 'on';
}
}
getAttrObjectByName(character, attrName) {
const attr = this.findObjs({ type: 'attribute', characterid: character, name: attrName });
return attr && attr.length > 0 ? attr[0] : null;
}
getOrCreateAttr(characterId, attrName) {
return this.getOrCreateObj('attribute', { characterid: characterId, name: attrName });
}
setAttrByName(characterId, attrName, value) {
this.getOrCreateAttr(characterId, attrName).set('current', value);
}
processAttrValue(characterId, attrName, cb) {
const attribute = this.getOrCreateAttr(characterId, attrName);
attribute.set('current', cb(attribute.get('current')));
}
getRepeatingSectionAttrs(characterId, sectionName) {
const prefix = `repeating_${sectionName}`;
return _.filter(this.findObjs({ type: 'attribute', characterid: characterId }),
attr => attr.get('name').indexOf(prefix) === 0);
}
getRepeatingSectionItemIdsByName(characterId, sectionName) {
const re = new RegExp(`repeating_${sectionName}_([^_]+)_name$`);
return _.reduce(this.getRepeatingSectionAttrs(characterId, sectionName),
(lookup, attr) => {
const match = attr.get('name').match(re);
if (match) {
lookup[attr.get('current').toLowerCase()] = match[1];
}
return lookup;
}, {});
}
getCurrentPage(playerId) {
let 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(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(playerId) {
return playerIsGM(playerId);
}
getCampaign() {
return Campaign(); // eslint-disable-line
}
sendChat(sendAs, message, callback, options) {
return sendChat(sendAs, message, callback, options);
}
on(event, callback) {
return on(event, callback);
}
log(msg) {
return log(msg);
}
};
/***/ },
/* 2 */
/***/ function(module, exports) {
module.exports = _;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
const _ = __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: ((*))}} - A parser that will process text in the format specified by the supplied formatSpec into
* JSON objects
*/
function getParser(formatSpec, logger) {
// noinspection JSUnusedGlobalSymbols
const parserModule = {
makeContentModelParser(fieldSpec, ordered) {
const module = this;
return {
parse(stateManager, textLines, resume) {
const parseState = stateManager.enterChildParser(this, resume);
let someMatch = false;
let canContinue;
let 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;
}
function parseRunner(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(stateManager, textLines) {
return this.parse(stateManager, textLines, true);
},
complete(parseState/* , finalText*/) {
const missingContent = _.filter(parseState.subParsers, 'required');
if (!_.isEmpty(missingContent)) {
throw new MissingContentError(missingContent);
}
},
};
},
matchParseToken(myParseState, textLines) {
if (_.isEmpty(textLines) || this.bare) {
return !_.isEmpty(textLines);
}
const re = new RegExp(`^(.*?)(${this.parseToken})(?:[\\s.]+|$)`, 'i');
const 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(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();
const matchGroup = this.matchGroup || 0;
const re = new RegExp(this.pattern, this.caseSensitive ? '' : 'i');
logger.debug('$$$ attempting to match value [$$$] against regexp $$$', this.name, textLines[0], re.toString());
const 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;
}
logger.debug('Match failed');
return false;
}
logger.debug('$$$ standard string match, not using pattern', this.name);
myParseState.text = '';
return true;
},
orderedContent(fieldSpec) {
return this.makeContentModelParser(fieldSpec, true);
},
unorderedContent(fieldSpec) {
return this.makeContentModelParser(fieldSpec, false);
},
string(/* fieldSpec */) {
return this.makeSimpleValueParser();
},
enumType(fieldSpec) {
const parser = this.makeSimpleValueParser();
if (fieldSpec.bare) {
parser.matchValue = function matchValue(myParseState, textLines) {
const firstMatch = _.chain(fieldSpec.enumValues)
.map(enumValue => {
logger.debug('Attempting to parse as enum property $$$', enumValue);
const pattern = `^(.*?)(${enumValue})(?:[\\s.]+|$)`;
const re = new RegExp(pattern, this.caseSensitive ? '' : 'i');
return textLines[0].match(re);
})
.compact()
.sortBy(match => 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(fieldSpec) {
const parser = this.makeSimpleValueParser();
parser.typeConvert = function typeConvert(textValue) {
const parts = textValue.split('/');
let intVal;
if (parts.length > 1) {
intVal = parts[0] / parts[1];
}
else {
intVal = parseInt(textValue, 10);
}
if (_.isNaN(intVal)) {
throw new BadValueError(fieldSpec.name, textValue, '[Integer]');
}
return intVal;
};
return parser;
},
ability(/* fieldSpec */) {
const parser = this.number();
parser.matchValue = function matchValue(parseState, textLines) {
if (_.isEmpty(textLines)) {
return false;
}
textLines[0] = textLines[0].trim();
const re = new RegExp('^([\\sa-z\\(\\)]*)(\\d+(?:\\s?\\([\\-+\\d]+\\))?)', 'i');
logger.debug('Attempting to match value [$$$] against regexp $$$', textLines[0].trim(), re.toString());
let match = textLines[0].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;
}
else if (textLines[1]) {
// Try and match against the next line in case we have a two line format
textLines[1] = textLines[1].trim();
match = textLines[1].match(/^(\d+)(?:\s?\([\-+\d]+\))?/);
if (match) {
logger.debug('Successful ability match $$$ on next line - looks like two line format', match);
parseState.text = match[1];
textLines[1] = textLines[1].slice(match[0].length);
if (!textLines[0]) {
textLines.shift();
}
if (!textLines[0]) {
textLines.shift();
}
return true;
}
}
return false;
};
return parser;
},
heading(fieldSpec) {
fieldSpec.bare = true;
const parser = this.makeSimpleValueParser();
parser.skipOutput = true;
return parser;
},
makeSimpleValueParser() {
const module = this;
return {
parse(stateManager, textLines) {
const parseState = stateManager.enterChildParser(this);
const 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(parseState, finalText) {
parseState.text += finalText || '';
if (parseState.text) {
parseState.value = this.extractValue(parseState.text);
parseState.value = this.typeConvert(parseState.value);
parseState.setOutputValue();
}
},
extractValue(text) {
text = text.trim();
if (this.pattern && !this.bare) {
const regExp = new RegExp(this.pattern, this.caseSensitive ? '' : 'i');
const match = text.match(regExp);
if (match) {
const matchGroup = this.matchGroup || 0;
return match[matchGroup];
}
throw new BadValueError(this.name, text, regExp);
}
else {
return text;
}
},
typeConvert(textValue) {
return textValue;
},
resumeParse(stateManager, textLines) {
if (_.isEmpty(textLines)) {
return false;
}
const parseState = stateManager.enterChildParser(this, true);
parseState.text += `${textLines.shift()}\n`;
stateManager.leaveChildParser(this, parseState);
return true;
},
matchParseToken: module.matchParseToken,
matchValue: module.matchValue,
};
},
makeBaseParseState(skipOutput, propertyPath, outputObject, completedObjects) {
return {
text: '',
getObjectValue() {
let value = outputObject;
const segments = _.clone(propertyPath);
while (segments.length) {
const prop = segments.shift();
if (prop.flatten) {
continue;
}
value = value[prop.name];
if (_.isArray(value)) {
value = _.last(value);
}
}
return value;
},
setOutputValue() {
if (skipOutput) {
return;
}
let outputTo = outputObject;
const segments = _.clone(propertyPath);
while (segments.length > 0) {
const prop = segments.shift();
if (prop.flatten) {
continue;
}
let currentValue = outputTo[prop.name];
let newValue = segments.length === 0 ? this.value : {};
if (_.isUndefined(currentValue) && prop.allowed > 1) {
currentValue = [];
outputTo[prop.name] = currentValue;
}
if (_.isArray(currentValue)) {
let 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() {
return _.extend(_.clone(this), { propertyPath });
},
};
},
makeParseStateManager() {
const incompleteParserStack = [];
const currentPropertyPath = [];
const completedObjects = [];
const module = this;
return {
outputObject: {},
leaveChildParser(parser, state) {
currentPropertyPath.pop();
if (state) {
state.resumeParser = _.isEmpty(incompleteParserStack) ? null : _.last(incompleteParserStack).parser;
incompleteParserStack.push({ parser, state });
}
},
completeCurrentStack(finalText) {
while (!_.isEmpty(incompleteParserStack)) {
const incomplete = incompleteParserStack.shift();
incomplete.parser.complete(incomplete.state, finalText);
const value = incomplete.state.getObjectValue();
if (_.isObject(value) && !incomplete.parser.flatten) {
// Crude but this list is unlikely to get that big
completedObjects.push(value);
}
}
},
enterChildParser(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() {
return _.extend(_.clone(this), {
incompleteParsers: incompleteParserStack,
propertyPath: currentPropertyPath,
});
},
};
},
parserId: 0,
parserAttributes: [
'forPreviousMatchGroup', 'forNextMatchGroup',
'parseToken', 'flatten', 'pattern', 'matchGroup', 'bare', 'caseSensitive',
'name', 'skipOutput',
],
getParserFor(fieldSpec) {
logger.debug('Making parser for field $$$', fieldSpec);
const parserBuilder = this[fieldSpec.type];
if (!parserBuilder) {
throw new Error(`Can\'t make parser for type ${fieldSpec.type}`);
}
const 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(contentModelArray) {
const module = this;
return _.chain(contentModelArray)
.reject('noParse')
.reduce((parsers, fieldSpec) => {
parsers.push(module.getParserFor(fieldSpec));
return parsers;
}, [])
.value();
},
logWrap: 'parseModule',
};
logger.wrapModule(parserModule);
const parser = parserModule.getParserFor(formatSpec);
return {
parse(text) {
logger.debug('Text: $$$', text);
const textLines = _.chain(text.split('\n'))
.invoke('trim')
.compact()
.value();
logger.debug(parser);
const stateManager = parserModule.makeParseStateManager();
const 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) {
// noinspection JSUnusedGlobalSymbols
this.message = message;
}
ParserError.prototype = new Error();
/**
* @constructor
*/
function MissingContentError(missingFieldParsers) {
this.missingFieldParsers = missingFieldParsers;
this.message = '
Field ${parser.parseToken} should have appeared ${parser.required} more times
`
, '');
this.message += '
';
}
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,
MissingContentError,
BadValueError,
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__) {
'use strict';
const _ = __webpack_require__(2);
function stringify(object) {
if (object === undefined) {
return object;
}
return typeof object === 'string' ? object : JSON.stringify(object, (key, value) =>
(key !== 'logWrap' && key !== 'isLogWrapped' ? value : undefined)
);
}
function wrapFunctions(object, moduleName, makeWrapper) {
const funcs = getAllFuncs(object);
return _.each(funcs, funcName => (object[funcName] = makeWrapper(funcName, object[funcName], moduleName)));
}
function getAllFuncs(obj) {
let props = [];
let current = obj;
do {
props = props.concat(Object.getOwnPropertyNames(current));
} while ((current = Object.getPrototypeOf(current)) && current !== Object.prototype);
return props.sort().filter((e, i, arr) => (e !== arr[i + 1] && typeof obj[e] === 'function'));
}
module.exports = class Logger {
constructor(loggerName, roll20) {
this.prefixString = '';
const state = roll20.getState('roll20-logger');
state[loggerName] = state[loggerName] || Logger.levels.INFO;
roll20.on('chat:message', (msg) => {
if (msg.type === 'api' && msg.content.startsWith('!logLevel')) {
const parts = msg.content.split(/\s/);
if (parts.length > 2) {
if (!state[parts[1]]) {
roll20.sendChat('Logger', `Unrecognised logger name ${parts[1]}`);
return;
}
state[parts[1]] = Logger.levels[parts[2].toUpperCase()] || Logger.levels.INFO;
}
}
});
function shouldLog(level) {
return level <= state[loggerName];
}
function outputLog(level, message) {
if (!shouldLog(level)) {
return;
}
const args = arguments.length > 2 ? _.toArray(arguments).slice(2) : [];
let processedMessage = stringify(message);
if (processedMessage) {
processedMessage = processedMessage.replace(/\$\$\$/g, () => stringify(args.shift()));
}
// noinspection NodeModulesDependencies
roll20.log(`${loggerName} ${Date.now()} ` +
`${Logger.getLabel(level)} : ${shouldLog(Logger.levels.TRACE) ? this.prefixString : ''}` +
`${processedMessage}`);
}
_.each(Logger.levels, (level, levelName) => {
this[levelName.toLowerCase()] = _.partial(outputLog, level);
});
this.wrapModule = function wrapModule(modToWrap) {
if (shouldLog(Logger.levels.TRACE)) {
wrapFunctions(modToWrap, modToWrap.logWrap, this.wrapFunction.bind(this));
modToWrap.isLogWrapped = true;
}
return modToWrap;
};
this.getLogTap = function getLogTap(level, messageString) {
return _.partial(outputLog, level, messageString);
};
this.wrapFunction = function wrapFunction(name, func, moduleName) {
if (shouldLog(Logger.levels.TRACE)) {
if (name === 'toJSON' || moduleName === 'roll20' && name === 'log') {
return func;
}
const logger = this;
return function functionWrapper() {
logger.trace('$$$.$$$ starting with this value: $$$ and args $$$', moduleName, name, this, arguments);
logger.prefixString = `${logger.prefixString} `;
const 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;
};
}
static getLabel(logLevel) {
const logPair = _.chain(Logger.levels).pairs().find(pair => pair[1] === logLevel).value();
return logPair ? logPair[0] : 'UNKNOWN';
}
static get levels() {
return {
OFF: 0,
ERROR: 1,
WARN: 2,
INFO: 3,
DEBUG: 4,
TRACE: 5,
};
}
};
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
const _ = __webpack_require__(2);
const utils = __webpack_require__(7);
module.exports = class EntityLookup {
constructor() {
this.entities = {};
this.noWhiteSpaceEntities = {};
this.entityProcessors = {};
this.versionCheckers = {};
}
configureEntity(entityName, processors, versionChecker) {
this.entities[entityName] = {};
this.noWhiteSpaceEntities[entityName] = {};
this.entityProcessors[entityName] = processors || [];
this.versionCheckers[entityName] = versionChecker || _.constant(true);
}
addEntities(entitiesObject) {
const results = {
errors: [],
};
_.chain(entitiesObject)
.omit('version', 'patch')
.each((entityArray, type) => {
results[type] = {
withErrors: [],
skipped: [],
deleted: [],
patched: [],
added: [],
};
if (!this.entities[type]) {
results.errors.push({ entity: 'general', errors: [`Unrecognised entity type ${type}`] });
return;
}
if (!this.versionCheckers[type](entitiesObject.version, results.errors)) {
return;
}
_.each(entityArray, (entity) => {
let key = entity.name.toLowerCase();
let operation = !!this.entities[type][key] ? (entitiesObject.patch ? 'patched' : 'skipped') : 'added';
if (operation === 'patched') {
entity = patchEntity(this.entities[type][key], entity);
if (!entity) {
operation = 'deleted';
delete this.entities[type][key];
delete this.noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
}
}
if (_.contains(['patched', 'added'], operation)) {
const processed = _.reduce(this.entityProcessors[type], utils.executor, {
entity,
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 this.entities[type][key];
delete this.noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
key = processed.entity.name.toLowerCase();
}
this.entities[type][key] = processed.entity;
this.noWhiteSpaceEntities[type][key.replace(/\s+/g, '')] = processed.entity;
}
}
results[type][operation].push(key);
});
});
return results;
}
findEntity(type, name, tryWithoutWhitespace) {
const key = name.toLowerCase();
if (!this.entities[type]) {
throw new Error(`Unrecognised entity type ${type}`);
}
let found = this.entities[type][key];
if (!found && tryWithoutWhitespace) {
found = this.noWhiteSpaceEntities[type][key.replace(/\s+/g, '')];
}
return found && utils.deepClone(found);
}
searchEntities(type, criteria) {
function containsSomeIgnoreCase(array, testValues) {
testValues = (_.isArray(testValues) ? testValues : [testValues]).map(s => s.toLowerCase());
return !!_.chain(array)
.map(s => s.toLowerCase())
.intersection(testValues)
.value().length;
}
return _.reduce(criteria, (results, criterionValue, criterionField) => {
const re = new RegExp(criterionValue, 'i');
const matcher = (entity) => {
const value = entity[criterionField];
switch (typeof value) {
case 'string':
return value.match(re);
case 'boolean':
case 'number':
return value === criterionValue;
case 'object':
return _.isArray(value) && containsSomeIgnoreCase(value, criterionValue);
default:
return false;
}
};
return results.filter(matcher);
}, this.getAll(type));
}
getAll(type) {
if (!this.entities[type]) {
throw new Error(`Unrecognised entity type: ${type}`);
}
return utils.deepClone(_.values(this.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
*/
getKeys(type, sort) {
if (!this.entities[type]) {
throw new Error(`Unrecognised entity type: ${type}`);
}
const keys = _.keys(this.entities[type]);
if (sort) {
keys.sort();
}
return keys;
}
/**
* Gets spell hydrator
* @function
* @public
* @name EntityLookup#getSpellHydrator
* @return {function}
*/
getSpellHydrator() {
const self = this;
return function spellHydrator(monsterInfo) {
const monster = monsterInfo.entity;
if (monster.spells) {
const spellArray = monster.spells.split(', ');
monster.spells = _.map(spellArray, spellName => self.findEntity('spells', spellName) || spellName);
}
return monsterInfo;
};
}
getMonsterSpellUpdater() {
const self = this;
return function spellUpdater(spellInfo) {
const spell = spellInfo.entity;
_.chain(self.entities.monsters)
.pluck('spells')
.compact()
.each(spellArray => {
const spellIndex = _.findIndex(spellArray, monsterSpell => {
if (typeof monsterSpell === 'string') {
return monsterSpell.toLowerCase() === spell.name.toLowerCase();
}
return monsterSpell !== spell && monsterSpell.name.toLowerCase() === spell.name.toLowerCase();
});
if (spellIndex !== -1) {
spellArray[spellIndex] = spell;
}
});
return spellInfo;
};
}
toJSON() {
return { monsterCount: _.size(this.entities.monsters), spellCount: _.size(this.entities.spells) };
}
get logWrap() {
return 'entityLookup';
}
static jsonValidatorAsEntityProcessor(jsonValidator) {
return function jsonValidatorEntityProcessor(entityInfo) {
const wrapper = {
version: entityInfo.version,
};
wrapper[entityInfo.type] = [entityInfo.entity];
const errors = jsonValidator.validate(wrapper);
const flattenedErrors = _.chain(errors).values().flatten().value();
entityInfo.errors = entityInfo.errors.concat(flattenedErrors);
return entityInfo;
};
}
static jsonValidatorAsVersionChecker(jsonValidator) {
return EntityLookup.getVersionChecker(jsonValidator.getVersionNumber());
}
static getVersionChecker(requiredVersion) {
function pruneToMinor(versionString) {
return versionString.split('.', 2).join('.');
}
return function versionChecker(version, errorsArray) {
const prunedVersion = pruneToMinor(version);
const prunedRequiredVersion = pruneToMinor(requiredVersion);
const valid = prunedVersion === prunedRequiredVersion;
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, (propVal, propName) => {
if (propName === 'name' && patch.newName) {
return patch.newName;
}
return patch[propName] || propVal;
});
}
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
const _ = __webpack_require__(2);
// noinspection JSUnusedGlobalSymbols
module.exports = {
deepExtend(original, newValues) {
if (!original) {
original = _.isArray(newValues) ? [] : {};
}
_.each(newValues, (value, key) => {
if (_.isArray(original[key])) {
if (!_.isArray(value)) {
original[key].push(value);
}
else {
original[key] = _.map(value, (item, index) => {
if (_.isObject(item)) {
return this.deepExtend(original[key][index], item);
}
return item !== undefined ? item : original[key][index];
});
}
}
else if (_.isObject(original[key])) {
original[key] = this.deepExtend(original[key], value);
}
else {
original[key] = value;
}
});
return original;
},
createObjectFromPath(pathString, value) {
const newObject = {};
_.reduce(pathString.split(/\./), (object, pathPart, index, pathParts) => {
const match = pathPart.match(/([^.\[]*)(?:\[(\d+)\])?/);
const 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(obj, path) {
path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
path = path.replace(/^\./, ''); // strip a leading dot
path.split('.').every(segment => (obj = obj[segment]));
return obj;
},
deepClone(object) {
return JSON.parse(JSON.stringify(object));
},
executor() {
switch (arguments.length) {
case 0:
return undefined;
case 1:
return arguments[0]();
default:
// Fall through
}
const 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(s) {
return s.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
},
toOptionsString(options) {
let res = options.join(' --');
if (res.length > 0) {
res = `--${res}`;
}
return res;
},
/**
* 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(hexcolor) {
hexcolor = hexcolor.replace('#', '');
if (hexcolor.length === 3) {
hexcolor += hexcolor;
}
const r = parseInt(hexcolor.substr(0, 2), 16);
const g = parseInt(hexcolor.substr(2, 2), 16);
const b = parseInt(hexcolor.substr(4, 2), 16);
const 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(tag, innerHtml, attrs) {
if (typeof innerHtml === 'object') {
innerHtml = _.map(innerHtml, html => html && this.buildHTML(html.tag, html.innerHtml, html.attrs)).join('');
}
let h = `<${tag}`;
h += _.chain(attrs)
.map((attrVal, attrName) => attrVal !== false && ` ${attrName}="${attrVal}"`)
.compact()
.value()
.join('');
if (innerHtml) {
h += `>${innerHtml}`;
}
else {
h += '/>';
}
return h;
},
missingParam(name) {
throw new Error(`Parameter ${name} is required`);
},
flattenObject(object) {
return _.reduce(object, (explodedProps, propVal, propKey) => {
if (_.isObject(propVal)) {
return _.extend(explodedProps, this.flattenObject(propVal));
}
explodedProps[propKey] = propVal;
return explodedProps;
}, {});
},
};
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
const _ = __webpack_require__(2);
// noinspection JSUnusedGlobalSymbols
const validatorFactories = {
orderedContent(spec) {
return makeContentModelValidator(spec);
},
unorderedContent(spec) {
return makeContentModelValidator(spec);
},
string(spec) {
if (spec.pattern) {
if (spec.matchGroup) {
return regExValidator(spec.name, extractRegexPart(spec.pattern, spec.matchGroup), spec.caseSensitive);
}
return regExValidator(spec.name, spec.pattern, spec.caseSensitive);
}
return function noop() {
};
},
enumType(spec) {
return function enumValidator(value, errors) {
if (!_.some(spec.enumValues, enumVal => new RegExp(`^${enumVal}$`, 'i').test(value))) {
errors.add(`Value "${value}" should have been one of [${spec.enumValues.join(',')}]`);
}
};
},
ability(spec) {
return regExValidator(spec.name, '\\d+');
},
heading() {
// Do not replace with _.noop, these functions get annotated
return function noop() {
};
},
number() {
return function numberValidator(value, errors) {
if (typeof value !== 'number') {
errors.add(`Value "${value}" should have been a number`);
}
};
},
};
function extractRegexPart(regexp, matchIndex) {
let braceCount = 0;
let startIndex = _.findIndex(regexp, (character, index) => {
if (character === '(' &&
(index < 2 || regexp[index - 1] !== '\\') &&
regexp[index + 1] !== '?') {
return ++braceCount === matchIndex;
}
return false;
});
if (startIndex === -1) {
throw new Error(`Can\'t find matchgroup ${matchIndex} in regular expression ${regexp}`);
}
// Lose the bracket
startIndex++;
let openCount = 1;
const endIndex = _.findIndex(regexp.slice(startIndex), (character, index, regexpPart) => {
if (character === '(' && regexpPart[index - 1] !== '\\') {
openCount++;
}
if (character === ')' && regexpPart[index - 1] !== '\\') {
return --openCount === 0;
}
return false;
});
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) {
const re = new RegExp(`^${regexp}$`, caseSensitive ? undefined : 'i');
return function regexpValidate(value, errors) {
if (!re.test(value)) {
errors.add(`Value "${value}" doesn\'t match pattern /${regexp}/`);
}
};
}
function makeValidator(spec) {
const 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) {
const parts = _.chain(spec.contentModel)
.reject({ type: 'heading' })
.partition({ flatten: true })
.value();
const flattened = _.map(parts[0], makeValidator);
const subValidators = _.reduce(parts[1], (subVals, field) => {
subVals[field.name] = makeValidator(field);
return subVals;
}, {});
return function contentModelValidator(object, errors, isFlatten) {
let completed = _.reduce(object, (completedMemo, fieldValue, fieldName) => {
const validator = subValidators[fieldName];
if (validator) {
completedMemo.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, (arrayItem, index) => {
errors.pushIndex(arrayItem.name ? arrayItem.name : index);
validator(arrayItem, errors);
errors.popIndex();
});
}
}
else {
validator(fieldValue, errors);
}
errors.popPath();
}
return completedMemo;
}, []);
let toValidate = _.omit(object, completed);
_.chain(flattened)
.map(validator => {
const subCompleted = validator(toValidate, errors, true);
if (subCompleted.length === 0) {
return validator;
}
completed = completed.concat(subCompleted);
toValidate = _.omit(toValidate, completed);
return null;
})
.compact()
.each(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(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((value, key) => {
errors.pushPath(key);
errors.add('Unrecognised field');
errors.popPath();
});
}
return completed;
};
}
class Errors {
constructor() {
this.errors = [];
this.currentPath = [];
}
pushPath(path) {
this.currentPath.push(path);
}
popPath() {
return this.currentPath.pop();
}
pushIndex(index) {
this.currentPath[this.currentPath.length - 1] = `${this.currentPath[this.currentPath.length - 1]}[${index}]`;
}
popIndex() {
this.currentPath[this.currentPath.length - 1] = this.currentPath[this.currentPath.length -
1].replace(/\[[^\]]+\]/, '');
}
add(msg) {
this.errors.push({ msg, path: _.clone(this.currentPath) });
}
getErrors() {
return _.chain(this.errors)
.groupBy(error => error.path[0])
.mapObject(errorList =>
_.map(errorList, error => `${error.path.slice(1).join('.')}: ${error.msg}`)
)
.value();
}
}
module.exports = class JSONValidator {
constructor(spec) {
this.versionProp = {
type: 'string',
name: 'version',
};
this.spec = spec;
this.contentValidator = makeValidator({ type: 'unorderedContent', contentModel: [spec, this.versionProp] });
}
validate(object) {
const errors = new Errors();
this.contentValidator(object, errors);
return errors.getErrors();
}
getVersionNumber() {
return this.spec.formatVersion;
}
};
/***/ },
/* 9 */
/***/ function(module, exports) {
'use strict';
function makeNormalMessage(scriptName, heading, text) {
return '
' +
'
' +
`${scriptName} ${heading}
${text}
`;
}
function makeErrorMessage(scriptName, text) {
return '
' +
'
' +
`${scriptName}
${text}
`;
}
class Reporter {
constructor(roll20, scriptName) {
this.roll20 = roll20;
this.scriptName = scriptName;
}
setPlayer(playerId) {
this.playerId = playerId;
}
reportPublic(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});
this.roll20.sendChat('', `${makeNormalMessage(this.scriptName, heading, text)}`);
}
reportPlayer(heading, text) {
this.roll20.sendChat('', `/w ${this.getPlayerName()} ${makeNormalMessage(this.scriptName, heading, text)}`);
}
reportError(text) {
this.roll20.sendChat('', `/w ${this.getPlayerName()} ${makeErrorMessage(this.scriptName, text)}`);
}
getPlayerName() {
return this.playerId ? this.roll20.getObj('player', this.playerId).get('displayname').split(/ /)[0] : 'gm';
}
}
module.exports = Reporter;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
/* globals unescape */
'use strict';
const _ = __webpack_require__(2);
const parseModule = __webpack_require__(3);
const makeCommandProc = __webpack_require__(11);
const utils = __webpack_require__(7);
const UserError = __webpack_require__(12);
const Migrator = __webpack_require__(14);
const ShapedConfig = __webpack_require__(15);
// Modules
const AbilityMaker = __webpack_require__(16);
const ConfigUI = __webpack_require__(17);
const AdvantageTracker = __webpack_require__(18);
const RestManager = __webpack_require__(19);
const TraitManager = __webpack_require__(20);
const AmmoManager = __webpack_require__(21);
/**
* @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, srdConverter, sanitise, mpp) {
let addedTokenIds = [];
const reportPublic = reporter.reportPublic.bind(reporter);
const reportPlayer = reporter.reportPlayer.bind(reporter);
const reportError = reporter.reportError.bind(reporter);
const commandProc = makeCommandProc('shaped', roll20);
const chatWatchers = [];
const advantageTracker = new AdvantageTracker();
const traitManager = new TraitManager();
const ammoManager = new AmmoManager();
const abilityMaker = new AbilityMaker();
const modules = [
abilityMaker,
new ConfigUI(),
advantageTracker,
traitManager,
new RestManager(),
ammoManager,
];
modules.forEach(module => module.configure(roll20, reporter, logger, myState, commandProc));
/**
*
* @param {ChatMessage} msg
*/
this.handleInput = function handleInput(msg) {
logger.debug(msg);
reporter.setPlayer(msg.playerid);
if (msg.type !== 'api') {
this.triggerChatWatchers(msg);
return;
}
this.oldStyleModulesConfigure(commandProc).processCommand(msg);
};
/////////////////////////////////////////
// Command handlers
/////////////////////////////////////////
this.applyTokenDefaults = function applyTokenDefaults(options) {
_.each(options.selected.graphic, token => {
const represents = token.get('represents');
const character = roll20.getObj('character', represents);
if (character) {
this.applyCharacterDefaults(character);
this.getTokenConfigurer(token)(character);
}
});
};
this.importStatblock = function importStatblock(options) {
logger.info('Importing statblocks for tokens $$$', options.selected.graphic);
_.each(options.selected.graphic, token => {
const error = `Could not find GM notes on either selected token ${token.get('name')} or the character ` +
'it represents. Have you pasted it in correctly?';
const text = token.get('gmnotes');
if (!text) {
const char = roll20.getObj('character', token.get('represents'));
if (char) {
char.get('gmnotes', notes => {
if (notes) {
return this.processGMNotes(options, token, notes);
}
return reportError(error);
});
}
else {
return reportError(error);
}
}
return this.processGMNotes(options, token, text);
});
};
this.processGMNotes = function processGMNotes(options, token, text) {
text = sanitise(unescape(text), logger);
const monsters = parser.parse(text).monsters;
mpp(monsters, entityLookup);
this.importMonsters(monsters, options, token, [
function gmNotesSetter(character) {
character.set('gmnotes', text.replace(/\n/g, ' '));
},
]);
};
this.importMonstersFromJson = function importMonstersFromJson(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);
if (!_.isEmpty(options.monsters)) {
setTimeout(() => this.importMonstersFromJson(options), 200);
}
}
};
this.importMonsters = function importMonsters(monsters, options, token, characterProcessors) {
const characterRetrievalStrategies = [];
if (token) {
characterProcessors.push(this.getAvatarCopier(token).bind(this));
if (_.size(monsters) === 1) {
characterProcessors.push(this.getTokenConfigurer(token).bind(this));
characterProcessors.push(this.getTokenVisionConfigurer(token, monsters[0].senses));
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));
const errors = [];
const importedList = _.chain(monsters)
.map(monsterData => {
const character = _.reduce(characterRetrievalStrategies,
(result, strategy) => result || strategy(monsterData.name, errors), null);
if (!character) {
logger.error('Failed to find or create character for monster $$$', monsterData.name);
return null;
}
const oldAttrs = roll20.findObjs({ type: 'attribute', characterid: character.id });
_.invoke(oldAttrs, 'remove');
character.set('name', monsterData.name);
_.each(characterProcessors, proc => proc(character, monsterData));
return character && character.get('name');
})
.compact()
.value();
if (!_.isEmpty(importedList)) {
const monsterList = importedList.join('
');
reportPlayer('Import Success', `Added the following monsters:
${monsterList}
`);
}
if (!_.isEmpty(errors)) {
const errorList = errors.join('
');
reportError(`The following errors occurred on import:
${errorList}
`);
}
};
this.importSpellsFromJson = function importSpellsFromJson(options) {
if (_.isEmpty(options.spells)) {
this.showEntityPicker('spell', 'spells');
}
else {
this.addSpellsToCharacter(options.selected.character, options.spells);
}
};
this.importSpellListFromJson = function importSpellListFromJson(options) {
const spells = entityLookup.searchEntities('spells', _.pick(options, _.keys(ShapedConfig.spellSearchOptions)));
const newOpts = _.omit(options, _.keys(ShapedConfig.spellSearchOptions));
newOpts.spells = spells;
this.importSpellsFromJson(newOpts);
};
this.getEntityCriteriaAdaptor = function getEntityCriteriaAdaptor(entityType) {
return function entityCriteriaAdaptor(criterionOption, options) {
const result = entityLookup.searchEntities(entityType, criterionOption, options[entityType]);
if (result) {
// If we get a result, wipe the existing list so that the new one replaces it
options[entityType] = [];
}
return result;
};
};
this.showEntityPicker = function showEntityPicker(entityName, entityNamePlural) {
const list = entityLookup.getKeys(entityNamePlural, true);
if (!_.isEmpty(list)) {
// title case the names for better display
list.forEach((part, index) => (list[index] = utils.toTitleCase(part)));
// create a clickable button with a roll query to select an entity from the loaded json
reportPlayer(`${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 addSpellsToCharacter(character, spells, noreport) {
const gender = roll20.getAttrByName(character.id, 'gender');
const defaultIndex = Math.min(myState.config.defaultGenderIndex, myState.config.genderPronouns.length);
const defaultPronounInfo = myState.config.genderPronouns[defaultIndex];
const pronounInfo = _.clone(_.find(myState.config.genderPronouns,
pronounDetails => new RegExp(pronounDetails.matchPattern, 'i').test(gender)) || defaultPronounInfo);
_.defaults(pronounInfo, defaultPronounInfo);
const importData = {
spells: srdConverter.convertSpells(spells, pronounInfo),
};
this.getImportDataWrapper(character).mergeImportData(importData);
if (!noreport) {
reportPlayer('Import Success', 'Added the following spells: