I am so broken and confusion

src/MPLoop.ts

@@ -1,137 +1,38 @@
-interface TServer {
-  ip: string
-  code: string
-}
 import Discord from 'discord.js';
 import TClient from './client';
 import {writeFileSync, readFileSync} from 'node:fs';
-import {FSPlayer, FSData, FSCareerSavegame} from './typings/interfaces';
+import {FSPlayer, FSData, FSCareerSavegame, TServer} from './typings/interfaces';
 
-export default async(client:TClient, Channel:string, Message:string, Server:TServer)=>{
+export default async(client:TClient, Channel:string, Message:string, Server:TServer, ServerName:string)=>{
-  if (!client.config.botSwitches.mpstats) return;
   let MPLoopPrefix = '[MPLoop] ';
+  let placeholder = '$_SERVERNAMEPLACEHOLDER';
+  //let httpRegex = /^(https?)(\:\/\/)/;
+  //let isServerOnline = false;
+  let playerData:Array<string> = [];
   let noContentImage = 'https://cdn.discordapp.com/attachments/1118960531135541318/1140906691236479036/68efx1.png';
   const msg = await (client.channels.resolve(Channel) as Discord.TextChannel).messages.fetch(Message);
+  const serverErrorEmbed = new client.embed().setColor(client.config.embedColorRed).setTitle('Host did not respond back in time');
+  const genericEmbed = new client.embed();
 
   // Log bot uptime for the sake of debugging.
   (client.channels.resolve('1091300529696673792') as Discord.TextChannel).send(client.formatTime(client.uptime, 2, {longNames: true, commas: true}));
 
+  const decoPlayer = (player:FSPlayer)=>{
+    let decorator = player.isAdmin ? ':detective:' : '';
+    decorator += player.name.includes('Toast') ? '<:toastv2:1132681026662056079>' : '';
+    return decorator
+  }
+  
   const HITALL = async()=>{
     let sessionInit = {signal: AbortSignal.timeout(7500),headers:{'User-Agent':`Daggerbot - HITALL/fetch`}};
     try {
       const hitDSS = await fetch(Server.ip+'/feed/dedicated-server-stats.json?code='+Server.code, sessionInit).then(r=>r.json() as Promise<FSData>);
-      const hitCSG = await fetch(Server.ip+'/feed/dedicated-server-savegame.html?code='+Server.code+'&file=careerSavegame', sessionInit).then(async r=>{
+      const hitCSG = await fetch(Server.ip+'/feed/dedicated-server-savegame.html?code='+Server.code+'&file=careerSavegame', sessionInit).then(async r=>(client.xjs.xml2js(await r.text(), {compact: true}) as any).careerSavegame as FSCareerSavegame);
-        if (r.status === 204) return msg.edit({embeds: [new client.embed().setImage(noContentImage)]});
-        else return (client.xjs.xml2js(await r.text(), {compact: true}) as any).careerSavegame as FSCareerSavegame
-      }).catch(()=>console.log(client.logTime(), `${MPLoopPrefix}CSG failed for ${Server.ip.replace(/^(https?)(\:\/\/)/, '')}`));
 
       if (!hitDSS ?? !hitCSG){
-        if (hitDSS && !hitDSS.slots) return new Error(`${MPLoopPrefix}DSS failed for unknown slots table`);
+        if (hitDSS && !hitDSS.slots) return new Error(`${MPLoopPrefix}DSS failed with unknown slots table for ${ServerName}`);
-        return msg.edit({embeds: [new client.embed().setColor(client.config.embedColorRed).setTitle('Host did not respond back in time')]});
+        if (hitDSS && !hitCSG) return msg.edit({content: 'No savegame found or autosave has ran.', embeds: [genericEmbed.setColor(client.config.embedColorOrange).setImage(noContentImage)]});
-      }
+        else return msg.edit({embeds: [serverErrorEmbed]});
-
-      msg.edit({content: [
-        Server.ip.replace(/^(https?)(\:\/\/)/, ''),
-        hitDSS.server.name.length > 0 ? hitDSS.server.name : 'Offline'
-      ].join('\n'), embeds: []})
-    } catch(err) {
-      throw new Error(`${MPLoopPrefix}Failed to make a promise request.`, {cause: err.cause})
-    }
-  }
-  HITALL();
-}
-
-/* export default async(client:TClient,Channel:string,Message:string,ServerName:string)=>{
-  if (!client.config.botSwitches.mpstats) return;
-  const noContentImage = 'https://cdn.discordapp.com/attachments/1118960531135541318/1140906691236479036/68efx1.png';
-  const msg = await (client.channels.resolve(Channel) as Discord.TextChannel).messages.fetch(Message);
-  const embed = new client.embed();
-  let playerData:Array<string> = [];
-  let error:Boolean;
-  let isServerOnline = false;
-  const fetchServer = await client.MPServer._content.findById(client.config.mainServer.id);
-  
-  const API = { // Fetch needed data from Farming Simulator server's API endpoints.
-    DSS: {
-      data: {} as FSData,
-      res: '' as string,
-      endpoint: '/feed/dedicated-server-stats.json?code='
-    },
-    CSG: {
-      data: {} as FSCareerSavegame,
-      res: '' as string,
-      endpoint: '/feed/dedicated-server-savegame.html?code=',
-      endpoint_file: '&file=careerSavegame'
-    }
-  }
-
-  // Fetch needed data from database server and hit them with a GET request.
-  if (!fetchServer.mainServer.ip(/http|https/) ?? !fetchServer.secondServer.ip(/http|https/)) return msg.edit({content:'*This server doesn\'t seem to be setup yet!*', embeds:null});
-  async function hitServer(client:TClient, URL:string){
-    return await client.axios.get(URL, {
-      timeout: 7500, // Increased the timeout a bit just in case.
-      maxContentLength: Infinity,
-      headers: {
-        'User-Agent': `Daggerbot/axios ${client.axios.VERSION}`
-      }
-    }).catch((err:Error)=>err.message)
-  }
-  await Promise.all([
-    hitServer(client, fetchServer.mainServer.ip+API.DSS.endpoint+fetchServer.mainServer.code),
-    hitServer(client, fetchServer.mainServer.ip+API.CSG.endpoint+fetchServer.mainServer.code+API.CSG.endpoint_file),
-    hitServer(client, fetchServer.secondServer.ip+API.DSS.endpoint+fetchServer.secondServer.code),
-    hitServer(client, fetchServer.secondServer.ip+API.CSG.endpoint+fetchServer.secondServer.code+API.CSG.endpoint_file)
-  ]).then(function(results){
-    // Main server's DSS
-    if (typeof results[0] === 'string') {
-      API.DSS.res = `DagMP:Main DSS failed, ${results[0]}`;
-      embed.addFields({name:'DSS Status',value:results[0]})
-    } else if (results[0].status != 200) {
-      API.DSS.res = `DagMP:Main DSS failed with ${results[0].status +' '+ results[0].statusText}`;
-      embed.addFields({name:'DSS Status',value:results[0].status +' '+ results[0].statusText})
-    } else API.DSS.data = results[0].data as FSData
-
-    // Main server's CSG
-    if (typeof results[1] === 'string') {
-      API.CSG.res = `DagMP:Main CSG failed, ${results[1]}`;
-      embed.addFields({name:'CSG Status',value:results[1]})
-    } else if (results[1].status != 200) {
-      if (results[1].status === 204) embed.setImage(noContentImage);
-      API.CSG.res = `DagMP:Main CSG failed with ${results[1].status +' '+ results[1].statusText}`;
-      embed.addFields({name:'CSG Status',value:results[1].status +' '+ results[1].statusText})
-    } else API.CSG.data = (client.xjs.xml2js(results[1].data,{compact:true}) as any).careerSavegame as FSCareerSavegame
-
-    // Second server's DSS
-    if (typeof results[2] === 'string') {
-      API.DSS.res = `DagMP:Second DSS failed, ${results[2]}`;
-      embed.addFields({name:'DSS Status',value:results[2]})
-    } else if (results[2].status != 200) {
-      API.DSS.res = `DagMP:Second DSS failed with ${results[2].status +' '+ results[2].statusText}`;
-      embed.addFields({name:'DSS Status',value:results[2].status +' '+ results[2].statusText})
-    } else API.DSS.data = results[2].data as FSData
-
-    // Second server's CSG
-    if (typeof results[3] === 'string') {
-      API.CSG.res = `DagMP:Second CSG failed, ${results[3]}`;
-      embed.addFields({name:'CSG Status',value:results[3]})
-    } else if (results[3].status != 200) {
-      if (results[3].status === 204) embed.setImage(noContentImage);
-      API.CSG.res = `DagMP:Second CSG failed with ${results[3].status +' '+ results[3].statusText}`;
-      embed.addFields({name:'CSG Status',value:results[3].status +' '+ results[3].statusText})
-    } else API.CSG.data = (client.xjs.xml2js(results[3].data,{compact:true}) as any).careerSavegame as FSCareerSavegame
-  }).catch((err:Error)=>console.error(err.message))
-
-  if (API.DSS.res.length != 0) {
-    error = true;
-    if (API.DSS.data.slots === undefined) return;
-    console.log(client.logTime(), API.DSS.res);
-  } else if (API.CSG.res.length != 0) {
-    error = true;
-    console.log(client.logTime(), API.CSG.res);
-  }
-  if (error) {// Nawdic broke it in his dream
-    embed.setTitle('Host did not respond back in time').setColor(client.config.embedColorRed);
-    return msg.edit({content:null, embeds:[embed]})
       }
 
       //Timescale formatting
@@ -139,64 +40,71 @@ export default async(client:TClient, Channel:string, Message:string, Server:TSer
         var n = Number(number);
         return n.toLocaleString(undefined, {minimumFractionDigits: digits})+icon
       }
+
       // Join/Leave log
       function playerLogEmbed(player:FSPlayer,joinLog:boolean){
-    const logEmbed = new client.embed().setDescription(`**${player.name} ${player.isAdmin ? '| admin' : ''}** ${joinLog ? 'joined' : 'left'} **${ServerName}** at <t:${Math.round(Date.now()/1000)}:t>`);
+        const logEmbed = new client.embed().setDescription(`**${player.name}${decoPlayer(player)}** ${joinLog ? 'joined' : 'left'} **${placeholder}** at <t:${Math.round(Date.now()/1000)}:t>`);
         if (joinLog) return logEmbed.setColor(client.config.embedColorGreen);
         else if (player.uptime > 0) return logEmbed.setColor(client.config.embedColorRed).setFooter({text:`Farmed for ${client.formatPlayerUptime(player.uptime)}`});
         else return logEmbed.setColor(client.config.embedColorRed);
       }
+
       function playerLog(){
         // Player leaving
         playersInCache.filter(x=>!playersOnServer.some(y=>y.name === x.name)).forEach(player=>serverLog.send({embeds:[playerLogEmbed(player,false)]}));
         // Player joining
         let playerObject;
-    if (playersInCache.length === 0 && (client.uptime as number) > 60010) playerObject = playersOnServer;
+        if (playersInCache.length === 0 && client.uptime > 32010) playerObject = playersOnServer;
         else if (playersInCache.length !== 0) playerObject = playersOnServer.filter(x=>!playersInCache.some(y=>y.name === x.name));
         if (playerObject) playerObject.forEach(x=>serverLog.send({embeds:[playerLogEmbed(x,true)]}));
+
+        if (client.uptime > 32000){
+          const Database:Array<number> = JSON.parse(readFileSync(`src/database/${ServerName}PlayerData.json`,{encoding:'utf8',flag:'r+'}));
+          Database.push(hitDSS.slots?.used);
+          writeFileSync(`src/database/${ServerName}PlayerData.json`, JSON.stringify(Database));
+        }
       }
 
-  const serverIndicatorEmbed =(indicator:string)=>new client.embed().setTitle(`**${ServerName}** is now ${indicator}`).setColor(client.config.embedColorOrange).setTimestamp();
+      //const serverIndicatorEmbed =(indicator:string)=>new client.embed().setTitle(`**${placeholder}** is now ${indicator}`).setColor(client.config.embedColorOrange).setTimestamp();
-
       const serverLog = client.channels.resolve(client.config.mainServer.channels.fs_server_log) as Discord.TextChannel;
-  const playersOnServer = API.DSS.data.slots?.players.filter(x=>x.isUsed);
+      const playersOnServer = hitDSS.slots?.players.filter(x=>x.isUsed);
       const playersInCache = client.MPServerCache[ServerName].players;
-  if (!playersOnServer) return console.error(client.logTime(), '[MPLoop] Empty filter, ignoring...'); // For the love of god, stop throwing errors everytime.
+      if (!playersOnServer ?? playersOnServer === undefined) return new Error('[MPLoop] Empty array, ignoring...'); // For the love of god, stop throwing errors everytime.
-  playersOnServer.forEach(player=>playerData.push(`**${player.name} ${player.isAdmin ? '| admin' : ''}**\nFarming for ${client.formatPlayerUptime(player.uptime)}`));
+      playersOnServer.forEach(player=>playerData.push(`**${player.name}${decoPlayer(player)}**\nFarming for ${client.formatPlayerUptime(player.uptime)}`));
 
-  ServerName = client.MPServerCache[ServerName].name; // Truncate unnecessary name for the embed
+      ServerName = client.MPServerCache[ServerName].name; // Truncate unnecessary parts of the name for the serverLog embed
-  if (API.DSS.data.server.name === 'Official Daggerwin Game Server') client.MPServerCache['main'].name = 'Daggerwin';
+      if (hitDSS.server.name === 'Official Daggerwin Game Server') client.MPServerCache['mainServer'].name = 'Daggerwin';
+      if (hitDSS.server.name === '! ! IRTGaming | Toast Test') client.MPServerCache['secondServer'].name = 'Toast';
       //Second server name is unknown, will come back and update this later.
-
+      playerLog();
-  if (API.DSS.data.server.name.length === 0){
+      if (hitDSS.server.name.length < 1){
-    embed.setTitle('The server seems to be offline.').setColor(client.config.embedColorRed);
+        msg.edit({content: 'This embed will resume when server is back online.', embeds: [genericEmbed.setColor(client.config.embedColorRed).setTitle('The server seems to be offline.')]});
-    msg.edit({content: 'This embed will resume when the server is back online.', embeds: [embed]});
+        /* if (client.MPServerCache[ServerName].status === 'online') serverLog.send({embeds:[serverIndicatorEmbed('offline')]});
-    if (client.MPServerCache[ServerName].status === 'online') serverLog.send({embeds:[serverIndicatorEmbed('offline')]});
+        client.MPServerCache[ServerName].status = 'offline' */
-    client.MPServerCache[ServerName].status = 'offline';
       } else {
-    if (client.MPServerCache[ServerName].status === 'offline'){
+        /* if (client.MPServerCache[ServerName]?.status === 'offline' ?? null){
           serverLog.send({embeds:[serverIndicatorEmbed('online')]});
           isServerOnline = true
-    };
-    client.MPServerCache[ServerName].status = 'online';
-    const statusEmbed = new client.embed().setColor(client.config.embedColor).setTitle('Server details').setFields(
-      {name: 'Current Map', value: API.DSS.data.server.mapName.length === 0 ? '\u200b' : API.DSS.data.server.mapName, inline: true},
-      {name: 'Version', value: API.DSS.data.server.version.length === 0 ? '\u200b' : API.DSS.data.server.version, inline: true},
-      {name: 'In-game Time', value: `${('0'+Math.floor((API.DSS.data.server.dayTime/3600/1000))).slice(-2)}:${('0'+Math.floor((API.DSS.data.server.dayTime/60/1000)%60)).slice(-2)}`, inline: true},
-      {name: 'Slot Usage', value: isNaN(Number(API.CSG.data.slotSystem?._attributes.slotUsage)) === true ? 'Unavailable' : Number(API.CSG.data.slotSystem?._attributes.slotUsage).toLocaleString('en-us'), inline: true},
-      {name: 'Autosave Interval', value: isNaN(Number(API.CSG.data.settings?.autoSaveInterval._text)) === true ? 'Unavailable' : Number(API.CSG.data.settings?.autoSaveInterval._text).toFixed(0)+' mins', inline:true},
-      {name: 'Timescale', value: isNaN(Number(API.CSG.data.settings?.timeScale._text)) === true ? 'Unavailable' : formatTimescale(Number(API.CSG.data.settings?.timeScale._text), 0, 'x'), inline: true}
-    );
-    embed.setColor(client.config.embedColor).setTitle(API.DSS.data.server.name).setDescription(API.DSS.data.slots.used === 0 ? '*No players online*' : playerData.join('\n\n')).setAuthor({name:`${API.DSS.data.slots.used}/${API.DSS.data.slots.capacity}`});
-    msg.edit({content:'This embed updates every minute.',embeds:[statusEmbed,embed]});
         }
+        client.MPServerCache[ServerName].status = 'online'; */
 
-  if (!isServerOnline){
+        const serverDetails = new client.embed().setColor(client.config.embedColor).setTitle('Server details').setFields(
-    playerLog();
+          {name: 'Current map', value: hitDSS.server.mapName, inline: true},
-    const Database:Array<number> = JSON.parse(readFileSync(`src/database/${ServerName}PlayerData.json`,{encoding:'utf8',flag:'r+'}));
+          {name: 'Server version', value: hitDSS.server.version, inline: true},
-    Database.push(API.DSS.data.slots?.used);
+          {name: 'In-game Time', value: `${('0'+Math.floor((hitDSS.server.dayTime/3600/1000))).slice(-2)}:${('0'+Math.floor((hitDSS.server.dayTime/60/1000)%60)).slice(-2)}`, inline: true},
-    writeFileSync(`src/database/${ServerName}PlayerData.json`, JSON.stringify(Database));
+          {name: 'Slot Usage', value: isNaN(Number(hitCSG.slotSystem?._attributes.slotUsage)) === true ? 'Unavailable' : Number(hitCSG.slotSystem?._attributes.slotUsage).toLocaleString('en-us'), inline: true},
-    client.MPServerCache[ServerName].players = playersOnServer
+          {name: 'Autosave Interval', value: isNaN(Number(hitCSG.settings?.autoSaveInterval._text)) === true ? 'Unavailable' : Number(hitCSG.settings?.autoSaveInterval._text).toFixed(0)+' mins', inline:true},
+          {name: 'Timescale', value: isNaN(Number(hitCSG.settings?.timeScale._text)) === true ? 'Unavailable' : formatTimescale(Number(hitCSG.settings?.timeScale._text), 0, 'x'), inline: true}
+        );
+        const playersEmbed = new client.embed().setColor(client.config.embedColor).setTitle(hitDSS.server.name).setDescription(hitDSS.slots.used < 1 ? '*No players online*' : playerData.join('\n\n')).setAuthor({name:`${hitDSS.slots.used}/${hitDSS.slots.capacity}`});
+        msg.edit({content:'This embed updates every 30 seconds.',embeds:[serverDetails, playersEmbed]});
       }
+    } catch(err) {
+      msg.edit({content: null, embeds: [new client.embed().setColor(client.config.embedColorRed).setTitle('Host did not respond back in time')]});
+      console.log(err)
+      //throw new Error(`Failed to make a request for ${ServerName}`, {cause: err.cause})
+    }
+  }
+  HITALL();
+// Hit dem servers in the head every 30 seconds.
 }
- */

src/client.ts

@@ -2,7 +2,7 @@ import Discord, {Client, WebhookClient, GatewayIntentBits, Partials} from 'disco
 import {readFileSync, readdirSync} from 'node:fs';
 import {exec} from 'node:child_process';
 import mongoose from 'mongoose';
-import {formatTimeOpt, Tokens, Config, repeatedMessages, MPServerCache} from './typings/interfaces';
+import {formatTimeOpt, Tokens, Config, repeatedMessages, type MPServerCache} from './typings/interfaces';
 import bannedWords from './models/bannedWords.js';
 import userLevels from './models/userLevels.js';
 import suggestion from './models/suggestion.js';
@@ -45,7 +45,7 @@ export default class TClient extends Client {
   bonkCount: bonkCount;
   bannedWords: bannedWords;
   MPServer: MPServer;
-  MPServerCache: MPServerCache;
+  MPServerCache: MPServerCache = {};
   suggestion: suggestion;
   tags: tags;
   repeatedMessages: repeatedMessages;
@@ -85,10 +85,7 @@ export default class TClient extends Client {
     this.punishments = new punishments(this);
     this.bannedWords = new bannedWords(this);
     this.MPServer = new MPServer(this);
-    this.MPServerCache = {
+    this.MPServerCache = {} as MPServerCache;
-      main: { players: [], status: null, name: null },
-      second: { players: [], status: null, name: null }
-    } as MPServerCache;
     this.suggestion = new suggestion(this);
     this.tags = new tags(this);
     this.repeatedMessages = {};
@@ -111,16 +108,21 @@ export default class TClient extends Client {
     }).then(()=>console.log(this.logTime(), 'Successfully connected to MongoDB')).catch(()=>{throw new Error('Failed to connect to MongoDB'); exec('pm2 stop Daggerbot', {windowsHide:true})})
     this.login(this.tokens.beta);
     for await (const file of readdirSync('dist/events')){
-      //console.log('EVENTS:', file)
       const eventFile = await import(`./events/${file}`);
       this.on(file.replace('.js',''), async(...args)=>eventFile.default.run(this,...args))
     }
     for await (const file of readdirSync('dist/commands')){
-      //console.log('COMMANDS:', file)
       const command = await import(`./commands/${file}`);
       this.commands.set(command.default.data.name,{command, uses: 0});
       this.registry.push(command.default.data.toJSON())
     }
+    for (const naming of Object.keys(this.config.MPStatsLocation)){
+      this.MPServerCache[naming] = {
+        players: [],
+        status: null,
+        name: null
+      }
+    }
   }
   formatTime(integer: number, accuracy = 1, options?: formatTimeOpt){
     let achievedAccuracy = 0;

src/commands/mp.ts

@@ -3,38 +3,472 @@ import TClient from '../client.js';
 import path from 'node:path';
 import canvas from 'canvas';
 import {readFileSync} from 'node:fs';
+import {FSData, TServer} from 'src/typings/interfaces.js';
+
+export default {
+  async run(client: TClient, interaction: Discord.ChatInputCommandInteraction<'cached'>){
+    if (client.uptime < 30000) return interaction.reply('I have just restarted, please wait for MPLoop to initialize.')
+    const serverSelector = interaction.options.getString('server', true);
+    if (interaction.channelId === '468835769092669461' && !client.isStaff(interaction.member) && ['status', 'players'].includes(interaction.options.getSubcommand())) return interaction.reply('Please use <#739084625862852715> for `/mp status/players` commands to prevent clutter in this channel.').then(()=>setTimeout(()=>interaction.deleteReply(), 6000));
+
+    const database = await client.MPServer._content.findById(interaction.guildId);
+    //const debug = (database[serverSelector] as TServer);
+    const endpoint = await fetch(database[serverSelector].ip+'/feed/dedicated-server-stats.json?code='+database[serverSelector].code, {signal: AbortSignal.timeout(7500),headers:{'User-Agent':`Daggerbot - MPdata/fetch`}}).then(r=>r.json() as Promise<FSData>);
+    ({
+      players: async()=>{
+        const data = JSON.parse(readFileSync(path.join(`src/database/${client.MPServerCache[serverSelector].name}PlayerData.json`), {encoding: 'utf8'})).slice(client.statsGraph);
+        // handle negative days
+        for (const [i, change] of data.entries()) if (change < 0) data[i] = data[i - 1] || data[i + 1] || 0;
+
+        const first_graph_top = 16;
+        const second_graph_top = 16;
+        const textSize = 40;
+        const img = canvas.createCanvas(1500, 750);
+        const ctx = img.getContext('2d');
+        const graphOrigin = [15, 65];
+        const graphSize = [1300, 630];
+        const nodeWidth = graphSize[0] / (data.length - 1);
+        ctx.fillStyle = '#36393f';
+        ctx.fillRect(0, 0, img.width, img.height);
+
+        // grey horizontal lines
+        ctx.lineWidth = 5;
+
+        const interval_candidates: [number, number, number][] = [];
+        for (let i = 4; i < 10; i++) {
+          const interval = first_graph_top / i;
+          if (Number.isInteger(interval)) {
+            let intervalString = interval.toString();
+            const reference_number = i * Math.max(intervalString.split('').filter(x => x === '0').length / intervalString.length, 0.3) * (['1', '2', '4', '5', '6', '8'].includes(intervalString[0]) ? 1.5 : 0.67)
+            interval_candidates.push([interval, i, reference_number]);
+          }
+        }
+        const chosen_interval = interval_candidates.sort((a, b) => b[2] - a[2])[0];
+        const previousY: number[] = [];
+        ctx.strokeStyle = '#202225';
+
+        for (let i = 0; i <= chosen_interval[1]; i++) {
+          const y = graphOrigin[1] + graphSize[1] - (i * (chosen_interval[0] / second_graph_top) * graphSize[1]);
+          if (y < graphOrigin[1]) continue;
+          const even = ((i + 1) % 2) === 0;
+          if (even) ctx.strokeStyle = '#2c2f33';
+          ctx.beginPath();
+          ctx.lineTo(graphOrigin[0], y);
+          ctx.lineTo(graphOrigin[0] + graphSize[0], y);
+          ctx.stroke();
+          ctx.closePath();
+          if (even) ctx.strokeStyle = '#202225';
+          previousY.push(y, i * chosen_interval[0]);
+        }
+
+        // 30d mark
+        ctx.setLineDash([8, 16]);
+        ctx.beginPath();
+        const lastMonthStart = graphOrigin[0] + (nodeWidth * (data.length - 60));
+        ctx.lineTo(lastMonthStart, graphOrigin[1]);
+        ctx.lineTo(lastMonthStart, graphOrigin[1] + graphSize[1]);
+        ctx.stroke();
+        ctx.closePath();
+        ctx.setLineDash([]);
+
+        // draw points
+        ctx.lineWidth = 5;
+
+        const gradient = ctx.createLinearGradient(0, graphOrigin[1], 0, graphOrigin[1] + graphSize[1]);
+        gradient.addColorStop(1 / 16, '#e62c3b'); // Red
+        gradient.addColorStop(5 / 16, '#ffea00'); // Yellow
+        gradient.addColorStop(12 / 16, '#57f287'); // Green
+
+        let lastCoords: number[] = [];
+
+        for (let [i, curPC /* current player count */] of data.entries()) {
+          if (curPC < 0) curPC = 0;
+          const x = i * nodeWidth + graphOrigin[0];
+          const y = ((1 - (curPC / second_graph_top)) * graphSize[1]) + graphOrigin[1];
+          const nexPC /* next player count */ = data[i + 1];
+          const prvPC /* previous player count */ = data[i - 1];
+          ctx.strokeStyle = gradient;
+          ctx.beginPath();
+          if (lastCoords.length) ctx.moveTo(lastCoords[0], lastCoords[1]);
+          // if the line being drawn is horizontal, make it go until it has to go down
+          if (y === lastCoords[1]) {
+            let newX = x;
+            for (let j = i + 1; j <= data.length; j++) {
+              if (data[j] === curPC) newX += nodeWidth;
+              else break;
+            }
+            ctx.lineTo(newX, y);
+          } else ctx.lineTo(x, y);
+            lastCoords = [x, y];
+            ctx.stroke();
+            ctx.closePath();
+
+          if (curPC !== prvPC || curPC !== nexPC) { // Ball if vertical different to next or prev point
+            // ball
+            ctx.fillStyle = gradient;
+            ctx.beginPath();
+            ctx.arc(x, y, ctx.lineWidth * 1.3, 0, 2 * Math.PI)
+            ctx.closePath();
+            ctx.fill();
+          };
+        }
+
+        // draw text
+        ctx.font = '400 ' + textSize + 'px sans-serif';
+        ctx.fillStyle = 'white';
+
+        // highest value
+        if (!isNaN(previousY.at(-2) as number)) {
+          const maxx = graphOrigin[0] + graphSize[0] + textSize / 2;
+          const maxy = (previousY.at(-2) as number) + (textSize / 3);
+          ctx.fillText((previousY.at(-1) as number).toLocaleString('en-US'), maxx, maxy);
+        }
+
+        // lowest value
+        const lowx = graphOrigin[0] + graphSize[0] + textSize / 2;
+        const lowy = graphOrigin[1] + graphSize[1] + (textSize / 3);
+        ctx.fillText('0 players', lowx, lowy);
+
+        // 30d
+        ctx.fillText('30 min ago', lastMonthStart, graphOrigin[1] - (textSize / 2));
+
+        // time ->
+        const tx = graphOrigin[0] + (textSize / 2);
+        const ty = graphOrigin[1] + graphSize[1] + (textSize);
+        ctx.fillText('time ->', tx, ty);
+
+        const playerData: string[] = [];
+        let Color = client.config.embedColor;
+        if (endpoint.slots.used === endpoint.slots.capacity) Color = client.config.embedColorRed;
+        else if (endpoint.slots.used > 8) Color = client.config.embedColorYellow;
+        else Color = client.config.embedColorGreen;
+
+        for (const player of endpoint.slots.players.filter(x=>x.isUsed)){
+          let decorator = player.isAdmin ? ':detective:' : '';
+          decorator += player.name.includes('Toast') ? '<:toastv2:1132681026662056079>' : '';
+          playerData.push(`**${player.name}${decorator}**\nFarming for ${client.formatPlayerUptime(player.uptime)}`)
+        }
+
+        const slot = `${endpoint.slots.used}/${endpoint.slots.capacity}`;
+        const ingameTime = `${('0'+Math.floor((endpoint.server.dayTime/3600/1000))).slice(-2)}:${('0'+Math.floor((endpoint.server.dayTime/60/1000)%60)).slice(-2)}`;
+        interaction.reply({embeds:[new client.embed().setColor(Color).setTitle(endpoint.server.name).setDescription(endpoint.slots.used < 1 ? '*No players online*' : playerData.join('\n\n')).setImage('attachment://FSStats.png').setAuthor({name:slot}).setFooter({text: 'Current time: '+ingameTime})], files: [new client.attachmentBuilder(img.toBuffer(),{name:'FSStats.png'})]})
+      },
+      status: async()=>{
+        interaction.reply(`$debug`)
+      }
+    })[interaction.options.getSubcommand()]();
+  },
+  data: new Discord.SlashCommandBuilder()
+    .setName('mp')
+    .setDescription('Display MP status and other things')
+    .addSubcommand(x=>x
+      .setName('status')
+      .setDescription('Display server status')
+      .addStringOption(x=>x
+        .setName('server')
+        .setDescription('The server to update')
+        .setRequired(true)
+        .setChoices(
+          {name: 'Main Server', value: 'mainServer'},
+          {name: 'Second Server', value: 'secondServer'}
+        )))
+    .addSubcommand(x=>x
+      .setName('players')
+      .setDescription('Display players on server')
+      .addStringOption(x=>x
+        .setName('server')
+        .setDescription('The server to display players for')
+        .setRequired(true)
+        .setChoices(
+          {name: 'Main Server', value: 'mainServer'},
+          {name: 'Second Server', value: 'secondServer'}
+        )))
+    .addSubcommand(x=>x
+      .setName('url')
+      .setDescription('View or update the server URL')
+      .addStringOption(x=>x
+        .setName('server')
+        .setDescription('The server to update')
+        .setRequired(true)
+        .setChoices(
+          {name: 'Main Server', value: 'mainServer'},
+          {name: 'Second Server', value: 'secondServer'}
+        ))
+      .addStringOption(x=>x
+        .setName('address')
+        .setDescription('The URL to the dedicated-server-stats.json file')
+        .setRequired(false)))
+    .addSubcommand(x=>x
+      .setName('info')
+      .setDescription('Display server information'))
+    .addSubcommand(x=>x
+      .setName('maintenance')
+      .setDescription('Toggle maintenance mode for #mp-active-players')
+      .addStringOption(x=>x
+        .setName('message')
+        .setDescription('The message to display in the channel')))
+}
+
+/* async function MPdata(client:TClient, interaction:Discord.ChatInputCommandInteraction, embed: Discord.EmbedBuilder, serverSelector: any) {
+  //let serverSelector;
+  let sessionInit = {signal: AbortSignal.timeout(7500),headers:{'User-Agent':`Daggerbot - MPdata/fetch`}};
+  if (!await client.MPServer._content.findOne({_id:interaction.guildId})) return interaction.reply('This server isn\'t linked to the bot.');
+  const ServerURL = await client.MPServer._content.findById(interaction.guildId);
+  if (!ServerURL[serverSelector].ip.match(/^(https?)(\:\/\/)/)) return interaction.reply(`The server IP for this server is currently invalid, please notify <@&${client.config.mainServer.roles.mpmanager}>`);
+  const hitDSS = await fetch(ServerURL[serverSelector].ip+'/feed/dedicated-server-stats.json?code='+ServerURL[serverSelector].code, sessionInit).then(r=>r.json());
+}
 
 export default {
   run(client: TClient, interaction: Discord.ChatInputCommandInteraction<'cached'>){
-    async function hitEndpoint(){
+    if (interaction.channelId === '468835769092669461' && !client.isStaff(interaction.member) && ['status', 'players'].includes(interaction.options.getSubcommand())) return interaction.reply(`Please use <#739084625862852715> for \`/mp status/players\` commands to prevent clutter in this channel.`).then(()=>setTimeout(()=>interaction.deleteReply(), 6000));
-      const array = (await client.MPServer?._content.find())?.map(x=>x._id).filter(c=>['mainServer','secondServer'].includes(c));
-      console.log(array?.map(c=>c));
-
-      /* const database = {
-        mainServer: (await client.MPServer._content.findById(interaction.guildId)).mainServer,
-        secondServer: (await client.MPServer._content.findById(interaction.guildId)).secondServer
-      }
-      const endpoint = '/feed/dedicated-server-stats.json?code=';
-      if (serverSelector === 'mainServer') return database.mainServer.ip+endpoint+database.mainServer.code;
-      else if (serverSelector === 'secondServer') return database.secondServer.ip+endpoint+database.secondServer.code;
-      const Server = await client.axios.get(serverSelector, {
-        timeout: 7500,
-        headers: {'User-Agent':`Daggerbot - mp cmd/axios ${client.axios.VERSION}`}
-      }) */
-    }
-    
-    if (interaction.channelId === '468835769092669461' && !client.isStaff(interaction.member) && ['status', 'players'].includes(interaction.options.getSubcommand())) {
-      interaction.reply(`Please use <#739084625862852715> for \`/mp status/players\` commands to prevent clutter in this channel.`).then(()=>setTimeout(()=>interaction.deleteReply(), 6000));
-      return;
-    }
     ({
       status: async()=>{
-        hitEndpoint()
+        const embed0 = new client.embed();
-        interaction.reply('x')
+        const FSserver0 = await MPdata(client, interaction, embed0, 'mainServer');
+        if (!FSserver0?.data) return console.log('FSserver0 failed - status');
+        try {
+          if (FSserver0.data.server.name.length > 1){
+            interaction.reply({embeds: [embed0.setTitle('Status/Details').setColor(client.config.embedColor).addFields(
+              {name: 'Server name', value: `${FSserver0?.data.server.name.length == 0 ? '\u200b' : `\`${FSserver0?.data.server.name}\``}`, inline: true},
+              {name: 'Players', value: `${FSserver0.data.slots.used} out of ${FSserver0.data.slots.capacity}`, inline: true},
+              {name: 'Current map', value: `${FSserver0?.data.server.mapName.length == 0 ? '\u200b' : FSserver0.data.server.mapName}`, inline: true},
+              {name: 'Version', value: `${FSserver0?.data.server.version.length == 0 ? '\u200b' : FSserver0.data.server.version}`, inline: true},
+              {name: 'In-game Time', value: `${('0' + Math.floor((FSserver0.data.server.dayTime/3600/1000))).slice(-2)}:${('0' + Math.floor((FSserver0.data.server.dayTime/60/1000)%60)).slice(-2)}`, inline: true}
+            )]})
+          } else if (FSserver0.data.server.name.length === 0) interaction.reply('Server is currently offline.')
+        } catch (err){
+          console.log(err)
+          interaction.reply('FSserver0 Error placeholder')
+        }
       },
-      info: async()=>{},
+      info: async()=>{
-      url: async()=>{},
+        const embed2 = new client.embed().setColor(client.config.embedColor)
-      players: async()=>{}
+        const FSserver2 = await MPdata(client, interaction, embed2, 'secondServer')
+        if (!FSserver2?.data) return console.log('FSserver2 failed - info')
+        const MPURL = await client.MPServer._content.findById(interaction.guildId);
+        if (FSserver2.data.server.name.length == 0) embed2.setFooter({text: 'Server is currently offline.'})
+        interaction.reply({embeds: [embed2.setDescription([
+          `**Server name**: \`${FSserver2?.data.server.name.length === 0 ? '\u200b' : FSserver2?.data.server.name}\``,
+          '**Password:** `mf4700`',
+          '**Crossplay server**',
+          `**Map:** ${FSserver2.data.server.mapName.length < 1 ? 'Null Island' : FSserver2.data.server.mapName}`,
+          `**Mods:** [Click here](${MPURL.mainServer.ip}/mods.html) **|** [Direct Download](${MPURL.mainServer.ip}/all_mods_download?onlyActive=true)`,
+          '**Filters:** [Click here](https://discord.com/channels/468835415093411861/468835769092669461/926581585938120724)',
+          'Please see <#543494084363288637> for additional information.'
+        ].join('\n'))]});
+      },
+      url: async()=>{
+        if (client.config.mainServer.id == interaction.guildId) {
+          if (!interaction.member.roles.cache.has(client.config.mainServer.roles.mpmanager) && !interaction.member.roles.cache.has(client.config.mainServer.roles.bottech) && !interaction.member.roles.cache.has(client.config.mainServer.roles.admin)) return client.youNeedRole(interaction, 'mpmanager');
+        }
+        const address = interaction.options.getString('address');
+        if (!address){
+          try {
+            const Url = await client.MPServer._content.findById(interaction.guildId);
+            if (interaction.options.getString('server').includes('mainServer')) {
+              if (Url.mainServer.ip && Url.mainServer.code) return interaction.reply(Url.mainServer.ip+'/feed/dedicated-server-stats.json?code='+Url.mainServer.code)
+            } else {
+              if (Url.secondServer.ip && Url.secondServer.code) return interaction.reply(Url.secondServer.ip+'/feed/dedicated-server-stats.json?code='+Url.secondServer.code)
+            }
+          } catch(err){
+            console.log(`MPDB :: ${err}`);
+            interaction.reply(`\`\`\`${err}\`\`\``)
+          }
+        } else {
+          if (!address.match(/dedicated-server-stats/)) return interaction.reply('The URL does not match `dedicated-server-stats.xml`');
+          const newURL = address.replace('xml','json').split('/feed/dedicated-server-stats.json?code=');
+          try {
+            if (interaction.options.getString('server').includes('mainServer')) {
+              console.log(`MPDB :: Main Server\'s URL for ${interaction.guild.name} has been modified by ${interaction.member.displayName} (${interaction.member.id})`);
+              await client.MPServer._content.create({_id: interaction.guildId, mainServer: { ip: newURL[0], code: newURL[1] }, secondServer: { ip: 'unknown', code: 'unknown' }})
+              .then(()=>interaction.reply('This guild is not found in database, therefore I have created it for you.'))
+              .catch((err:Error)=>interaction.reply(`I ran into a brick wall while creating the server data:\n${err.message}`))
+            } else {
+              console.log(`MPDB :: Second Server\'s URL for ${interaction.guild.name} has been modified by ${interaction.member.displayName} (${interaction.member.id})`)
+              await client.MPServer._content.findOneAndUpdate({_id: interaction.guildId},{$set: {secondServer: {ip: newURL[0], code: newURL[1]}}})
+              .then(()=>interaction.reply('URL for second server successfully updated.'))
+              .catch((err:Error)=>interaction.reply(`I got hit by a flying fish while updating the server data:\n${err.message}`))
+            }
+          } catch(err) {
+            if (interaction.options.getString('server').includes('mainServer')) {
+              const affected = await client.MPServer._content.findByIdAndUpdate({_id: interaction.guildId}, {$set: {mainServer:{ip: newURL[0], code: newURL[1]}}})
+              if (affected) return interaction.reply('URL for Main Server successfully updated.')
+            } else {
+              const affected = await client.MPServer._content.findByIdAndUpdate({_id: interaction.guildId}, {$set: {secondServer:{ip: newURL[0], code: newURL[1]}}})
+              if (affected) return interaction.reply('URL for Second Server successfully updated.')
+            }
+          }
+        }
+      },
+      players: async()=>{
+        const data = JSON.parse(readFileSync(path.join(`src/database/${client.MPServerCache[interaction.options.getString('server',true)].name}PlayerData.json`), {encoding: 'utf8'})).slice(client.statsGraph)
+        // handle negative days
+        data.forEach((change: number, i: number) => {
+          if (change < 0) data[i] = data[i - 1] || data[i + 1] || 0;
+        });
+
+        const first_graph_top = 16;
+        const second_graph_top = 16;
+        const textSize = 40;
+
+        const img = canvas.createCanvas(1500, 750);
+        const ctx = img.getContext('2d');
+
+        const graphOrigin = [15, 65];
+        const graphSize = [1300, 630];
+        const nodeWidth = graphSize[0] / (data.length - 1);
+        ctx.fillStyle = '#36393f'; //'#111111';
+        ctx.fillRect(0, 0, img.width, img.height);
+
+        // grey horizontal lines
+        ctx.lineWidth = 5;
+
+        let interval_candidates = [];
+        for (let i = 4; i < 10; i++) {
+          const interval = first_graph_top / i;
+          if (Number.isInteger(interval)) {
+            let intervalString = interval.toString();
+            const reference_number = i * Math.max(intervalString.split('').filter(x => x === '0').length / intervalString.length, 0.3) * (['1', '2', '4', '5', '6', '8'].includes(intervalString[0]) ? 1.5 : 0.67)
+            interval_candidates.push([interval, i, reference_number]);
+          }
+        }
+        const chosen_interval = interval_candidates.sort((a, b) => b[2] - a[2])[0];
+
+        const previousY: Array<number> = [];
+
+        ctx.strokeStyle = '#202225'; //'#555B63';
+        for (let i = 0; i <= chosen_interval[1]; i++) {
+          const y = graphOrigin[1] + graphSize[1] - (i * (chosen_interval[0] / second_graph_top) * graphSize[1]);
+          if (y < graphOrigin[1]) continue;
+          const even = ((i + 1) % 2) === 0;
+          if (even) ctx.strokeStyle = '#2c2f33'; //'#3E4245';
+          ctx.beginPath();
+          ctx.lineTo(graphOrigin[0], y);
+          ctx.lineTo(graphOrigin[0] + graphSize[0], y);
+          ctx.stroke();
+          ctx.closePath();
+          if (even) ctx.strokeStyle = '#202225'; //'#555B63';
+          previousY.push(y, i * chosen_interval[0]);
+        }
+
+        // 30m mark
+        ctx.setLineDash([8, 16]);
+        ctx.beginPath();
+        const lastMonthStart = graphOrigin[0] + (nodeWidth * (data.length - 30));
+        ctx.lineTo(lastMonthStart, graphOrigin[1]);
+        ctx.lineTo(lastMonthStart, graphOrigin[1] + graphSize[1]);
+        ctx.stroke();
+        ctx.closePath();
+        ctx.setLineDash([]);
+
+        // draw points
+        ctx.lineWidth = 5;
+
+        function getYCoordinate(value: number) {
+          return ((1 - (value / second_graph_top)) * graphSize[1]) + graphOrigin[1];
+        }
+
+        function colorAtPlayercount(playercount: number) {
+          if (playercount === first_graph_top) return client.config.embedColorRed as string;
+          else if (playercount > 9) return client.config.embedColorYellow as string;
+          else return client.config.embedColorGreen as string
+        }
+        let lastCoords: Array<number> = [];
+        data.forEach((curPC: number /* current player count, i: number) => {
+          if (curPC < 0) curPC = 0;
+          const x = i * nodeWidth + graphOrigin[0];
+          const y = getYCoordinate(curPC);
+          const nexPC /* next player count = data[i + 1];
+          const prvPC /* previous player count = data[i - 1];
+          const curColor = colorAtPlayercount(curPC); // color now
+          const prvColor = colorAtPlayercount(prvPC); // color at last point
+          if (curColor !== prvColor && !isNaN(prvPC) && lastCoords.length > 0) { // gradient should be used when the color between now and last point is not the same
+            // gradient from now to last point
+            const grd = ctx.createLinearGradient(lastCoords[0], lastCoords[1], x, y);
+            grd.addColorStop(0, colorAtPlayercount(prvPC)); // prev color at the beginning
+            grd.addColorStop(1, colorAtPlayercount(curPC)); // cur color at the end
+            // special case: playercount rises or falls rapidly accross all colors (eg. straight from red to green)
+            if (curColor !== client.config.embedColorYellow && prvColor !== client.config.embedColorYellow) {
+              const yellowY = getYCoordinate(10); // y coordinate at which line should be yellow
+              const stop = (yellowY - lastCoords[1]) / (y - lastCoords[1]); // between 0 and 1, where is yellowY between y and nextPointCoords[1] ?
+              grd.addColorStop(stop, client.config.embedColorYellow as string); // add a yellow stop to the gradient
+            }
+            ctx.strokeStyle = grd;
+          } else ctx.strokeStyle = colorAtPlayercount(curPC);
+          ctx.beginPath();
+          if (lastCoords.length > 0) ctx.moveTo(lastCoords[0], lastCoords[1]);
+          // if the line being drawn is horizontal, make it go until it has to go down
+          if (y === lastCoords[1]) {
+            let newX = x;
+            for (let j = i + 1; j <= data.length; j++) {
+              if (data[j] === curPC) newX += nodeWidth; else break;
+            }
+            ctx.lineTo(newX, y);
+          } else ctx.lineTo(x, y);
+          lastCoords = [x, y];
+          ctx.stroke();
+          ctx.closePath();
+
+          if (curPC === prvPC && curPC === nexPC) return; // no ball because no vertical difference to next or prev point
+          else {
+            // ball
+            ctx.fillStyle = colorAtPlayercount(curPC);
+            ctx.beginPath();
+            ctx.arc(x, y, ctx.lineWidth * 1.3, 0, 2 * Math.PI)
+            ctx.closePath();
+            ctx.fill();
+          }
+        });
+
+        // draw text
+        ctx.font = '400 ' + textSize + 'px sans-serif';
+        ctx.fillStyle = 'white';
+
+        // highest value
+        const maxx = graphOrigin[0] + graphSize[0] + textSize / 2;
+        const maxy = previousY[0] + (textSize / 3);
+        ctx.fillText(previousY[1].toLocaleString('en-US'), maxx, maxy);
+
+        // lowest value
+        const lowx = graphOrigin[0] + graphSize[0] + textSize / 2;
+        const lowy = graphOrigin[1] + graphSize[1] + (textSize / 3);
+        ctx.fillText('0 players', lowx, lowy);
+
+        // 30m
+        ctx.fillText('30 mins ago', lastMonthStart, graphOrigin[1] - (textSize / 2));
+
+        // time ->
+        const tx = graphOrigin[0] + (textSize / 2);
+        const ty = graphOrigin[1] + graphSize[1] + (textSize);
+        ctx.fillText('time ->', tx, ty);
+
+        const embed1 = new client.embed();
+        const FSserver1 = await MPdata(client, interaction, embed1, 'mainServer')
+        if (!FSserver1?.data) return console.log('FSserver1 failed - players')
+        embed1.setTitle(FSserver1?.data.server.name.length === 0 ? 'Offline' : FSserver1?.data.server.name)
+          .setDescription(`${FSserver1?.data.slots.used}/${FSserver1?.data.slots.capacity}`)
+          .setColor(FSserver1?.data.server.name.length === 0 ? client.config.embedColorRed : client.config.embedColor)
+          .setImage('attachment://FSStats.png');
+        FSserver1?.data.slots.players.filter(x=>x.isUsed).forEach(player=>embed1.addFields({name: `${player.name} ${player.isAdmin ? '| admin' : ''}`, value: `Farming for ${client.formatPlayerUptime(player.uptime)}`}))
+        interaction.reply({embeds: [embed1], files: [new client.attachmentBuilder(img.toBuffer(),{name:'FSStats.png'})]})
+      },
+      maintenance: ()=>{
+        if (client.config.mainServer.id == interaction.guildId) {
+          if (!interaction.member.roles.cache.has(client.config.mainServer.roles.mpmanager) && !interaction.member.roles.cache.has(client.config.mainServer.roles.bottech) && !interaction.member.roles.cache.has(client.config.mainServer.roles.admin)) return client.youNeedRole(interaction, 'mpmanager');
+        }
+        const maintenanceMessage = interaction.options.getString('message');
+        const activePlayersChannel = '739084625862852715';
+        const channel = (client.channels.cache.get(activePlayersChannel) as Discord.TextChannel);
+        if (channel.permissionOverwrites.cache.get(interaction.guildId).deny.has('SendMessages')) {
+          channel.permissionOverwrites.edit(interaction.guildId, {SendMessages: true}, {type: 0, reason: `Unlocked by ${interaction.member.displayName}`});
+          channel.send({embeds: [new client.embed().setColor(client.config.embedColor).setAuthor({name: interaction.member.displayName, iconURL: interaction.member.displayAvatarURL({size:1024})}).setTitle('🔓 Channel unlocked').setDescription(`**Reason:**\n${maintenanceMessage}`).setTimestamp()]});
+          interaction.reply({content: `<#${activePlayersChannel}> has been unlocked!`, ephemeral: true});
+        } else if (channel.permissionOverwrites.cache.get(interaction.guildId).allow.has('SendMessages')) {
+          channel.permissionOverwrites.edit(interaction.guildId, {SendMessages: false}, {type: 0, reason: `Locked by ${interaction.member.displayName}`});
+          channel.send({embeds: [new client.embed().setColor(client.config.embedColor).setAuthor({name: interaction.member.displayName, iconURL: interaction.member.displayAvatarURL({size:1024})}).setTitle('🔒 Channel locked').setDescription(`**Reason:**\n${maintenanceMessage}`).setTimestamp()]});
+          interaction.reply({content: `<#${activePlayersChannel}> has been locked!`, ephemeral: true});
+        }
+      }
     } as any)[interaction.options.getSubcommand()]();
   },
   data: new Discord.SlashCommandBuilder()
@@ -91,3 +525,4 @@ export default {
         .setDescription('The reason why is the server unavailable for?')
         .setRequired(true)))
 }
+ */

src/index.ts

@@ -67,10 +67,10 @@ if (client.config.botSwitches.music){
 }
 
 // YouTube Upload notification and Daggerwin MP loop
-setInterval(async()=>{
+if (client.config.botSwitches.mpstats) setInterval(async()=>{
   const serverlake = (await client.MPServer._content.findById(client.config.mainServer.id));
-  for await (const [locName, locArea] of Object.entries(client.config.MPStatsLocation)) await MPLoop(client, locArea.channel, locArea.message, serverlake[locName])
+  for await (const [locName, locArea] of Object.entries(client.config.MPStatsLocation)) await MPLoop(client, locArea.channel, locArea.message, serverlake[locName], locName)
-}, 10000);
+}, 30000);
 setInterval(async()=>{
 	client.YTLoop('UCQ8k8yTDLITldfWYKDs3xFg', 'Daggerwin', '528967918772551702'); // 528967918772551702 = #videos-and-streams
 	client.YTLoop('UCguI73--UraJpso4NizXNzA', 'Machinery Restorer', '767444045520961567') // 767444045520961567 = #machinery-restorer

src/typings/interfaces.d.ts

@@ -192,15 +192,12 @@ export interface Config {
     }
   }
 }
-export interface MPServerCache {
+export type MPServerCache = Record<string,{
-  main: {
   players: FSPlayer[],
   status: 'online' | 'offline' | null,
   name: string | null
-  },
+}>
-  second: {
+export interface TServer {
-    players: FSPlayer[],
+  ip: string
-    status: 'online' | 'offline' | null,
+  code: string
-    name: string | null
-  }
 }