discord-coc-bot/lib/rpbot.js

A Discord bot that contains commands useful for Call of Cthulu text roleplaying, based on RPbot by Gawdl3y (https://github.com/Gawdl3y/discord-rpbot/)

#!/usr/bin/env node

'use babel';
'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.client = undefined;

var _discordGraf = require('discord-graf');

var _bot = require('./bot');

var _bot2 = _interopRequireDefault(_bot);

var _config = require('./config');

var _config2 = _interopRequireDefault(_config);

var _version = require('./version');

var _version2 = _interopRequireDefault(_version);

var _database = require('./database');

var db = _interopRequireWildcard(_database);

var _character = require('./database/character');

var _character2 = _interopRequireDefault(_character);

var _analytics = require('./util/analytics');

var analytics = _interopRequireWildcard(_analytics);

var _diceExpressionEvaluator = require('dice-expression-evaluator');

var _diceExpressionEvaluator2 = _interopRequireDefault(_diceExpressionEvaluator);

var _list = require('./commands/characters/list');

var _list2 = _interopRequireDefault(_list);

var _view = require('./commands/characters/view');

var _view2 = _interopRequireDefault(_view);

var _add = require('./commands/characters/add');

var _add2 = _interopRequireDefault(_add);

var _delete = require('./commands/characters/delete');

var _delete2 = _interopRequireDefault(_delete);

var _clear = require('./commands/characters/clear');

var _clear2 = _interopRequireDefault(_clear);

var _roll = require('./commands/dice/roll');

var _roll2 = _interopRequireDefault(_roll);

var _max = require('./commands/dice/max');

var _max2 = _interopRequireDefault(_max);

var _min = require('./commands/dice/min');

var _min2 = _interopRequireDefault(_min);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

Function.prototype.$asyncbind = function $asyncbind(self, catcher) {
	"use strict";

	if (!Function.prototype.$asyncbind) {
		Object.defineProperty(Function.prototype, "$asyncbind", {
			value: $asyncbind,
			enumerable: false,
			configurable: true,
			writable: true
		});
	}

	if (!$asyncbind.trampoline) {
		$asyncbind.trampoline = function trampoline(t, x, s, e, u) {
			return function b(q) {
				while (q) {
					if (q.then) {
						q = q.then(b, e);
						return u ? undefined : q;
					}

					try {
						if (q.pop) {
							if (q.length) return q.pop() ? x.call(t) : q;
							q = s;
						} else q = q.call(t);
					} catch (r) {
						return e(r);
					}
				}
			};
		};
	}

	if (!$asyncbind.LazyThenable) {
		$asyncbind.LazyThenable = function () {
			function isThenable(obj) {
				return obj && obj instanceof Object && typeof obj.then === "function";
			}

			function resolution(p, r, how) {
				try {
					var x = how ? how(r) : r;
					if (p === x) return p.reject(new TypeError("Promise resolution loop"));

					if (isThenable(x)) {
						x.then(function (y) {
							resolution(p, y);
						}, function (e) {
							p.reject(e);
						});
					} else {
						p.resolve(x);
					}
				} catch (ex) {
					p.reject(ex);
				}
			}

			function _unchained(v) {}

			function thenChain(res, rej) {
				this.resolve = res;
				this.reject = rej;
			}

			function Chained() {}

			;
			Chained.prototype = {
				resolve: _unchained,
				reject: _unchained,
				then: thenChain
			};

			function then(res, rej) {
				var chain = new Chained();

				try {
					this._resolver(function (value) {
						return isThenable(value) ? value.then(res, rej) : resolution(chain, value, res);
					}, function (ex) {
						resolution(chain, ex, rej);
					});
				} catch (ex) {
					resolution(chain, ex, rej);
				}

				return chain;
			}

			function Thenable(resolver) {
				this._resolver = resolver;
				this.then = then;
			}

			;

			Thenable.resolve = function (v) {
				return Thenable.isThenable(v) ? v : {
					then: function (resolve) {
						return resolve(v);
					}
				};
			};

			Thenable.isThenable = isThenable;
			return Thenable;
		}();

		$asyncbind.EagerThenable = $asyncbind.Thenable = ($asyncbind.EagerThenableFactory = function (tick) {
			tick = tick || typeof process === "object" && process.nextTick || typeof setImmediate === "function" && setImmediate || function (f) {
				setTimeout(f, 0);
			};

			var soon = function () {
				var fq = [],
				    fqStart = 0,
				    bufferSize = 1024;

				function callQueue() {
					while (fq.length - fqStart) {
						try {
							fq[fqStart]();
						} catch (ex) {}

						fq[fqStart++] = undefined;

						if (fqStart === bufferSize) {
							fq.splice(0, bufferSize);
							fqStart = 0;
						}
					}
				}

				return function (fn) {
					fq.push(fn);
					if (fq.length - fqStart === 1) tick(callQueue);
				};
			}();

			function Zousan(func) {
				if (func) {
					var me = this;
					func(function (arg) {
						me.resolve(arg);
					}, function (arg) {
						me.reject(arg);
					});
				}
			}

			Zousan.prototype = {
				resolve: function (value) {
					if (this.state !== undefined) return;
					if (value === this) return this.reject(new TypeError("Attempt to resolve promise with self"));
					var me = this;

					if (value && (typeof value === "function" || typeof value === "object")) {
						try {
							var first = 0;
							var then = value.then;

							if (typeof then === "function") {
								then.call(value, function (ra) {
									if (!first++) {
										me.resolve(ra);
									}
								}, function (rr) {
									if (!first++) {
										me.reject(rr);
									}
								});
								return;
							}
						} catch (e) {
							if (!first) this.reject(e);
							return;
						}
					}

					this.state = STATE_FULFILLED;
					this.v = value;
					if (me.c) soon(function () {
						for (var n = 0, l = me.c.length; n < l; n++) STATE_FULFILLED(me.c[n], value);
					});
				},
				reject: function (reason) {
					if (this.state !== undefined) return;
					this.state = STATE_REJECTED;
					this.v = reason;
					var clients = this.c;
					if (clients) soon(function () {
						for (var n = 0, l = clients.length; n < l; n++) STATE_REJECTED(clients[n], reason);
					});
				},
				then: function (onF, onR) {
					var p = new Zousan();
					var client = {
						y: onF,
						n: onR,
						p: p
					};

					if (this.state === undefined) {
						if (this.c) this.c.push(client);else this.c = [client];
					} else {
						var s = this.state,
						    a = this.v;
						soon(function () {
							s(client, a);
						});
					}

					return p;
				}
			};

			function STATE_FULFILLED(c, arg) {
				if (typeof c.y === "function") {
					try {
						var yret = c.y.call(undefined, arg);
						c.p.resolve(yret);
					} catch (err) {
						c.p.reject(err);
					}
				} else c.p.resolve(arg);
			}

			function STATE_REJECTED(c, reason) {
				if (typeof c.n === "function") {
					try {
						var yret = c.n.call(undefined, reason);
						c.p.resolve(yret);
					} catch (err) {
						c.p.reject(err);
					}
				} else c.p.reject(reason);
			}

			Zousan.resolve = function (val) {
				if (val && val instanceof Zousan) return val;
				var z = new Zousan();
				z.resolve(val);
				return z;
			};

			Zousan.reject = function (err) {
				if (err && err instanceof Zousan) return err;
				var z = new Zousan();
				z.reject(err);
				return z;
			};

			Zousan.version = "2.3.3-nodent";
			return Zousan;
		})();
	}

	function boundThen() {
		return resolver.apply(self, arguments);
	}

	var resolver = this;

	switch (catcher) {
		case true:
			return new $asyncbind.Thenable(boundThen);

		case 0:
			return new $asyncbind.LazyThenable(boundThen);

		case undefined:
			boundThen.then = boundThen;
			return boundThen;

		default:
			return function () {
				try {
					return resolver.apply(self, arguments);
				} catch (ex) {
					return catcher(ex);
				}
			};
	}
};

_bot2.default.logger.info(`RPBot v${_version2.default} is starting...`);
analytics.sendEvent('Bot', 'started');

// Create bot
const client = exports.client = _bot2.default.registerDefaults().registerModules([['characters', 'Characters'], ['dice', 'Dice']]).registerCommands([_list2.default, _view2.default, _add2.default, _delete2.default, _clear2.default, _roll2.default, _max2.default, _min2.default]).registerEvalObjects({
	db: db,
	Character: _character2.default,
	config: _config2.default,
	version: _version2.default,
	dice: _diceExpressionEvaluator2.default
}).createClient();

// Set up command analytics
_bot2.default.dispatcher.on('commandRun', command => {
	analytics.sendEvent('Command', 'run', `${command.module}:${command.memberName}`);
}).on('commandError', (command, err) => {
	if (!(err instanceof _discordGraf.FriendlyError)) analytics.sendException(err);
});

// Set up database
db.init().catch(err => {
	_bot2.default.logger.error(err);
	process.exit(1);
});

// Exit on interrupt
let interruptCount = 0;
process.on('SIGINT', () => new Promise(function ($return, $error) {
	interruptCount++;
	if (interruptCount === 1) {
		_bot2.default.logger.info('Received interrupt signal; closing database, destroying client, and exiting...');
		return Promise.all([db.close(), client.destroy()]).catch(err => {
			_bot2.default.logger.error(err);
		}).then(function ($await_2) {
			process.exit(0);
			return $If_1.call(this);
		}.$asyncbind(this, $error), $error);
	} else {
		_bot2.default.logger.info('Received another interrupt signal; immediately exiting.');
		process.exit(0);
		return $If_1.call(this);
	}

	function $If_1() {
		return $return();
	}
}));
//# sourceMappingURL=rpbot.js.map