remade queue logic

.gitignore

@@ -1,4 +1,5 @@
 node_modules
-token
+token.txt
+queues.json
 .DS_Store
 log

scripts/mac-linux/install

@@ -8,11 +8,11 @@ cd ../..
 npm install
 
 #discord token
-[ ! -f "token" ] && touch "token"
+[ ! -f "token.txt" ] && touch "token.txt"
 
-if [ ! -s "token" ]
+if [ ! -s "token.txt" ]
 then
     printf "Enter your discord bot token: "
     read token
-    printf $token > "token"
+    printf $token > "token.txt"
 fi

scripts/windows/install.bat

@@ -4,12 +4,12 @@
 cd %~f0\..\..\..\
 
 @REM discord token
-if not exist "token" copy NUL "token"
+if not exist "token.txt" copy NUL "token.txt"
 
-for /f %%i in ("token") do set size=%%~zi
+for /f %%i in ("token.txt") do set size=%%~zi
 if %size% equ 0 (
     set /p token="Enter your discord bot token: "
-    echo | set /p=%id% > "token"
+    echo | set /p=%id% > "token.txt"
 )
 
 @REM run

src/discord.ts

@@ -5,13 +5,12 @@ import { Routes } from '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, //INTEGER
                 name: 'teamsize',
                 description: 'size of each team',
-                required: true,
                 min_value: 1
             }
         ]
@@ -25,12 +24,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',

src/index.ts

@@ -3,7 +3,7 @@ import { Client, Intents } from 'discord.js';
 import * as fs from 'fs';
 import { getPlayerInteraction } from './api';
 import { registerCommands } from './discord';
-import { cancelQueue, createQueue, joinQueue, leaveQueue, readyQueue } from './queue';
+import { discordInit, QueueCommands } from './queue';
 import { errorMessage } from './util';
 const CLIENT = new Client({ intents: [Intents.FLAGS.GUILDS] });
 
@@ -11,8 +11,8 @@ const CLIENT = new Client({ intents: [Intents.FLAGS.GUILDS] });
 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);
 }
@@ -23,6 +23,7 @@ CLIENT.on('ready', client => {
     console.log(`Logged in as ${client.user.tag}`);
     client.guilds.fetch().then(guilds =>
         registerCommands(TOKEN, client.user.id, guilds.map(g => g.id)));
+    discordInit(client);
 });
 
 CLIENT.on('interactionCreate', async interaction => {
@@ -31,15 +32,13 @@ CLIENT.on('interactionCreate', async interaction => {
     try {
 
         if (interaction.commandName === 'queue')
-            await createQueue(interaction);
+            await QueueCommands.queue(interaction);
         else if (interaction.commandName === 'join')
-            await joinQueue(interaction);
+            await QueueCommands.join(interaction);
         else if (interaction.commandName === 'leave')
-            await leaveQueue(interaction);
+            await QueueCommands.leave(interaction);
-        else if (interaction.commandName === 'ready')
+        else if (interaction.commandName === 'stop')
-            await readyQueue(interaction);
+            await QueueCommands.stop(interaction);
-        else if (interaction.commandName === 'cancel')
-            await cancelQueue(interaction);
         else if (interaction.commandName === 'player')
             await getPlayerInteraction(interaction);
 

src/queue.ts

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

src/util.ts

@@ -46,14 +46,11 @@ export const emsg = (msg: string, ephemeral: boolean = true) => new errorMessage
 
 
 
-export type queueInfo = {
+export interface queueInfoBase {
-    players: GuildMember[],
+    teamsize: number
-    initiator: {
+}
-        interaction: CommandInteraction,
+export interface queueInfo extends queueInfoBase{
-        member: GuildMember
+    players: GuildMember[]
-    },
-    teamsize: number,
-    timeout: NodeJS.Timeout
 }
 
 /**
@@ -85,3 +82,14 @@ export function getChannel(interaction: CommandInteraction): TextChannel {
 
     return channel;
 }
+
+
+export function memberIsMod(interaction: CommandInteraction): boolean {
+    let member = getMember(interaction);
+    return member.permissionsIn(interaction.channelId).has('MANAGE_MESSAGES');
+}
+
+export function memberIsModThrow(interaction: CommandInteraction) {
+    if (!memberIsMod(interaction))
+        throw emsg('Member is not a moderator');
+}