discord-coc-bot
Version:
A Discord bot that contains commands useful for Call of Cthulu text roleplaying, based on RPbot by Gawdl3y (https://github.com/Gawdl3y/discord-rpbot/)
382 lines (325 loc) • 9.01 kB
JavaScript
'use babel';
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _discordGraf = require('discord-graf');
var _character = require('../../database/character');
var _character2 = _interopRequireDefault(_character);
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);
}
};
}
};
class ViewCharacterCommand extends _discordGraf.Command {
constructor(bot) {
super(bot, {
name: 'character',
aliases: ['view-character', 'show-character', 'char'],
module: 'characters',
memberName: 'view',
description: 'Views a character\'s information.',
usage: 'character <name>',
details: 'The name can be the whole name of the character, or just a part of it.',
examples: ['character Billy McBillface', 'character bill'],
guildOnly: true
});
}
run(message, args) {
return new Promise(function ($return, $error) {
let characters;
if (!args[0]) return $error(new _discordGraf.CommandFormatError(this, message.guild));
return _character2.default.findInGuild(message.guild, args[0]).then(function ($await_4) {
characters = $await_4;
if (characters.length === 1) {
let ownerName;
var $Try_1_Post = function () {
return $return(`Character **${characters[0].name}** (created by ${ownerName}):\n${characters[0].info}`);
}.$asyncbind(this, $error);var $Try_1_Catch = function (err) {
ownerName = 'Unknown';
return $Try_1_Post();
}.$asyncbind(this, $error);
try {
let owner;
return message.client.fetchUser(characters[0].owner).then(function ($await_5) {
owner = $await_5;
ownerName = `${owner.username}#${owner.discriminator}`;
var $Try_2_Post = function () {
ownerName = this.bot.util.escapeMarkdown(ownerName);
return $Try_1_Post();
}.$asyncbind(this, $Try_1_Catch);var $Try_2_Catch = function (err2) {
// do nothing
return $Try_2_Post();
}.$asyncbind(this, $Try_1_Catch);try {
let member;
return message.guild.fetchMember(owner).then(function ($await_6) {
member = $await_6;
if (member.nickname) ownerName = `${member.nickname} (${ownerName})`;
return $Try_2_Post();
}.$asyncbind(this, $Try_2_Catch), $Try_2_Catch);
} catch (err2) {
$Try_2_Catch(err2)
}
}.$asyncbind(this, $Try_1_Catch), $Try_1_Catch);
} catch (err) {
$Try_1_Catch(err)
}
} else {
if (characters.length > 1) {
return $return(this.bot.util.disambiguation(characters, 'characters'));
} else {
return $return(`Unable to find character. Use ${this.bot.util.usage('characters', message.guild)} to view the list of characters.`);
}
return $If_3.call(this);
}
function $If_3() {
return $return();
}
return $If_3.call(this);
}.$asyncbind(this, $error), $error);
}.$asyncbind(this));
}
}
exports.default = ViewCharacterCommand;
//# sourceMappingURL=view.js.map