updated file names

dist/discord.js

@@ -7,13 +7,12 @@ const v9_1 = require("discord-api-types/v9");
 const commands = [
     {
         name: 'queue',
-        description: 'create a queue',
+        description: 'get queue info or initialize a queue for this channel',
         options: [
             {
                 type: 4,
                 name: 'teamsize',
                 description: 'size of each team',
-                required: true,
                 min_value: 1
             }
         ]
@@ -27,12 +26,8 @@ const commands = [
         description: 'leave the active queue'
     },
     {
-        name: 'ready',
+        name: 'stop',
-        description: 'ready the queue and display team info'
+        description: 'stops the current queue (must have the Manage Messages permission)'
-    },
-    {
-        name: 'cancel',
-        description: 'cancels the current queue (must have the Manage Messages permission)'
     },
     {
         name: 'player',

dist/index.js

@@ -29,31 +29,30 @@ const CLIENT = new discord_js_1.Client({ intents: [discord_js_1.Intents.FLAGS.GU
 //init logs with a timestamp
 console.log(new Date().toISOString() + '\n\n');
 //get token
-if (!fs.existsSync('./token')) {
+if (!fs.existsSync('./token.txt')) {
-    fs.writeFileSync('./token', '');
+    fs.writeFileSync('./token.txt', '');
     console.error('Missing Discord Token, please enter the bot token into the token file');
     process.exit(1);
 }
-const TOKEN = fs.readFileSync('./token').toString();
+const TOKEN = fs.readFileSync('./token.txt').toString();
 //discord connections
 CLIENT.on('ready', client => {
     console.log(`Logged in as ${client.user.tag}`);
     client.guilds.fetch().then(guilds => (0, discord_1.registerCommands)(TOKEN, client.user.id, guilds.map(g => g.id)));
+    (0, queue_1.discordInit)(client);
 });
 CLIENT.on('interactionCreate', async (interaction) => {
     if (!interaction.isCommand())
         return;
     try {
         if (interaction.commandName === 'queue')
-            await (0, queue_1.createQueue)(interaction);
+            await queue_1.QueueCommands.queue(interaction);
         else if (interaction.commandName === 'join')
-            await (0, queue_1.joinQueue)(interaction);
+            await queue_1.QueueCommands.join(interaction);
         else if (interaction.commandName === 'leave')
-            await (0, queue_1.leaveQueue)(interaction);
+            await queue_1.QueueCommands.leave(interaction);
-        else if (interaction.commandName === 'ready')
+        else if (interaction.commandName === 'stop')
-            await (0, queue_1.readyQueue)(interaction);
+            await queue_1.QueueCommands.stop(interaction);
-        else if (interaction.commandName === 'cancel')
-            await (0, queue_1.cancelQueue)(interaction);
         else if (interaction.commandName === 'player')
             await (0, api_1.getPlayerInteraction)(interaction);
     }

dist/queue.js

@@ -1,189 +1,218 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+/* TODO
-exports.cancelQueue = exports.readyQueue = exports.leaveQueue = exports.joinQueue = exports.createQueue = exports.queueContains = exports.getAll = exports.getInfo = void 0;
+
-const discord_js_1 = require("discord.js");
+join message should contain your current position in the queue, editing it to keep it current
-const util_1 = require("./util");
+*/
-//maps ChannelID to QueueInfo
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-const QUEUE = new Map();
+    if (k2 === undefined) k2 = k;
-/**
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
- * get the queueInfo of an interaction
+}) : (function(o, m, k, k2) {
- * @param interaction
+    if (k2 === undefined) k2 = k;
- * @throws errorMessage class if it does not exist
+    o[k2] = m[k];
- * @returns queue info
+}));
- */
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-function getInfo(interaction) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
-    let info = QUEUE.get(interaction.channelId);
+}) : function(o, v) {
-    if (!info)
+    o["default"] = v;
-        throw (0, util_1.emsg)('There is not an active queue in this channel, type `/queue` to create one');
-    return info;
-}
-exports.getInfo = getInfo;
-/**
- * compiles all the get functions above
- * @param interaction
- * @throws if another get function throws
- * @returns object containing each
- */
-const getAll = (interaction) => ({
-    member: (0, util_1.getMember)(interaction),
-    channel: (0, util_1.getChannel)(interaction),
-    info: getInfo(interaction)
 });
-exports.getAll = getAll;
+var __importStar = (this && this.__importStar) || function (mod) {
-/**
+    if (mod && mod.__esModule) return mod;
- * checks if the interaction data is already in the queue
+    var result = {};
- * @param interaction
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- * @returns boolean
+    __setModuleDefault(result, mod);
- */
+    return result;
-function queueContains(interaction) {
+};
-    let { member, info } = (0, exports.getAll)(interaction);
+Object.defineProperty(exports, "__esModule", { value: true });
-    if (info.players.map(m => m.id).includes(member.id))
+exports.QueueCommands = exports.discordInit = void 0;
-        return true;
+const discord_js_1 = require("discord.js");
-    return false;
+const fs = __importStar(require("fs"));
+const util_1 = require("./util");
+//load queues from file
+if (!fs.existsSync('./queues.json'))
+    fs.writeFileSync('./queues.json', '{}');
+const _QUEUE = fs.readFileSync('./queues.json').toString(), QUEUE = new Map();
+try {
+    let queueJson = JSON.parse(_QUEUE);
+    for (let channelId of queueJson) {
+        let { teamsize } = queueJson[channelId];
+        if (teamsize)
+            QUEUE.set(channelId, { teamsize, players: [] });
+    }
 }
-exports.queueContains = queueContains;
+catch (e) { }
-/**
+function SaveQueue() {
- * creates the timeout for the queue
+    let queueJson = Object.fromEntries(QUEUE), queueFileJson = {};
- * @param interaction
+    for (let channelId in QUEUE.keys())
- * @returns time timeout identifier
+        queueFileJson[channelId] = { teamsize: queueJson[channelId].teamsize };
- */
+    fs.writeFileSync('./queues.json', JSON.stringify(queueFileJson, null, 2));
-function setQueueTimeout(interaction) {
-    let channel = (0, util_1.getChannel)(interaction);
-    return setTimeout(() => {
-        clearQueue(interaction);
-        channel.send('Queue has been reset due to inactivity');
-    }, 5 * 60 * 1000); //5 minutes
 }
-/**
+async function checkQueue(channel) {
- * updates the rich embed for the current queue
+    let info = QUEUE.get(channel.id);
- * @param interaction
+    if (!info)
- */
+        return;
-async function sendQueueEmbed(interaction, closed = false) {
+    if (info.players.length > info.teamsize) {
-    let info = getInfo(interaction), origInteraction = info.initiator.interaction;
+        let team = info.players.splice(0, info.teamsize).map(m => m.toString());
-    let embed = new discord_js_1.MessageEmbed()
+        let embed = new discord_js_1.MessageEmbed()
-        .setTitle('Queue')
+            .setTitle('Team')
-        .setAuthor({
+            .setDescription(team.join('\n'));
-        name: info.initiator.member.displayName,
+        await channel.send({ embeds: [embed] });
-        iconURL: info.initiator.member.displayAvatarURL({ dynamic: true })
+    }
-    })
-        .addField('Team Size', info.teamsize.toString(), true)
-        .addField('Players Joined', info.players.length.toString(), true)
-        .setFooter({ text: closed ? 'queue is finished' : 'type /join' });
-    if (origInteraction.deferred || origInteraction.replied)
-        await origInteraction.editReply({ embeds: [embed] });
-    else
-        await origInteraction.reply({ embeds: [embed] });
 }
-/**
+var Queue;
- * sends the list of teams
+(function (Queue) {
- * @param interaction
+    function create(channelId, teamsize) {
- */
+        if (!QUEUE.has(channelId)) {
-async function sendTeamsEmbed(interaction, teams) {
+            QUEUE.set(channelId, { teamsize, players: [] });
-    let embed = new discord_js_1.MessageEmbed()
+            SaveQueue();
-        .setTitle('Teams');
+        }
-    teams.forEach((team, i) => {
+    }
-        team.map(m => m.user.tag);
+    Queue.create = create;
-        embed.addField(`Title ${i + 1}`, team.join('\n'));
+    function remove(channelId) {
+        if (QUEUE.has(channelId)) {
+            QUEUE.delete(channelId);
+            SaveQueue();
+        }
+    }
+    Queue.remove = remove;
+    function addPlayer(channelId, member) {
+        if (QUEUE.has(channelId)) {
+            QUEUE.delete(channelId);
+        }
+    }
+    Queue.addPlayer = addPlayer;
+    function removePlayer(channelId, member) {
+        if (QUEUE.has(channelId)) {
+            QUEUE.delete(channelId);
+        }
+    }
+    Queue.removePlayer = removePlayer;
+})(Queue || (Queue = {}));
+SaveQueue();
+async function discordInit(client) {
+    for (let channelId in QUEUE.keys()) {
+        let info = QUEUE.get(channelId), channel = await client.channels.fetch(channelId);
+        if (!info) { //no idea what could cause this but TS complains
+            Queue.remove(channelId);
+            continue;
+        }
+        if (!channel || !(channel instanceof discord_js_1.TextChannel)) {
+            console.error(`Unable to find channel ${channelId} for teams of ${info?.teamsize}`);
+            Queue.remove(channelId);
+            continue;
+        }
+        channel.send('The bot has just restarted and anybody in the queues have been reset');
+    }
+}
+exports.discordInit = discordInit;
+var QueueCommands;
+(function (QueueCommands) {
+    /**
+     * get the queueInfo of an interaction
+     * @param interaction
+     * @throws errorMessage class if it does not exist
+     * @returns queue info
+     */
+    function getInfo(interaction) {
+        let info = QUEUE.get(interaction.channelId);
+        if (!info)
+            throw (0, util_1.emsg)('There is not an active queue in this channel, type `/queue` to create one');
+        return info;
+    }
+    /**
+     * compiles all the get functions above
+     * @param interaction
+     * @throws if another get function throws
+     * @returns object containing each
+     */
+    const getAll = (interaction) => ({
+        member: (0, util_1.getMember)(interaction),
+        channel: (0, util_1.getChannel)(interaction),
+        info: getInfo(interaction)
     });
-    interaction.reply({ embeds: [embed] });
+    /**
-}
+     * checks if the interaction data is already in the queue
-/**
+     * @param interaction
- * sends the list of teams
+     * @returns boolean
- * @param interaction
+     */
- */
+    function queueContains(interaction) {
-async function clearQueue(interaction) {
+        let { member, info } = getAll(interaction);
-    let info = getInfo(interaction);
+        if (info.players.map(m => m.id).includes(member.id))
-    sendQueueEmbed(interaction, true);
+            return true;
-    clearTimeout(info.timeout);
+        return false;
-    QUEUE.delete(interaction.channelId);
+    }
-}
+    QueueCommands.queueContains = queueContains;
-/**
+    /**
- * creates a queue from an interaction
+     * creates a queue from an interaction
- * @param interaction
+     * @param interaction
- * @throws errorMessage class if it cannot be created
+     * @throws errorMessage class if it cannot be left
- */
+     */
-async function createQueue(interaction) {
+    function queueCreate(interaction) {
-    let member = (0, util_1.getMember)(interaction), { channelId } = interaction, teamsize = interaction.options.getInteger('teamsize', true);
+        (0, util_1.memberIsModThrow)(interaction);
-    if (QUEUE.has(channelId))
+        let { channelId } = interaction, teamsize = interaction.options.getInteger('teamsize', true);
-        throw (0, util_1.emsg)('There is already an active queue in this channel, ' + (queueContains(interaction) ? 'and you are already in it' : 'type `/join` to join'));
+        if (QUEUE.has(channelId))
-    QUEUE.set(channelId, {
+            throw (0, util_1.emsg)(`There is already an active queue in this channel for teams of ${QUEUE.get(channelId)?.teamsize}`);
-        players: [
+        Queue.create(channelId, teamsize);
-            member
+        interaction.reply(`A queue for teams of ${teamsize} has been started`);
-        ],
+    }
-        initiator: {
+    QueueCommands.queueCreate = queueCreate;
-            interaction,
+    /**
-            member
+     * creates a queue from an interaction
-        },
+     * @param interaction
-        teamsize: teamsize,
+     * @throws errorMessage class if it cannot be left
-        timeout: setQueueTimeout(interaction)
+     */
-    });
+    async function queue(interaction) {
-    sendQueueEmbed(interaction);
+        let teamsize = interaction.options.getInteger('teamsize');
-}
+        if (teamsize) {
-exports.createQueue = createQueue;
+            queueCreate(interaction);
-/**
+            return;
- * joins a queue from an interaction
+        }
- * @param interaction
+        let info = getInfo(interaction);
- * @throws errorMessage class if it cannot be joined
+        let embed = new discord_js_1.MessageEmbed()
- */
+            .setTitle('Active Queue')
-async function joinQueue(interaction) {
+            .addField('Team Size', info.teamsize.toString(), true)
-    let { member, info } = (0, exports.getAll)(interaction);
+            .addField('Players Joined', info.players.length.toString(), true)
-    if (queueContains(interaction))
+            .setFooter({ text: 'type /join' });
-        throw (0, util_1.emsg)('You are already in the active queue');
+        await interaction.reply({ embeds: [embed], ephemeral: true });
-    info.players.push(member);
+    }
-    clearTimeout(info.timeout);
+    QueueCommands.queue = queue;
-    info.timeout = setQueueTimeout(interaction);
+    /**
-    QUEUE.set(interaction.channelId, info);
+     * stops a queue from an interaction
-    sendQueueEmbed(interaction);
+     * @param interaction
-    await interaction.reply('Joined the queue');
+     * @throws errorMessage class if it cannot be joined
-}
+     */
-exports.joinQueue = joinQueue;
+    async function stop(interaction) {
-/**
+        (0, util_1.memberIsModThrow)(interaction);
- * leaves a queue from an interaction
+        QUEUE.delete(interaction.channelId);
- * @param interaction
+        await interaction.reply('Queue has been reset');
- * @throws errorMessage class if it cannot be left
+    }
- */
+    QueueCommands.stop = stop;
-async function leaveQueue(interaction) {
+    /**
-    let { member, info } = (0, exports.getAll)(interaction);
+     * joins a queue from an interaction
-    if (!queueContains(interaction))
+     * @param interaction
-        throw (0, util_1.emsg)('You aren\'t in the active queue');
+     * @throws errorMessage class if it cannot be readied
-    info.players.splice(info.players.indexOf(member), 1);
+     */
-    clearTimeout(info.timeout);
+    async function join(interaction) {
-    info.timeout = setQueueTimeout(interaction);
+        let { member, info, channel } = getAll(interaction);
-    QUEUE.set(interaction.channelId, info);
+        if (queueContains(interaction))
-    sendQueueEmbed(interaction);
+            throw (0, util_1.emsg)('You are already in the queue');
-    await interaction.reply('Left the queue');
+        info.players.push(member);
-}
+        QUEUE.set(interaction.channelId, info);
-exports.leaveQueue = leaveQueue;
+        await interaction.reply('Joined the queue');
-/**
+        checkQueue(channel);
- * readys a queue from an interaction
+    }
- * @param interaction
+    QueueCommands.join = join;
- * @throws errorMessage class if it cannot be readied
+    /**
- */
+     * leaves a queue from an interaction
-async function readyQueue(interaction) {
+     * @param interaction
-    let { member, info } = (0, exports.getAll)(interaction), { initiator } = info;
+     * @throws errorMessage class if it cannot be reset
-    if (member.id !== initiator.member.id)
+     */
-        throw (0, util_1.emsg)('Only the queue initiator can ready the queue');
+    async function leave(interaction) {
-    clearQueue(interaction);
+        let { member, info } = getAll(interaction);
-    if (info.players.filter(m => m.id !== initiator.member.id).length === 0)
+        if (!queueContains(interaction))
-        throw (0, util_1.emsg)('Nobody signed up for the queue, the queue has been reset');
+            throw (0, util_1.emsg)('You aren\'t in the queue');
-    //team data
+        info.players.splice(info.players.indexOf(member), 1);
-    let playerlist = (0, util_1.shuffle)(info.players), teams = [];
+        QUEUE.set(interaction.channelId, info);
-    //fill team data
+        await interaction.reply('Left the queue');
-    for (let i = 0; i < playerlist.length; i += info.teamsize)
+    }
-        teams.push(playerlist.slice(i, i + info.teamsize));
+    QueueCommands.leave = leave;
-    sendTeamsEmbed(interaction, teams);
+})(QueueCommands = exports.QueueCommands || (exports.QueueCommands = {}));
-}
-exports.readyQueue = readyQueue;
-/**
- * readys a queue from an interaction
- * @param interaction
- * @throws errorMessage class if it cannot be reset
- */
-async function cancelQueue(interaction) {
-    let { info, member, channel } = (0, exports.getAll)(interaction);
-    if (!member.permissionsIn(channel).has('MANAGE_MESSAGES'))
-        throw (0, util_1.emsg)('You do not have permission to run this command');
-    clearQueue(interaction);
-    await interaction.reply('Queue has been reset');
-}
-exports.cancelQueue = cancelQueue;

dist/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChannel = exports.getMember = exports.emsg = exports.errorMessage = exports.shuffle = void 0;
+exports.memberIsModThrow = exports.memberIsMod = exports.getChannel = exports.getMember = exports.emsg = exports.errorMessage = exports.shuffle = void 0;
 const discord_js_1 = require("discord.js");
 /**
  * shuffles an array
@@ -64,3 +64,13 @@ function getChannel(interaction) {
     return channel;
 }
 exports.getChannel = getChannel;
+function memberIsMod(interaction) {
+    let member = getMember(interaction);
+    return member.permissionsIn(interaction.channelId).has('MANAGE_MESSAGES');
+}
+exports.memberIsMod = memberIsMod;
+function memberIsModThrow(interaction) {
+    if (!memberIsMod(interaction))
+        throw (0, exports.emsg)('Member is not a moderator');
+}
+exports.memberIsModThrow = memberIsModThrow;

src/index.ts

@@ -16,7 +16,7 @@ if (!fs.existsSync('./token.txt')) {
     console.error('Missing Discord Token, please enter the bot token into the token file');
     process.exit(1);
 }
-const TOKEN = fs.readFileSync('./token').toString();
+const TOKEN = fs.readFileSync('./token.txt').toString();
 
 //discord connections
 CLIENT.on('ready', client => {

src/queue.ts

@@ -8,10 +8,10 @@ import * as fs from 'fs';
 import { emsg, getChannel, getMember, memberIsModThrow, queueInfo, queueInfoBase } from "./util";
 
 //load queues from file
-if (!fs.existsSync('./queues'))
+if (!fs.existsSync('./queues.json'))
-    fs.writeFileSync('./queues', '{}');
+    fs.writeFileSync('./queues.json', '{}');
 
-const _QUEUE = fs.readFileSync('./queues').toString(),
+const _QUEUE = fs.readFileSync('./queues.json').toString(),
     QUEUE = new Map<string, queueInfo>();
 
 try {