${v}
`,
// `Delete`
styles.components.labelWithDelete(v, `${confirm}autobut --deleteTemplate ${v}`)
]),
footerContent = `Add template`;
templateText.unshift([ 'Template name']);
new ChatDialog({ content: templateText, title: `Roll Template List`, footer: footerContent }, 'table');
}
},
{
name: 'addTemplate',
rx: /^addtem/i,
description: `Add roll template name to listen list for damage rolls`,
requiredServices: { config: 'ConfigController' },
action: function (args) {
if (!this.config.getSetting('templates/names').includes(args)) {
const result = this.config.changeSetting('templates/names', args);
if (result.success) result.msg = `Added template ${args} to listener list`;
return result;
}
}
},
{
name: 'removeTemplate',
rx: /^(remove|delete)tem/i,
description: `Remove roll template from listen list`,
requiredServices: { config: 'ConfigController' },
action: function (args) {
if (this.config.getSetting('templates/names').includes(args)) {
const result = this.config.changeSetting('templates/names', args);
if (result.success) result.msg = `Removed template ${args} to listener list`;
return result;
}
}
},
{
name: 'listProperties',
rx: /^(list)?(propert|props)/i,
description: `List roll template properties inline rolls are grabbed from`,
requiredServices: { config: 'ConfigController' },
action: function () {
const properties = this.config.getSetting('templates/damageProperties'),
confirm = styles.components.confirmApiCommand(`delete this template property?`),
styleCategory = `font-size: 1.4rem; font-weight: bold; font-style: italic;`
let templateText = [ ['Category', 'Properties'] ];
if (typeof properties === 'object') {
for (let category in properties) {
const propButtons = properties[category].map(prop => styles.components.labelWithDelete(prop, `${confirm}autobut --deleteprop ${category}/${prop}`));
templateText.push([
`${category}`,
`${propButtons.join(``)}
Add Property` ]); } } else return { err: `Error getting damage properties from state` } new ChatDialog({ title: 'Roll Template Properties', content: templateText, borders: { row: true } }, 'table'); } }, { name: 'addProperty', rx: /^addprop/i, description: `Add a roll template property to the listener`, requiredServices: { config: 'ConfigController', }, action: function (args) { const parts = args.match(/([^/]+)\/(.+)/); if (parts && parts.length === 3) { if (this.config.getSetting(`templates/damageProperties/${parts[1]}`) == null) { Helpers.toChat(`Created new roll template damage property category: ${parts[1]}`); state[scriptName].settings.templates.damageProperties[parts[1]] = []; } return this.config.changeSetting(`templates/damageProperties/${parts[1]}`, parts[2]); } else { return { err: `Bad property path supplied, must be in the form "category/propertyName". Example: damage/dmg1` }; } } }, { name: 'removeProperty', rx: /^(remove|delete)?prop/i, description: `Remove a roll template property from the listener`, requiredServices: { config: 'ConfigController', }, action: function (args) { const parts = args.match(/([^/]+)\/(.+)/); if (parts && parts.length === 3) { const currentArray = this.config.getSetting(`templates/damageProperties/${parts[1]}`); if (currentArray != null) { const result = this.config.changeSetting(`templates/damageProperties/${parts[1]}`, parts[2]); if (result.success && !/^(damage|crit)$/i.test(parts[1])) { // Clean up category if it's now empty, and isn't a core category const newArray = this.config.getSetting(`templates/damageProperties/${parts[1]}`); if (newArray.length === 0) { delete state[scriptName].settings.templates.damageProperties[parts[1]]; result.msg += `\nCategory ${parts[1]} was empty, and was removed.`; } } return result; } else return { err: `Could not find roll template property category: ${parts[1]}` } } else { return { err: `Bad property path supplied, must be in the form "category/propertyName". Example: damage/dmg1` } } } }, { name: 'listButtons', rx: /^(list)?button/i, description: `List available buttons`, requiredServices: { config: 'ConfigController', buttons: 'ButtonManager' }, action: function() { const removableButtons = this.buttons.getButtonNames({ default: false }), usedButtons = this.config.getSetting('enabledButtons'), unusedButtons = this.buttons.getButtonNames({ hidden: true }), availableButtons = this.buttons.getButtonNames({ hidden: true, currentSheet: true }), reorderedButtons = usedButtons.concat(unusedButtons); const links = { hide: `!autoButton --hideButton %name%`, show: `!autoButton --showButton %name%`, delete: `${styles.components.confirmApiCommand(`delete button %name%?`)}--deleteButton %name%`, disabled: `#` } const labels = { hide: `E/`, show: 'E', delete: 'D', disabled: '!' }; const controls = ['show', 'hide', 'delete']; const listBody = reorderedButtons.map(button => { const fadeText = usedButtons.includes(button) ? '' : styles.list.faded; let rowHtml = `
`;
controls.forEach(control => {
const controlType = (
(control === 'show' && availableButtons.includes(button)) ||
(control === 'hide' && usedButtons.includes(button)) ||
(control === 'delete' && removableButtons.includes(button))) ?
control : 'disabled';
rowHtml += ``;
});
return `${rowHtml.replace(/%name%/g, button)}
`;
});
const headerText = `autoButton list (sheet: ${this.config.getSetting('sheet')})`,
bodyText = listBody.join(''),
footerText = `Create New Button`;
new ChatDialog({ header: headerText, body: bodyText, footer: footerText }, 'listButtons');
},
},
{
name: 'showButton',
rx: /^showbut/i,
description: `Add a button to the button bar`,
requiredServices: { config: 'ConfigController', buttons: 'ButtonManager' },
action: function (args) {
const newVal = args.trim();
const validButtons = this.buttons.getButtonNames({ hidden: true, currentSheet: true });
if (validButtons.includes(newVal)) {
return this.config.changeSetting('enabledButtons', newVal);
} else new ChatDialog({ title: 'Error', content: `Unrecognised or incompatible button: "${newVal}"` }, 'error');
}
},
{
name: 'hideButton',
rx: /^hidebut/i,
description: `Remove a button from the template`,
requiredServices: { config: 'ConfigController', buttons: 'ButtonManager' },
action: function (args) {
const newVal = args.trim();
const validButtons = this.buttons.getButtonNames({ shown: true, currentSheet: true });
if (validButtons.includes(newVal)) {
return this.config.changeSetting('enabledButtons', newVal);
} else new ChatDialog({ title: 'Error', content: `Unrecognised or incompatible button: "${newVal}"` }, 'error');
}
},
{
name: 'reorderButtons',
rx: /^(re)?order/i,
description: `Change order of buttons`,
requiredServices: { config: 'ConfigController' },
action: function (args) {
if (!args) return;
const newIndices = args.replace(/[^\d,]/g, '').split(/,/g),
currentOrder = this.config.getSetting('enabledButtons');
let newOrder = [];
let valid = true;
newIndices.forEach(buttonIndex => {
const realIndex = buttonIndex - 1;
if (realIndex > -1 && realIndex < currentOrder.length) {
if (currentOrder[realIndex]) {
newOrder.push(currentOrder[realIndex]);
currentOrder[realIndex] = null;
}
} else valid = false;
});
if (!valid) return { err: `Invalid button order input: ${args}. Indices must be between 1 and total number of buttons in use.` }
newOrder = newOrder.concat(currentOrder.filter(v => v));
if (newOrder.length === currentOrder.length) return this.config.changeSetting('enabledButtons', newOrder, { overwriteArray: true });
}
},
{
name: 'createButton',
rx: /^createbut/i,
description: `Create a new button`,
requiredServices: { config: 'ConfigController', buttons: 'ButtonManager' },
action: function (args) {
const buttonData = Helpers.splitHandlebars(args);
if (buttonData && buttonData.name) {
if (/^[^A-Za-z]/.test(buttonData.name)) return { err: `Invalid button name: must start with a letter` };
let buttonName = /\s/.test(buttonData.name) ? Helpers.camelise(buttonData.name) : buttonData.name;
if (this.buttons.getButtonNames().includes(buttonName)) return { err: `Invalid button name, already in use: "${buttonName}"` }
if (!buttonData.math) return { err: `Button must have an associated function, {{math=...}}` }
buttonData.default = false;
buttonData.mathString = buttonData.math;
const result = this.buttons.addButton(buttonData);
if (result.success) {
this.buttons.showButton(buttonName);
return result;
}
else return result.err || `An error occurred creating the button.`;
} else return { err: `Bad input for button creation` }
}
},
{
name: 'editButton',
rx: /^editbut/i,
description: `Edit an existing button`,
requiredServices: { buttons: 'ButtonManager' },
action: function (args) {
let buttonData = Helpers.splitHandlebars(args);
debug.log(buttonData);
if (buttonData && buttonData.name) {
if (this.buttons.getButtonNames().includes(buttonData.name)) {
return this.buttons.editButton(buttonData);
}
}
}
},
{
name: 'deleteButton',
rx: /^del(ete)?but/i,
description: `Remove a button`,
requiredServices: { buttons: 'ButtonManager', config: 'ConfigController' },
action: function (args) {
const removeResult = this.buttons.removeButton(args.trim()),
buttonIsEnabled = this.config.getSetting('enabledButtons').includes(args);
if (removeResult.success) {
if (buttonIsEnabled) this.config.changeSetting('enabledButtons', args);
return removeResult;
} else return removeResult;
}
},
{
name: 'ignoreApi',
rx: /^ignoreapi/i,
description: `Ignore anything sent to chat by the API`,
requiredServices: { config: 'ConfigController' },
action: function(args) { return this.config.changeSetting('ignoreAPI', args) }
},
{
name: 'overheal',
rx: /^overh/i,
description: `Allow healing to push hp above hpMax`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('overheal', args) }
},
{
name: 'overkill',
rx: /^overk/i,
description: `Allow healing to push hp above hpMax`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('overkill', args) }
},
{
name: 'gmOnly',
rx: /^gmo/i,
description: `Whisper the buttons to GM, or post publicly`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('gmOnly', args) }
},
{
name: 'imageIcons',
rx: /^imagei/i,
description: `Render default icons as images (may solve font aligntment issues on Mac / ChromeOS)`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('imageIcons', args) }
},
{
name: `cloneButton`,
rx: /^clonebut/i,
description: `Clone a button`,
requiredServices: { buttons: 'ButtonManager' },
action: function(args) {
const parts = args.trim().split(/\s+/g),
originalButtonName = parts[0],
cloneName = parts[1];
return this.buttons.cloneButton(originalButtonName, cloneName);
}
},
{
name: `renameButton`,
rx: /^renamebut/i,
description: `Rename a button (Custom buttons only)`,
requiredServices: { buttons: 'ButtonManager' },
action: function(args) {
const parts = args.trim().split(/\s+/g),
originalButtonName = parts[0],
newName = parts[1];
return this.buttons.renameButton(originalButtonName, newName);
}
},
{
name: 'darkMode',
rx: /^dark/i,
description: `Palette change for the button bar`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('darkMode', args) }
},
{
name: 'multiattack',
rx: /^multiat/i,
description: `Attempt to link the button bar label to the source attack for easy repeat rolls`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('multiattack', args) }
},
{
name: 'allowNegatives',
rx: /^negative/i,
description: `Allow final results to be negative`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('allowNegatives', args) }
},
{
name: 'autosort',
rx: /^autosort/i,
description: `Auto sort buttons by unicode order`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('autosort', args) }
},
{
name: 'autohide',
rx: /^autohide/i,
description: `Autohide buttons with 0 reported damage`,
requiredServices: { config: 'ConfigController' },
action: function (args) { return this.config.changeSetting('autohide', args) }
},
{
name: 'report',
rx: /^report/i,
description: `Change settings for reporting HP changes to chat`,
requiredServices: { config: 'ConfigController' },
action: function (args) {
const newVal = `${args}`.replace(/\W/g, '').toLowerCase();
return this.config.changeSetting('report', newVal);
}
},
{
name: 'repair',
rx: /^repair/,
description: `Attempt to repair a button from the backed up math string.`,
requiredServices: { buttons: 'ButtonManager' },
action: function() {
for (const _button in this.buttons._buttons) {
const button = this.buttons._buttons[_button];
if (!button.default) {
if (!button.mathString.trim() || button.mathString.trim() === '0') {
if (button.mathBackup) {
const valid = ButtonManager.validateMathString(button.mathBackup, button.name);
if (valid.success) {
button.mathString = button.mathBackup;
this.buttons.saveToStore();
new ChatDialog({ content: `${button.name} was restored from backup.` });
}
}
}
}
}
}
},
{
name: 'settings',
rx: /^setting/i,
description: `Open settings UI`,
requiredServices: { config: 'ConfigController' },
action: function() { this.config.getSettingsMenu() }
},
{
name: 'help',
rx: /^(\?$|h$|help)/i,
description: `Display script help`,
action: function() { new ChatDialog({ title: `Script Help`, content: `Please visit the autoButtons thread for documentation.` }) }
},
{
name: 'uninstall',
rx: /^uninstall$/i,
description: `Remove all script settings from API state`,
action: function(args) {
if (/^undo/i.test(args)) {
state[scriptName] = Helpers.copyObj(undoUninstall);
new ChatDialog({ title: 'Reverse! Reverse the reverse!', content: `State settings have been restored. Let's pretend that never happend, eh?` }, 'error')
} else if (!undoUninstall) {
undoUninstall = Helpers.copyObj(state[scriptName]);
state[scriptName] = null;
delete state[scriptName];
new ChatDialog({
header: `${scriptName} uninstalled!`,
body: `Removed all ${scriptName} data from API state. Click the 'whoopsie' button below if you didn't mean to destroy all your settings!Otherwise, all settings will be *permantently* lost on sandbox restart.
Deleting the script now will result in a complete removal of the script and all associated data.`, footer: `Restore!`, }, 'listButtons'); } } } ]; /** * SCRIPT USER-CONFIG OPTIONS * * Must have a valid type to be pulled into SettingsManager as a setting * 'object' type can be used for nesting settings keys * 'validate' is a validator for the input, not necessarily the key itself (e.g. an array might accept strings in the validator) * 'name'/'description' are only used for chat menu UI * 'menuAction' must be supplied. Starting with '$' will automatically convert into a button with leading API command syntax, otherwise supply actual text required */ const defaultScriptSettings = { sheet: { type: 'string', range: ['dnd5e_r20', 'custom'], rangeLabels: [ 'DnD5e by Roll20', 'Custom' ], validate: function(v) { return this.range.includes(v) }, default: 'dnd5e_r20', name: 'Character sheet', description: 'Character sheet in use', menuAction: `$--loadPreset` }, enabledButtons: { type: 'array', validate: (v) => typeof(v) === 'string', default: [], }, gmOnly: { type: 'boolean', default: true, name: `GM-only buttons`, description: `Whether the buttons are visible to players`, menuAction: `$--gmo`, }, hpBar: { type: 'integer', range: [1,2,3], validate: function(v) { return this.range.includes(v) }, default: 1, name: `Token HP bar`, description: `Which token bar contains hit points`, menuAction: `$--bar`, }, ignoreAPI: { type: 'boolean', default: true, name: `Ignore API posts`, description: `Ignore any automated damage rolls made by scripts`, menuAction: `$--ignoreapi`, }, overheal: { type: 'boolean', default: false, name: `Allow overheal`, description: `Allow HP to go above max`, menuAction: `$--overheal`, }, overkill: { type: 'boolean', default: false, name: `Allow overkill`, description: `Allow HP to go below 0`, menuAction: `$--overkill`, }, targetTokens: { type: 'boolean', default: false, name: `Target tokens`, description: `Use a target click to target token, instead of current selection`, menuAction: `$--targettoken`, }, bump: { type: 'boolean', default: true, name: `Slim buttons`, description: `CSS to bump the button container up in chat to save some space`, menuAction: `$--bump`, }, imageIcons: { type: 'boolean', default: true, name: `Image Icons`, description: `Render default icons as images (may solve font aligntment issues on Mac / ChromeOS)`, menuAction: `$--imageicon`, }, darkMode: { type: 'boolean', default: false, name: `Dark Mode`, description: `Palette change for the button bar`, menuAction: `$--darkMode`, }, multiattack: { type: 'boolean', default: false, name: `Multiattack`, description: `Attempt to link the button bar label to the source attack for easy repeat rolls. 5e only.`, menuAction: `$--multiattack`, }, allowNegatives: { type: 'boolean', default: false, name: `Allow negatives`, description: `Allow final results to be negative. This can cause healing to cause damage, or damage to heal`, menuAction: `$--negatives`, }, autosort: { type: 'boolean', default: false, name: `Sort buttons`, description: `Auto sort buttons by unicode order`, menuAction: `$--autosort`, }, autohide: { type: 'boolean', default: true, name: `Autohide buttons`, description: `Autohide buttons with 0 reported damage`, menuAction: `$--autohide`, }, report: { type: 'string', range: [ 'off', 'gm', 'control', 'all' ], rangeLabels: [ 'Off', 'GM', 'Character', 'Public' ], validate: function(v) { return this.range.find(r => r.toLowerCase() === v.toLowerCase()) }, default: 'Off', name: `Report changes`, description: `Report hitpoint changes to chat`, menuAction: `$--report`, }, templates: { type: 'object', names: { type: 'array', validate: (v) => typeof(v) === 'string', default: [], name: `Roll templates & properties`, description: `Names of roll templates & properties watched by autoButtons`, menuAction: `Templates
Properties`, }, damageProperties: { type: 'object', damageFields: { type: 'array', validate: (v) => typeof(v) === 'string', default: [], }, critFields: { type: 'array', validate: (v) => typeof(v) === 'string', default: [] }, upcastDamage: { type: 'array', validate: (v) => typeof(v) === 'string', default: [] }, upcastCrit: { type: 'array', validate: (v) => typeof(v) === 'string', default: [] }, get value() { const output = {}; for (const key in this) { if (key === 'value') continue; if (this[key].value) output[key] = this[key].value; } return output; } }, }, } /** * CLASS DEFINITIONS */ /** * Service Locator - Find a registered service from any scope in the script with ServiceLocator.getLocator().getService('serviceName') */ class ServiceLocator { static _active = null; _services = {}; constructor(services={}) { if (ServiceLocator._active) return ServiceLocator._active; this.name = `ServiceLocator`; for (let svc in services) { this._services[svc] = services[svc] } ServiceLocator._active = this; } static getLocator() { return ServiceLocator._active } register({ serviceName, serviceReference }) { if (!this._services[serviceName]) this._services[serviceName] = serviceReference } // Find a service. If service has multiple instances, make sure to request by instance name, or only the first registered constructor name will be returned. // Search by Class Constructor Name is only suitable for unique class instances getService(serviceName) { if (this._services[serviceName]) return { [serviceName]: this._services[serviceName] } else { const rxServices = new RegExp(`${serviceName}`, 'i') for (let service in this._services) { if (this._services[service].constructor && rxServices.test(this._services[service].constructor.name)) return this._services[service]; } } } } /** * Settings Manager - Handles fetch and store of user settings to state{} object, reads and writes to user settings. Processes the defaultScriptSettings{} object on init. Access via ConfigManager */ class SettingsManager { _settingsKeys = {}; constructor(settingsData = {}) { const processObject = (currentObject, targetPath) => { for (const key in currentObject) { if (!currentObject[key].type) { debug.log(`Skipping ${key}, no type found`); continue; } debug.log(`Processing ${key}...`); if (currentObject[key].type === 'object' && Helpers.isObj(currentObject[key])) { targetPath[key] = currentObject[key]; processObject(currentObject[key], targetPath[key]); } else if (this._validateKey(currentObject[key], currentObject[key].default)) { targetPath[key] = currentObject[key]; targetPath[key].value = currentObject[key].default; } else debug.warn(`${this.constructor.name}: Bad key used in constructor: ${key} default value does not match specified type`, currentObject[key]); } } processObject(settingsData, this._settingsKeys); debug.log(this._settingsKeys); } get settingsKeys() { return this._settingsKeys } // Validate a settings key and the stored value _validateKey(settingsKey, settingsValue) { if (!settingsKey) return false; // debug.log(`Validating ${settingsValue}...`); const passValidation = ( settingsKey.type === 'array' && Array.isArray(settingsValue) || ['float', 'integer', 'number'].includes(settingsKey.type) && typeof(settingsValue) === 'number' || typeof(settingsValue) === settingsKey.type ) ? true : false; // debug.log(passValidation); return passValidation; } // Validate an input to be stored in a settings key (e.g. may be a primitive value to be stored in an object type key) // Returns undefined for failed validation, otherwise returns value ready for storage _validateNewValue(settingsKey, newValue, options = { forceValidation: null }) { if (!settingsKey || typeof(settingsKey) !== 'object' || !settingsKey.type || newValue === undefined) return debug.error(`${this.constructor.name}: Bad settings key`, settingsKey); // Handle keys with validators (Objects and Arrays must have a validator since they can't be passed from Roll20) if (typeof(options.forceValidation) === 'function') { if (options.forceValidation(newValue)) return newValue; else return undefined; } else if (typeof(settingsKey.validate) === 'function') { if (settingsKey.validate(newValue)) return newValue; else return undefined; } // Handle booleans else if (settingsKey.type === 'boolean') { if (rx.on.test(newValue)) return true; else if (rx.off.test(newValue)) return false; else return undefined; } // Otherwise, type match else if (settingsKey.type === 'integer' && parseInt(newValue) === parseInt(newValue)) return parseInt(newValue); else if (settingsKey.type === 'float' && parseFloat(newValue) === parseFloat(newValue)) return parseFloat(newValue); else if (settingsKey.type === typeof(newValue)) return newValue; else return undefined; } _writeSetting(settingsKey, newValue, options = { overwriteArray: false }) { const validationOptions = (options.overwriteArray) ? { forceValidation: (v) => Array.isArray(v) } : {}, validData = this._validateNewValue(settingsKey, newValue, validationOptions); if (validData === undefined) { debug.error(`${this.constructor.name}: Settings change not applied, value failed validation`, settingsKey, newValue); return { err: `${this.constructor.name}: Settings change not applied, value failed validation` } } else { if (settingsKey.type === 'array') { if (options.overwriteArray && Array.isArray(newValue)) { settingsKey.value = newValue; return { msg: `Saved new Array: [${newValue.join(', ')}]` } } else return Helpers.modifyArray(settingsKey.value, newValue); } else { settingsKey.value = newValue; return { msg: `Saved value: ${newValue}` } } } } importSettingsValues(importedKeys = {}) { if (typeof(importedKeys) !== 'object') return debug.error(`${this.constructor.name}: Bad settings import, must only supply object type`); const processObject = (currentObject, targetPath) => { for (const key in currentObject) { if (targetPath[key]) { if (!targetPath[key].type) { debug.log(`Skipping ${key}, no type defined`); continue; } if (targetPath[key].type === 'object' && Helpers.isObj(currentObject[key])) { processObject(currentObject[key], targetPath[key]); } else if (this._validateKey(targetPath[key], currentObject[key])) { targetPath[key].value = currentObject[key]; } else debug.warn(`${this.constructor.name}: Key "${key}" failed validation`, currentObject[key]); } else debug.warn(`${this.constructor.name}: Key "${key}" does not exist.`, currentObject[key]); } } processObject(importedKeys, this._settingsKeys); debug.log(this._settingsKeys); } exportSettingsValues() { const output = {}; const processObject = (currentObject, targetPath) => { for (const key in currentObject) { if (currentObject[key].type === 'object' && Helpers.isObj(currentObject[key])) { targetPath[key] = {}; processObject(currentObject[key], targetPath[key]); } else if (currentObject[key].type) { targetPath[key] = currentObject[key].value; } } } processObject(this._settingsKeys, output); return output; } // Provide path relative to {Config._settings}, e.g. changeSetting('sheet', 'mySheet'); // booleans with no "newValue" supplied will be toggled // Use options.force 'type' to force a type on the setting e.g. array or boolean // Combine with options.createPath: true to create a new setting of the correct type updateSetting(pathString, newValue, options = { createPath: false, overwriteArray: false, force: null }) { if (typeof(pathString) !== 'string' || newValue === undefined) return { err: `Bad path string or no new value supplied.` }; // Can probably remove this bit now that a .value key is used const keyName = (pathString.match(/[^/]+$/)||[])[0], path = /.+\/.+/.test(pathString) ? pathString.match(/(.+)\/[^/]+$/)[1] : '', configPath = path ? Helpers.getObjectPath(path, this._settingsKeys, options.createPath) : this._settingsKeys, targetKey = configPath[keyName]; if (targetKey) { debug.log(`changeSetting - ${keyName}`, targetKey, options, newValue); if (targetKey.type === 'boolean') { newValue = (newValue == null || newValue === '') ? !targetKey.value : rx.on.test(newValue) ? true : rx.off.test(newValue) ? false : newValue; } const result = this._writeSetting(targetKey, newValue, options); if (result.msg) result.msg = `Changed setting: ${pathString}
${result.msg}`; else if (result.err) result.err = `Changed setting: ${pathString}
${result.err}`; return result; } else { return { err: `Settings key not found - *${pathString}*` } } } readSetting(pathString) { if (typeof(pathString) !== 'string') return; const targetKey = Helpers.getObjectPath(pathString, this._settingsKeys, false); return targetKey ? targetKey.value : undefined; } // Export this._settingsKeys as chatbar-friendly text getMenuText() { const output = []; const processObject = (currentObject, targetOutput) => { for (const key in currentObject) { if (currentObject[key].type === 'object') { processObject(currentObject[key], targetOutput); } else if (currentObject[key].menuAction) { const name = currentObject[key].name || key, hover = currentObject[key].description ? `title="${currentObject[key].description}"` : ``, settingName = `
${name}
`,
currentSetting = `${currentObject[key].value}`;
// Entry has a custom menu action
if (/^[^$]/.test(currentObject[key].menuAction)) {
targetOutput.push([ settingName, currentObject[key].menuAction ]);
}
// Autofill prompt for boolean or defined range
else {
const queryRange =
currentObject[key].type === 'boolean' ? ['True', 'False']
: currentObject[key].range ?
currentObject[key].rangeLabels ? currentObject[key].range.map((v,i) => `${currentObject[key].rangeLabels[i]||v},${v}`)
: Helpers.toArray(currentObject[key].range)
: '',
queryString = queryRange ? `?{Select new value|${queryRange.join('|')}}` : `?{Enter new value}`,
cliFlag = (`${currentObject[key].menuAction}`.match(/^\$(.+)/)||[])[1] || `--${key}`,
commandString = `!${scriptName} ${cliFlag} ${queryString}`;
targetOutput.push([ settingName, `${currentSetting}`]);
}
}
}
}
processObject(this._settingsKeys, output);
return output;
}
}
/**
* Config Controller - Handles user settings via injected SettingsManager, and Custom Button storage via internal _store
*/
class ConfigController {
_version = { M: 0, m: 0, p: 0 };
constructor(scriptName, scriptData={}) {
Object.assign(this, {
name: scriptName || `newScript`,
_settings: new SettingsManager(scriptData.settings) || {},
_store: scriptData.store || {},
});
if (scriptData.version) this.version = scriptData.version;
}
get version() { return `${this._version.M}.${this._version.m}.${this._version.p}` }
set version(newVersion) {
if (typeof(newVersion) === 'object' && newVersion.M && newVersion.m && newVersion.p) Object.assign(this._version, newVersion);
else {
const parts = `${newVersion}`.split(/\./g);
if (!parts.length) debug.error(`Bad version number, not setting version.`)
else Object.keys(this._version).forEach((v,i) => this._version[v] = parseInt(parts[i]) || 0);
}
}
initialState() {
return {
version: this.version,
settings: this._settings.exportSettingsValues(),
store: this._store
}
}
fromStore(path) { return Helpers.getObjectPath(path, this._store, false) }
toStore(path, data) { // Supplying data=null will delete the target
const ref = Helpers.getObjectPath(path, this._store, true);
let msg;
if (ref) {
if (data) {
Object.assign(ref, data);
msg = `New data written to "${path}"`;
} else if (data === null) {
Helpers.getObjectPath(path, this._store, false, true);
msg = `${path} deleted from store.`;
} else return { success: 0, err: `Bad data supplied (type: ${typeof data})` }
} else return { success: 0, err: `Bad store path: "${path}"` }
this.saveToState();
return { success: 1, msg: msg }
}
fetchFromState() {
Object.assign(this, { _store: state[scriptName].store, });
this._settings.importSettingsValues(state[scriptName].settings);
}
saveToState() {
Object.assign(state[scriptName], {
settings: this._settings.exportSettingsValues(),
store: this._store,
});
}
changeSetting(pathString, newValue, options) {
options = typeof(options) === 'object' ? options : undefined;
const result = this._settings.updateSetting(pathString, newValue, options);
debug.log(`Setting change attempted`, result);
if (result.msg) this.saveToState();
return result;
}
getSetting(pathString) {
const currentValue = this._settings.readSetting(pathString);
return (typeof currentValue === 'object') ? Helpers.copyObj(currentValue) : currentValue;
}
loadPreset() {
const currentSheet = this.getSetting('sheet') || '';
if (Object.keys(preset).includes(currentSheet)) {
// Load template names
this._settings.updateSetting('templates/names', preset[currentSheet].templates.names, { overwriteArray: true });
// Load damage properties
for (const key in preset[currentSheet].templates.damageProperties) {
// debug.info(`Processing ${key} in preset...`);
this._settings.updateSetting(`templates/damageProperties/${key}`, preset[currentSheet].templates.damageProperties[key], { overwriteArray: true });
}
this._settings.updateSetting('enabledButtons', preset[currentSheet].defaultButtons || [], { overwriteArray: true });
this.saveToState();
return { res: 1, data: `${this.getSetting('sheet')}` }
} else return { res: 0, err: `Preset not found for sheet: "${currentSheet}"`}
}
getSettingsMenu() {
const menuOptions = this._settings.getMenuText(),
confirm = styles.components.confirmApiCommand(`reset to default sheet settings?`),
footerContent = `Reset Sheet Settings`;
menuOptions.unshift(['Key', 'Setting']);
new ChatDialog({ title: `${scriptName} settings
v${scriptVersion}`, content: menuOptions, footer: footerContent }, 'table'); } } /** * Button Manager - Handles CRUD operations, math/query functions and HTML output for all buttons, both internal and Custom Button */ class ButtonManager { static _buttonKeys = ['sheets', 'content', 'content2', 'content3', 'tooltip', 'style', 'style2', 'style3', 'math', 'default', 'mathString', 'query']; static _editKeys = ['clone', 'rename']; _locator = null; _Config = {}; _buttons = {}; constructor(data={}) { Object.assign(this, { name: data.name || 'newButtonManager' }); // Requires access to a ConfigController this._locator = ServiceLocator.getLocator() || this._locator; this._Config = this._locator ? this._locator.getService('ConfigController') : null; if (!this._Config) return {}; for (let button in data.defaultButtons) { this._buttons[button] = new Button(data.defaultButtons[button], styles) } } get keys() { return ButtonManager._buttonKeys } get editKeys() { return [ ...ButtonManager._buttonKeys, ...ButtonManager._editKeys ]} getButtonNames(filters={ default: null, currentSheet: null, shown: null, hidden: null }) { let buttons = Object.entries(this._buttons); const sheet = this._Config.getSetting('sheet'), enabledButtons = this._Config.getSetting('enabledButtons'); if (typeof filters.default === 'boolean') buttons = buttons.filter(kv => kv[1].default === filters.default); if (typeof filters.currentSheet === 'boolean') buttons = buttons.filter(kv => (!kv[1].sheets.length || sheet === 'custom' || (kv[1].sheets.includes(sheet) === filters.currentSheet))); if (typeof filters.shown === 'boolean') buttons = buttons.filter(kv => (enabledButtons.includes(kv[0]) === filters.shown)); if (typeof filters.hidden === 'boolean') buttons = buttons.filter(kv => (enabledButtons.includes(kv[0]) === !filters.hidden)); const output = buttons.map(kv=>kv[0]); // debug.log(`button names: ${output.join(', ')}`); return output; } static validateMathString(inputString, buttonName) { debug.info(inputString); inputString = `${inputString}`; // Default buttons will send in a JS function, remove the declaration part inputString = inputString.replace(/^.*?=>\s*/, ''); let newFormula = inputString; const mathOpsString = MathOpsTransformer.transformMathString(newFormula); debug.info(mathOpsString); // Create a test object const damageKeyMatches = inputString.match(/damage\.(\w+)/g) || [], critKeyMatches = inputString.match(/crit\.(\w+)/g) || [], damageKeys = damageKeyMatches.reduce((output, key) => ({ ...output, [key.replace(/^[^.]*\./, '')]: 5 }), {}), critKeys = critKeyMatches.reduce((output, key) => ({ ...output, [key.replace(/^[^.]*\./, '')]: 5 }), {}); const { config } = ServiceLocator.getLocator().getService('config'); const damageProperties = Object.values(config.getSetting('templates/damageProperties')).reduce((output, category) => [ ...output, ...category ], []); const invalidProperties = [ ...Object.keys(damageKeys), ...Object.keys(critKeys) ].filter(key => !(damageProperties.includes(key))); const mathOpsKeys = MathOpsTransformer.transformMathOpsPayload(damageKeys, critKeys); debug.info(mathOpsKeys); let error; try { const testResult = MathOps.MathProcessor({ code: mathOpsString, known: mathOpsKeys }); debug.info(testResult); if (testResult.message) { error = testResult.message; } else if (isNaN(testResult)) { error = `The supplied math did not return a number: ${inputString}`; } } catch(e) { error = `Math failed validation - ${e}`; } if (invalidProperties.length) new ChatDialog({ title: `Button Warning: "${buttonName}"`, content: `The following damage properties in the button are not set up in this game: ${invalidProperties.join(', ')}` }, 'error'); return error ? { success: false, err: error } : { success: true, err: null } } addButton(buttonData={}) { const newButton = buttonData.default === false ? new CustomButton(buttonData) : new Button(buttonData); debug.warn(newButton); if (newButton.err || !newButton.math) return { success: 0, err: newButton.err || `Button ${buttonData.name} could not be created.` } if (this._buttons[newButton.name]) return { success: 0, err: `Button "${newButton.name}" already exists` }; this._buttons[newButton.name] = newButton; this.saveToStore(); return { success: 1, msg: `New Button "${newButton.name}" successfully created` } } editButton(buttonData={}) { const modded = []; if (!this._buttons[buttonData.name]) return { success: 0, err: `Button "${buttonData.name}" does not exist.` } if (this._buttons[buttonData.name].default) return { success: 0, err: `Cannot edit default buttons.` } this.editKeys.forEach(k => { debug.log(k, buttonData[k]); if (buttonData[k] != null) { if (k === 'default') return; // Don't allow reassignment of 'default' property else if (k === 'math') { const { success, err } = ButtonManager.validateMathString(buttonData[k], buttonData.name); if (!success) return { err }; else { this._buttons[buttonData.name].mathString = buttonData[k]; modded.push(k); } } else if (/^style/.test(k)) { this._buttons[buttonData.name][k] = styles[buttonData[k]] || buttonData[k] || ''; modded.push(k); } // else if (k === 'query') { // this._buttons[buttonData.name].query = Button.splitAndEscapeQuery(buttonData.query); // modded.push(k); // } else { this._buttons[buttonData.name][k] = buttonData[k]; modded.push(k); } } }); if (modded.length) this.saveToStore(); return modded.length ? { success: 1, msg: `Modified ${buttonData.name} fields: ${modded.join(', ')}` } : { success: 0, err: `No fields supplied.` } } removeButton(buttonName) { if (!this._buttons[buttonName]) return { success: 0, err: `Button "${buttonName}" does not exist.` } if (this._buttons[buttonName].default) return { success: 0, err: `Cannot delete default buttons.` } delete this._buttons[buttonName]; this._Config.toStore(`customButtons/${buttonName}`, null); return { success: 1, msg: `Removed "${buttonName}".` } } cloneButton(originalButtonName, newButtonName) { if (this._buttons[originalButtonName] && newButtonName) { const cloneName = /\s/.test(newButtonName) ? Helpers.camelise(newButtonName) : newButtonName, cloneData = { ...this._buttons[originalButtonName], name: cloneName, default: false }, copyResult = this.addButton(cloneData); return copyResult.success ? { success: 1, msg: `Cloned button ${originalButtonName} => ${cloneName}` } : copyResult; } else return { err: `Could not find button "${originalButtonName}", or bad clone button name "${newButtonName}"` } } renameButton(originalButtonName, newButtonName) { if (!this._buttons[originalButtonName]) return { success: 0, err: `Button "${originalButtonName}" could not be found` }; if (this._buttons[originalButtonName].default) return { success: 0, err: `Cannot rename a default button.` }; const cloneName = /\s/.test(newButtonName) ? Helpers.camelise(newButtonName) : newButtonName, cloneResult = this.cloneButton(originalButtonName, cloneName); if (cloneResult.success) { this.removeButton(originalButtonName); return { success: 1, msg: `Renamed button ${originalButtonName} => ${cloneName}` }; } else return cloneResult; } showButton(buttonName) { if (this._buttons[buttonName] && !this._Config.getSetting('enabledButtons').includes(buttonName)) { return this._Config.changeSetting('enabledButtons', buttonName) } } hideButton(buttonName) { if (this._buttons[buttonName] && this._Config.getSetting('enabledButtons').includes(buttonName)) { return this._Config.changeSetting('enabledButtons', buttonName) } } saveToStore() { const customButtons = this.getButtonNames({default: false}); customButtons.forEach(button => this._Config.toStore(`customButtons/${button}`, Helpers.copyObj(this._buttons[button]))); } _getReportTemplate(barNumber) { const template = `'*({name}) {bar${barNumber}_value;before}HP -> {bar${barNumber}_value}HP*'`; return template; // Styled report template for if Aaron implements decoding in TM // const templateRaw = `''`; // return encodeURIComponent(templateRaw); // !token-mod --set bar1_value|-[[floor(query*17)]]! } _getImageIcon(buttonName, cacheBust, version = '2a') { if (!cacheBusted) { cacheBust = true; } const url = `https://raw.githubusercontent.com/ooshhub/autoButtons/main/assets/imageIcons/${buttonName}.png?${version}`.replace(/%/g, 'P'); return cacheBust ? `${url}${Math.floor(Math.random()*1000000000)}` : url; // May need to switch to this if images move // return styles.imageIcons[buttonName]; } createApiButton(buttonName, damage, crit) { // debug.info(this._buttons[buttonName]); const btn = this._buttons[buttonName], autoHide = this._Config.getSetting(`autohide`), bar = this._Config.getSetting('hpBar'), overheal = this._Config.getSetting('overheal'), overkill = this._Config.getSetting('overkill'), sendReport = (this._Config.getSetting('report')||``).toLowerCase(), reportString = [ 'all', 'gm', 'control' ].includes(sendReport) ? ` --report ${sendReport}|${this._getReportTemplate(bar)}` : ``, darkMode = this._Config.getSetting('darkMode'); const zeroBound = this._Config.getSetting('allowNegatives') ? false : true, boundingPre = zeroBound ? `{0, ` : ``, boundingPost = zeroBound ? `}kh1` : ``; const queryString = Button.splitAndEscapeQuery(btn.query) || ''; if (!btn || typeof(btn.math) !== 'function') { debug.error(`${scriptName}: error creating API button ${buttonName}`); return ``; } const modifier = this.resolveButtonMath(btn, damage, crit), tooltip = btn.tooltip.replace(/%/, `${modifier} HP`), setWithQuery = queryString ? `[[${boundingPre}${queryString.replace(/%%MODIFIER%%/g, Math.abs(modifier))}${boundingPost}]]` : `${Math.abs(modifier)}`, tokenModCmd = (modifier > 0) ? (!overheal) ? `+${setWithQuery}!` : `+${setWithQuery}` : (modifier < 0 && !overkill) ? `-${setWithQuery}!` : `-${setWithQuery}`, selectOrTarget = (this._Config.getSetting('targetTokens') === true) ? `--ids @{target|token_id} ` : ``, buttonHref = `!token-mod ${selectOrTarget}--set bar${bar}_value|${tokenModCmd}${reportString}`, useImageIcon = this._Config.getSetting('imageIcons') && btn.default, buttonContent = useImageIcon ? `})
`
: `${btn.content}`,
buttonContent2 = useImageIcon ? ``
: btn.content2 ? `${btn.content2}` : ``,
buttonContent3 = useImageIcon ? ``
: btn.content3 ? `${btn.content3}` : ``;
return (autoHide && modifier == 0) ?
``
: ``;
}
verifyButtons() {
const currentSheet = this._Config.getSetting('sheet'),
currentButtons = this._Config.getSetting('enabledButtons'),
validButtons = currentButtons.filter(button => {
if (currentSheet === 'custom' || this._buttons[button] && this._buttons[button].sheets.includes(currentSheet)) return 1;
});
if (validButtons.length !== currentButtons.length) {
const { success, msg, err } = this._Config.changeSetting('enabledButtons', validButtons);
if (success && msg) new ChatDialog({ content: msg, title: 'Buttons Changed' });
else if (err) new ChatDialog({ content: err }, 'error');
}
}
resolveButtonMath(button, damage, crit) {
const buttonType = button.constructor.name;
if (buttonType === 'CustomButton') {
debug.info(button.mathString, MathOpsTransformer.transformMathOpsPayload(damage, crit), MathOpsTransformer.transformMathString(button.mathString));
let mathOpsString = MathOpsTransformer.transformMathString(button.mathString);
const mathOpsDamageKeys = MathOpsTransformer.transformMathOpsPayload(damage, crit);
// MathOps zeroed key patch
mathOpsString = mathOpsZeroPatch ? this.resolveZeroedKeys(mathOpsString, mathOpsDamageKeys) : mathOpsString;
debug.warn(mathOpsString);
let result = MathOps.MathProcessor({ code: mathOpsString, known: mathOpsDamageKeys});
debug.info(result);
return isNaN(result) ? 0 : result;
}
else if (buttonType === 'Button') {
return button.math(damage, crit);
}
}
resolveZeroedKeys(mathOpsString, mathOpsDamageKeys) {
for (const key in mathOpsDamageKeys) {
if (mathOpsDamageKeys[key] === 0) {
const rxReplacer = new RegExp(key, 'g');
mathOpsString = mathOpsString.replace(rxReplacer, '0');
}
}
return mathOpsString;
}
}
/**
* Button - Basic schema of a Button object
*/
class Button {
constructor(buttonData={}, styleData=styles) {
Object.assign(this, {
name: buttonData.name || 'newButton',
sheets: Array.isArray(buttonData.sheets) ? buttonData.sheets : [],
tooltip: `${buttonData.tooltip || ''}`,
style: styleData[buttonData.style] || buttonData.style || '',
style2: styleData[buttonData.style2] || buttonData.style2 || '',
style3: styleData[buttonData.style3] || buttonData.style3 || '',
content: buttonData.content || '?',
content2: buttonData.content2 || '',
content3: buttonData.content3 || '',
math: buttonData.math || null,
mathString: buttonData.mathString,
query: buttonData.query || ``,
default: buttonData.default === false ? false : true,
mathBackup: buttonData.mathBackup || '',
});
debug.log(this);
if (typeof(this.math) !== 'function') return { err: `Button "${this.name}" math function failed validation` };
}
static splitAndEscapeQuery(queryString) {
if (!queryString || typeof(queryString) !== 'string') return ``;
const replacers = {
'*': `*`,
'+': `+`,
}
const replacerFunction = (m) => replacers[m],
rxQuerySplit = /^[+*/-][+-0]?\|/,
rxReplacers = new RegExp(`[${Object.keys(replacers).reduce((out,v) => out += `\\${v}`, ``)}]`, 'g');
let operator = (queryString.match(rxQuerySplit)||[])[0] || ``,
query = queryString.replace(rxQuerySplit, ''),
roundingPre = ``,
roundingPost = ``;
// Deal with rounding for * and /
if (/^[*/]/.test(operator)) {
roundingPre = operator[1] === '+' ?
`ceil(`
: `floor(`
roundingPost = `)`;
}
operator = (operator[0]||``).replace(rxReplacers, replacerFunction);
return query ? `${roundingPre}%%MODIFIER%%${operator}?{${query}}${roundingPost}` : ``;
}
}
/**
* Custom Button - user-made buttons pass through here for validation before being passed to superclass
*/
class CustomButton extends Button {
constructor(buttonData={}) {
debug.info(buttonData);
if (!buttonData.mathString) return { err: `Button must contain a math string.` };
const { success, err } = ButtonManager.validateMathString(buttonData.mathString, buttonData.name);
if (!success) {
return { err };
}
Object.assign(buttonData, {
name: buttonData.name || 'newCustomButton',
mathString: buttonData.mathString,
math: (code, known) => MathOps.MathProcessor({ code: MathOpsTransformer.transformMathString(code), known }),
style: buttonData.style || 'full',
query: buttonData.query || ``,
default: false,
mathBackup: buttonData.mathBackup || buttonData.mathString,
});
super(buttonData);
}
}
/**
* Command Line Interface - handle adding and removing CLI Options, and assess chat input when passed in from HandleInput()
*/
class CommandLineInterface {
_locator = null;
_services = {};
_options = {};
constructor(cliData={}) {
this.name = cliData.name || `Cli`;
this._locator = ServiceLocator.getLocator();
if (!this._locator) debug.warn(`${this.constructor.name} could not find the service locator. Any commands relying on services will be disabled.`);
Object.assign(this._services, {
config: this._locator.getService('ConfigController'),
buttons: this._locator.getService('ButtonManager'),
cli: this,
});
if (cliData.options && cliData.options.length) this.addOptions(cliData.options);
debug.log(`Initialised CLI`);
}
// Add one or more options to the CLI
addOptions(optionData) {
optionData = Helpers.toArray(optionData);
optionData.forEach(data => {
if (data.name && !this._options[data.name]) {
const suppliedServices = { cli: this }
if (data.requiredServices) {
for (let service in data.requiredServices) {
const svc =
service === 'ConfigController' ? this._services.config
: service === 'ButtonManager' ? this._services.buttons
: this._locator.getService(data.requiredServices[service]);
if (svc) suppliedServices[service] = svc;
else return debug.warn(`${this.name}: Warning - Service "${service}" could not be found for option ${data.name}. CLI option not registered.`);
}
}
data.services = suppliedServices;
this._options[data.name] = new CommandLineOption(data);
} else debug.warn(`Bad data supplied to CLI Option constructor`);
});
}
assess(commandArray, reportToChat = true) {
let changed = [], errs = [];
commandArray.forEach(command => {
const cmd = (command.match(/^([^\s]+)/)||[])[1],
args = (command.match(/\s+(.+)/)||['',''])[1];
for (let option in this._options) {
if (this._options[option].rx.test(cmd)) {
const { msg, err } = (this._options[option].action(args) || {});
// debug.log(msg||err);
if (msg) changed.push(Helpers.toArray(msg).join('
')); if (err) errs.push(err); } } }); if (changed.length && reportToChat) { // debug.info(changed); const chatData = { title: `${scriptName} settings changed`, content: changed }; new ChatDialog(chatData); } if (errs.length) new ChatDialog( { title: 'Errors', content: errs }, 'error'); } trigger(option, ...args) { if (this._options[option]) this._options[option].action(...args) } } /** * Command Line Option - basic model for a user-facing CLI option */ class CommandLineOption { constructor(optionData={}) { for (let service in optionData.services) { this[service] = optionData.services[service]; } Object.assign(this, { name: optionData.name || 'newOption', rx: optionData.rx || new RegExp(`${optionData.name}`, 'i'), description: optionData.description || `Description goes here...`, action: optionData.action }); } } /** * Chat Dialog - Short-lived layout class which, by default, is sent straight to chat once constructed. * Can be instantiated and persisted by disabling the default autoSend in the constructor */ class ChatDialog { static _templates = { none: ({content}) => `${content}`, default: ({ title, content }) => { const msgArray = content ? Helpers.toArray(content) : [], body = msgArray.map(row => `
`;
},
table: ({ title, content, footer, borders }) => {
const rowBorders = borders && borders.row ? styles.table.rowBorders : ``;
const msgArray = content ? Helpers.toArray(content) : [],
columns = msgArray[0].length || 1,
tableRows = msgArray.map((row,i) => {
const tc = i === 0 ? 'th' : 'td',
tcStyle = i === 0 ? styles.table.headerCell : `${styles.table.cell}${rowBorders}`,
trStyle = i === 0 ? styles.table.headerRow : styles.table.row;
let cells = ``;
for (let i=0; i < columns; i++) { cells += `<${tc} style="${tcStyle}">${row[i]}` }
return `
${cells}
`;
}).join(''),
footerContent = footer ? `` : ``;
return `
${tableRows}
${footerContent}
`;
},
error: ({ title, content }) => {
const errArray = content ? Helpers.toArray(content) : [];
return `
`;
},
listButtons: ({ header, body, footer }) => {
return `
`;
}
}
constructor(message, template = 'default', autoSend = true) {
this.msg = ChatDialog._templates[template] ? ChatDialog._templates[template](message) : null;
if (this.msg) {
this.msg = this.msg.replace(/\n/g, '');
if (autoSend) Helpers.toChat(this.msg);
} else {
debug.warn(`${scriptName}: error creating chat dialog, missing template "${template}"`);
return {};
}
}
}
on('ready', startScript);
})();
{ try { throw new Error(''); } catch (e) { API_Meta.autoButtons.lineCount = (parseInt(e.stack.split(/\n/)[1].replace(/^.*:(\d+):.*$/, '$1'), 10) - API_Meta.autoButtons.offset); } }
/* */
v${scriptVersion}`, content: menuOptions, footer: footerContent }, 'table'); } } /** * Button Manager - Handles CRUD operations, math/query functions and HTML output for all buttons, both internal and Custom Button */ class ButtonManager { static _buttonKeys = ['sheets', 'content', 'content2', 'content3', 'tooltip', 'style', 'style2', 'style3', 'math', 'default', 'mathString', 'query']; static _editKeys = ['clone', 'rename']; _locator = null; _Config = {}; _buttons = {}; constructor(data={}) { Object.assign(this, { name: data.name || 'newButtonManager' }); // Requires access to a ConfigController this._locator = ServiceLocator.getLocator() || this._locator; this._Config = this._locator ? this._locator.getService('ConfigController') : null; if (!this._Config) return {}; for (let button in data.defaultButtons) { this._buttons[button] = new Button(data.defaultButtons[button], styles) } } get keys() { return ButtonManager._buttonKeys } get editKeys() { return [ ...ButtonManager._buttonKeys, ...ButtonManager._editKeys ]} getButtonNames(filters={ default: null, currentSheet: null, shown: null, hidden: null }) { let buttons = Object.entries(this._buttons); const sheet = this._Config.getSetting('sheet'), enabledButtons = this._Config.getSetting('enabledButtons'); if (typeof filters.default === 'boolean') buttons = buttons.filter(kv => kv[1].default === filters.default); if (typeof filters.currentSheet === 'boolean') buttons = buttons.filter(kv => (!kv[1].sheets.length || sheet === 'custom' || (kv[1].sheets.includes(sheet) === filters.currentSheet))); if (typeof filters.shown === 'boolean') buttons = buttons.filter(kv => (enabledButtons.includes(kv[0]) === filters.shown)); if (typeof filters.hidden === 'boolean') buttons = buttons.filter(kv => (enabledButtons.includes(kv[0]) === !filters.hidden)); const output = buttons.map(kv=>kv[0]); // debug.log(`button names: ${output.join(', ')}`); return output; } static validateMathString(inputString, buttonName) { debug.info(inputString); inputString = `${inputString}`; // Default buttons will send in a JS function, remove the declaration part inputString = inputString.replace(/^.*?=>\s*/, ''); let newFormula = inputString; const mathOpsString = MathOpsTransformer.transformMathString(newFormula); debug.info(mathOpsString); // Create a test object const damageKeyMatches = inputString.match(/damage\.(\w+)/g) || [], critKeyMatches = inputString.match(/crit\.(\w+)/g) || [], damageKeys = damageKeyMatches.reduce((output, key) => ({ ...output, [key.replace(/^[^.]*\./, '')]: 5 }), {}), critKeys = critKeyMatches.reduce((output, key) => ({ ...output, [key.replace(/^[^.]*\./, '')]: 5 }), {}); const { config } = ServiceLocator.getLocator().getService('config'); const damageProperties = Object.values(config.getSetting('templates/damageProperties')).reduce((output, category) => [ ...output, ...category ], []); const invalidProperties = [ ...Object.keys(damageKeys), ...Object.keys(critKeys) ].filter(key => !(damageProperties.includes(key))); const mathOpsKeys = MathOpsTransformer.transformMathOpsPayload(damageKeys, critKeys); debug.info(mathOpsKeys); let error; try { const testResult = MathOps.MathProcessor({ code: mathOpsString, known: mathOpsKeys }); debug.info(testResult); if (testResult.message) { error = testResult.message; } else if (isNaN(testResult)) { error = `The supplied math did not return a number: ${inputString}`; } } catch(e) { error = `Math failed validation - ${e}`; } if (invalidProperties.length) new ChatDialog({ title: `Button Warning: "${buttonName}"`, content: `The following damage properties in the button are not set up in this game: ${invalidProperties.join(', ')}` }, 'error'); return error ? { success: false, err: error } : { success: true, err: null } } addButton(buttonData={}) { const newButton = buttonData.default === false ? new CustomButton(buttonData) : new Button(buttonData); debug.warn(newButton); if (newButton.err || !newButton.math) return { success: 0, err: newButton.err || `Button ${buttonData.name} could not be created.` } if (this._buttons[newButton.name]) return { success: 0, err: `Button "${newButton.name}" already exists` }; this._buttons[newButton.name] = newButton; this.saveToStore(); return { success: 1, msg: `New Button "${newButton.name}" successfully created` } } editButton(buttonData={}) { const modded = []; if (!this._buttons[buttonData.name]) return { success: 0, err: `Button "${buttonData.name}" does not exist.` } if (this._buttons[buttonData.name].default) return { success: 0, err: `Cannot edit default buttons.` } this.editKeys.forEach(k => { debug.log(k, buttonData[k]); if (buttonData[k] != null) { if (k === 'default') return; // Don't allow reassignment of 'default' property else if (k === 'math') { const { success, err } = ButtonManager.validateMathString(buttonData[k], buttonData.name); if (!success) return { err }; else { this._buttons[buttonData.name].mathString = buttonData[k]; modded.push(k); } } else if (/^style/.test(k)) { this._buttons[buttonData.name][k] = styles[buttonData[k]] || buttonData[k] || ''; modded.push(k); } // else if (k === 'query') { // this._buttons[buttonData.name].query = Button.splitAndEscapeQuery(buttonData.query); // modded.push(k); // } else { this._buttons[buttonData.name][k] = buttonData[k]; modded.push(k); } } }); if (modded.length) this.saveToStore(); return modded.length ? { success: 1, msg: `Modified ${buttonData.name} fields: ${modded.join(', ')}` } : { success: 0, err: `No fields supplied.` } } removeButton(buttonName) { if (!this._buttons[buttonName]) return { success: 0, err: `Button "${buttonName}" does not exist.` } if (this._buttons[buttonName].default) return { success: 0, err: `Cannot delete default buttons.` } delete this._buttons[buttonName]; this._Config.toStore(`customButtons/${buttonName}`, null); return { success: 1, msg: `Removed "${buttonName}".` } } cloneButton(originalButtonName, newButtonName) { if (this._buttons[originalButtonName] && newButtonName) { const cloneName = /\s/.test(newButtonName) ? Helpers.camelise(newButtonName) : newButtonName, cloneData = { ...this._buttons[originalButtonName], name: cloneName, default: false }, copyResult = this.addButton(cloneData); return copyResult.success ? { success: 1, msg: `Cloned button ${originalButtonName} => ${cloneName}` } : copyResult; } else return { err: `Could not find button "${originalButtonName}", or bad clone button name "${newButtonName}"` } } renameButton(originalButtonName, newButtonName) { if (!this._buttons[originalButtonName]) return { success: 0, err: `Button "${originalButtonName}" could not be found` }; if (this._buttons[originalButtonName].default) return { success: 0, err: `Cannot rename a default button.` }; const cloneName = /\s/.test(newButtonName) ? Helpers.camelise(newButtonName) : newButtonName, cloneResult = this.cloneButton(originalButtonName, cloneName); if (cloneResult.success) { this.removeButton(originalButtonName); return { success: 1, msg: `Renamed button ${originalButtonName} => ${cloneName}` }; } else return cloneResult; } showButton(buttonName) { if (this._buttons[buttonName] && !this._Config.getSetting('enabledButtons').includes(buttonName)) { return this._Config.changeSetting('enabledButtons', buttonName) } } hideButton(buttonName) { if (this._buttons[buttonName] && this._Config.getSetting('enabledButtons').includes(buttonName)) { return this._Config.changeSetting('enabledButtons', buttonName) } } saveToStore() { const customButtons = this.getButtonNames({default: false}); customButtons.forEach(button => this._Config.toStore(`customButtons/${button}`, Helpers.copyObj(this._buttons[button]))); } _getReportTemplate(barNumber) { const template = `'*({name}) {bar${barNumber}_value;before}HP -> {bar${barNumber}_value}HP*'`; return template; // Styled report template for if Aaron implements decoding in TM // const templateRaw = `''`; // return encodeURIComponent(templateRaw); // !token-mod --set bar1_value|-[[floor(query*17)]]! } _getImageIcon(buttonName, cacheBust, version = '2a') { if (!cacheBusted) { cacheBust = true; } const url = `https://raw.githubusercontent.com/ooshhub/autoButtons/main/assets/imageIcons/${buttonName}.png?${version}`.replace(/%/g, 'P'); return cacheBust ? `${url}${Math.floor(Math.random()*1000000000)}` : url; // May need to switch to this if images move // return styles.imageIcons[buttonName]; } createApiButton(buttonName, damage, crit) { // debug.info(this._buttons[buttonName]); const btn = this._buttons[buttonName], autoHide = this._Config.getSetting(`autohide`), bar = this._Config.getSetting('hpBar'), overheal = this._Config.getSetting('overheal'), overkill = this._Config.getSetting('overkill'), sendReport = (this._Config.getSetting('report')||``).toLowerCase(), reportString = [ 'all', 'gm', 'control' ].includes(sendReport) ? ` --report ${sendReport}|${this._getReportTemplate(bar)}` : ``, darkMode = this._Config.getSetting('darkMode'); const zeroBound = this._Config.getSetting('allowNegatives') ? false : true, boundingPre = zeroBound ? `{0, ` : ``, boundingPost = zeroBound ? `}kh1` : ``; const queryString = Button.splitAndEscapeQuery(btn.query) || ''; if (!btn || typeof(btn.math) !== 'function') { debug.error(`${scriptName}: error creating API button ${buttonName}`); return ``; } const modifier = this.resolveButtonMath(btn, damage, crit), tooltip = btn.tooltip.replace(/%/, `${modifier} HP`), setWithQuery = queryString ? `[[${boundingPre}${queryString.replace(/%%MODIFIER%%/g, Math.abs(modifier))}${boundingPost}]]` : `${Math.abs(modifier)}`, tokenModCmd = (modifier > 0) ? (!overheal) ? `+${setWithQuery}!` : `+${setWithQuery}` : (modifier < 0 && !overkill) ? `-${setWithQuery}!` : `-${setWithQuery}`, selectOrTarget = (this._Config.getSetting('targetTokens') === true) ? `--ids @{target|token_id} ` : ``, buttonHref = `!token-mod ${selectOrTarget}--set bar${bar}_value|${tokenModCmd}${reportString}`, useImageIcon = this._Config.getSetting('imageIcons') && btn.default, buttonContent = useImageIcon ? `
')); if (err) errs.push(err); } } }); if (changed.length && reportToChat) { // debug.info(changed); const chatData = { title: `${scriptName} settings changed`, content: changed }; new ChatDialog(chatData); } if (errs.length) new ChatDialog( { title: 'Errors', content: errs }, 'error'); } trigger(option, ...args) { if (this._options[option]) this._options[option].action(...args) } } /** * Command Line Option - basic model for a user-facing CLI option */ class CommandLineOption { constructor(optionData={}) { for (let service in optionData.services) { this[service] = optionData.services[service]; } Object.assign(this, { name: optionData.name || 'newOption', rx: optionData.rx || new RegExp(`${optionData.name}`, 'i'), description: optionData.description || `Description goes here...`, action: optionData.action }); } } /** * Chat Dialog - Short-lived layout class which, by default, is sent straight to chat once constructed. * Can be instantiated and persisted by disabling the default autoSend in the constructor */ class ChatDialog { static _templates = { none: ({content}) => `${content}`, default: ({ title, content }) => { const msgArray = content ? Helpers.toArray(content) : [], body = msgArray.map(row => `
${row}
`).join('')
return `
${title||scriptName}
${body}
${title||scriptName}
${title}
${errArray.join('
')}
')}