amendment to last commit

.gitignore

@@ -139,4 +139,4 @@ dist
 pb/data
 
 # config files
-auth.json
+.env.*

README.md

@@ -31,6 +31,8 @@ ITEM|FUNCTION|ALIASES
 -|-|-
 `blaster {target}`|Times the target user out for 60 seconds|`!blast, !blaster`
 `silverbullet {target}`|Times the target user out for 24 hours|`!execute, !silverbullet`
+`revive {target}`|Reduce timeout timer of target by 30 seconds|`!revive, !heal`
+`superrevive {target}`|Reduce timeout timer of target by 12|`!superrevive, !superheal`
 `grenade`|Times a random chatter out for 60 seconds|`!grenade`
 `tnt`|Times out 1 to 10 chatters for 60 seconds|`!tnt`
 `lootbox`|Gives the user some qbucks, and possibly some items|`!lootbox`
@@ -105,7 +107,7 @@ VARIABLE|DEFAULT|FUNCTION|REQUIRED
 `COOLDOWN`|24 Hours|Cooldown between letting users get a lootbox with `!getloot` in seconds|:x:
 `CLIENT_ID`|None|Set the CLIENT_ID to authenticate the bot|:bangbang:
 `CLIENT_SECRET`|None|Set the CLIENT_SECRET to authenticate the bot|:bangbang:
-`REDIRECT_URI`|`https://qweri0p.github.io/url-params/`|The REDIRECT_URI set in the twitch dev console|:bangbang:
+`REDIRECT_URI`|`https://qwerinope.github.io/url-params/`|The REDIRECT_URI set in the twitch dev console|:bangbang:
 `OAUTH_CODE`|None|Authorization code for OAuth|:bangbang:
 `DIFFERENT_BROADCASTER`|`false`|Set this to true when `BOT_NAME` and `CHANNEL` are different.|:white_check_mark:
 `BROADCASER_OAUTH_CODE`|None|OAuth authorization code for the broadcaster (ignored if `DIFFERENT_BROADCASTER` is false)|:bangbang:

src/commands/admin.ts

@@ -1,10 +1,11 @@
 import { createBotCommand } from "@twurple/easy-bot";
 import api from "../lib/api";
+import items from "../items"
 import { changeItemCount } from "../lib/items";
 import { changeBalance } from "../lib/userHelper";
 import { vulnerableUsers } from "../lib/timeoutHelper";
 
-const give = createBotCommand('give', async (params, { say, broadcasterId, userId, userName }) => {
+const give = createBotCommand('give', async (params, { say, broadcasterId, userId }) => {
     if (userId !== broadcasterId) return
 
     const target = await api.users.getUserByName(params[0].replace(/[@]/g, ''))
@@ -17,10 +18,11 @@ const give = createBotCommand('give', async (params, { say, broadcasterId, userI
     if (data.reason === 'negative') { await say(`${target.name} only has ${data.count}. Cannot yoink ${-parseInt(params[2])} ${params[1]}`); return }
     else if (data.reason === 'noexist') { await say(`Can't find item ${params[1]}`); return }
 
-    await say(`${target.name} now has ${data.count} ${params[1]}`)
+    const selection = items.find(item => item.name === params[1].toLowerCase())
+    await say(`${target.displayName} now has ${data.count} ${params[1]}${data.count === 1 ? '' : selection?.plural}`)
 })
 
-const vulnChatters = createBotCommand('vulnchatters', async (_params, { say, userId, broadcasterId, userName }) => {
+const vulnChatters = createBotCommand('vulnchatters', async (_params, { say, userId, broadcasterId }) => {
     if (userId !== broadcasterId) return
 
     await say(`There are ${vulnerableUsers.length} vulnerable chatters`)

src/commands/getloot.ts

@@ -15,7 +15,7 @@ function getTimeDifference(date1: number, date2: number) {
 
 export default createBotCommand('getloot', async (_params, { reply, userId }) => {
     const user = await api.users.getUserById(userId)
-    const data = await lootboxReady(user)
+    const data = await lootboxReady(user!)
     if (!data.result) {
         const { days, hours, minutes, seconds } = getTimeDifference(data.lastlootbox, Date.now() - COOLDOWN)
         await reply(`lootbox ready in: 

src/commands/index.ts

@@ -5,9 +5,10 @@ import getloot from "./getloot";
 import modme from "./modme";
 import use from "./use";
 import iteminfo from "./iteminfo"
+import leaderboard from "./leaderboard"
 
 import stats from "./stats"
 import aliases from "./itemAliases"
 import admin from "./admin"
 
-export default [timeout, inventory, qbucks, getloot, modme, use, iteminfo, ...aliases, ...admin, ...stats]
+export default [timeout, inventory, qbucks, getloot, modme, use, iteminfo, leaderboard, ...aliases, ...admin, ...stats]

src/commands/inventory.ts

@@ -1,12 +1,13 @@
 import { createBotCommand } from "@twurple/easy-bot";
 import { getInventory } from "../lib/userHelper";
 import api from "../lib/api";
+import items from "../items";
 import { HelixUser } from "@twurple/api";
 
-export default createBotCommand('inv', async (params, { userName, say }) => {
+export default createBotCommand('inv', async (params, { userName, say, userDisplayName }) => {
     let user: HelixUser | null
     if (params.length !== 0) {
-        user = await api.users.getUserByName(params[0].replace(/[^a-zA-Z0-9]/g, ''))
+        user = await api.users.getUserByName(params[0].replace(/[@]/g, ''))
     } else user = await api.users.getUserByName(userName)
     if (!user) {
         await say(`User ${params[0]} not found`)
@@ -15,38 +16,18 @@ export default createBotCommand('inv', async (params, { userName, say }) => {
 
     const data = params.length === 0 ? { me: true, inv: await getInventory(user!) } : { me: false, inv: await getInventory(user!) }
 
-    interface parsedData {
-        amount: number,
-        name: string,
-        plural: string
+    const messagedata: string[] = []
+
+    for (const [key, amount] of Object.entries(data.inv)) {
+        if (amount === 0) continue
+        const itemselection = items.find(item => item.name === key)
+        messagedata.push(`${itemselection?.prettyname}${amount === 1 ? '' : itemselection?.plural}: ${amount}`)
     }
 
-    let dataparsed: parsedData[] = []
-    for (const key of Object.entries(data.inv)) {
-        if (key[1] === 0) continue
-        switch (key[0]) {
-            case 'lootbox':
-                dataparsed.push({ amount: key[1], name: key[0], plural: 'es' })
-                break
-            case 'version':
-                break
-            default:
-                dataparsed.push({ amount: key[1], name: key[0], plural: 's' })
-                break
-        }
-    }
-
-    if (!dataparsed) { await say(`${data.me ? userName : params[0]} has no items!`); return }
-
-    let messagedata: string[] = []
-    for (const item of dataparsed) {
-        messagedata.push(`${item.name + (item.amount === 1 ? '' : item.plural)}: ${item.amount}`)
-    }
-
-    if (messagedata.length === 0) {await say(`${data.me ? userName : params[0]} has no items!`); return}
+    if (messagedata.length === 0) { await say(`${data.me ? userDisplayName : params[0]} has no items!`); return }
 
     await say(`
-        inventory of ${data.me ? userName : params[0]}: 
+        inventory of ${data.me ? userDisplayName : user.displayName}: 
         ${messagedata.join(', ')}
     `)
 }, { aliases: ['inventory'] })

src/commands/itemAliases.ts

@@ -1,39 +1,38 @@
-import { createBotCommand } from "@twurple/easy-bot";
+import { BotCommand, createBotCommand } from "@twurple/easy-bot";
 
-import { useBlaster, useClipboard, useGrenade, useLootbox, useSilverBullet, useTNT } from "../lib/items";
 import api from "../lib/api";
+import items from "../items";
+import { ITEMBUSY, toggleBusy } from "../lib/items";
 
-const blaster = createBotCommand('blaster', async (params, { say, broadcasterId, userId }) => {
-    const user = await api.users.getUserById(userId)
-    if (params[0] === undefined) return
-    await useBlaster(broadcasterId, user!, params[0].replace(/[@]/g, ''), say)
-}, { aliases: ['blast'] })
+const aliascommands: BotCommand[] = []
 
-const silverbullet = createBotCommand('execute', async (params, { say, broadcasterId, userId }) => {
-    const user = await api.users.getUserById(userId)
-    if (params[0] === undefined) return
-    await useSilverBullet(broadcasterId, user!, params[0].replace(/[@]/g, ''), say)
-}, { aliases: ['silverbullet'] })
+for (const item of items) {
+    aliascommands.push(createBotCommand(item.name, async (params, { say, reply, broadcasterId, userId }) => {
+        if (ITEMBUSY) { await reply(`There is currently an item in use. Try again.`); return }
+        const user = await api.users.getUserById(userId)
+        toggleBusy()
+        switch (item.name) {
+            case 'blaster':
+            case 'silverbullet':
+            case 'revive':
+            case 'superrevive':
+                if (params[0] === undefined) { await reply('Please specify a target'); return }
+                await item.execute(user!, say, broadcasterId, params[0].replace(/[@]/g, ''))
+                break
+            case 'grenade':
+            case 'tnt':
+                await item.execute(user!, say, broadcasterId)
+                break
+            case 'lootbox':
+                await item.execute(user!, say)
+                break
+            case 'clipboard':
+                if (params[0] === undefined) { await reply("Please specify what the clipboard asks") }
+                await item.execute(user!, say, broadcasterId, params.join(' '))
+                break
+        }
+        toggleBusy()
+    }, { aliases: item.aliases }))
+}
 
-const grenade = createBotCommand('grenade', async (_params, { say, broadcasterId, userId }) => {
-    const user = await api.users.getUserById(userId)
-    await useGrenade(broadcasterId, user!, say)
-})
-
-const tnt = createBotCommand('tnt', async (_params, { say, broadcasterId, userId }) => {
-    const user = await api.users.getUserById(userId)
-    await useTNT(broadcasterId, user!, say)
-})
-
-const lootbox = createBotCommand('lootbox', async (_params, { say, userId }) => {
-    const user = await api.users.getUserById(userId)
-    await useLootbox(user!, say)
-})
-
-const clipboard = createBotCommand('clipboard', async (params, { say, broadcasterId, userId }) => {
-    const user = await api.users.getUserById(userId)
-    if (params[0] === undefined) return
-    await useClipboard(broadcasterId, user!, params.join(' '), say)
-})
-
-export default [blaster, silverbullet, grenade, tnt, lootbox, clipboard]
+export default aliascommands

src/commands/iteminfo.ts

@@ -1,31 +1,9 @@
 import { createBotCommand } from "@twurple/easy-bot";
+import items from "../items"
 
 export default createBotCommand('iteminfo', async (params, { say }) => {
     if (params[0] === undefined) { await say('No item specified!'); return }
-    let message = ''
-    switch (params[0].toLowerCase()) {
-        case 'blaster':
-            message = "Use: blaster {target}, Function: Times the target user out for 60 seconds. Aliases: !blast, !blaster"
-            break
-        case 'silver':
-        case 'silverbullet':
-            message = "Use: silverbullet {target}, Function: Times the target user out for 24 hours. Aliases: !execute, !silverbullet"
-            break
-        case 'grenade':
-            message = "Use: grenade, Function: Times a random chatter out for 60 seconds. Aliases: !grenade"
-            break
-        case 'tnt':
-            message = "Use: tnt, Function: Times out 1 to 10 chatters for 60 seconds. Aliases: !tnt"
-            break
-        case 'lootbox':
-            message = "Use: lootbox, Function: Gives the user some qbucks, and possibly some items. Aliases: !lootbox"
-            break
-        case 'clipboard':
-            message = "Use: clipboard {message}, Function: Starts a two minute long poll with the user specified message. Aliases: !clipboard"
-            break
-        default:
-            message = "Item not found"
-            break
-    }
-    await say(message)
+    const selection = items.find(item => item.aliases.includes(params[0].toLowerCase()))
+    if (!selection) { await say('Item not found'); return }
+    await say(selection.description)
 }, { aliases: ['item'] })

src/commands/leaderboard.ts

@@ -0,0 +1,22 @@
+import { createBotCommand } from "@twurple/easy-bot"
+import pb, { User } from "../lib/pocketbase"
+import { getTimeouts } from "../lib/userHelper"
+
+type KDData = { user: User, KD: number }
+
+export default createBotCommand('leaderboard', async (_params, { say }) => {
+    const users = await pb.collection('users').getFullList()
+    let userKDs: KDData[] = []
+    for (const user of users) {
+        const data = await getTimeouts(user.id)
+        if (data.hit.blaster < 5) continue
+        const KD = data.shot.blaster / data.hit.blaster
+        const obj: KDData = { user, KD }
+        userKDs.push(obj)
+    }
+    if (userKDs.length === 0) { await say('No users on leaderboard yet!'); return }
+    userKDs.sort((data1, data2) => data2.KD - data1.KD)
+    const textlist: string[] = []
+    for (let i = 0; i < (userKDs.length < 5 ? userKDs.length : 5); i++) textlist.push(`${i + 1}. ${userKDs.at(i)!.user.firstname}: ${userKDs.at(i)!.KD.toFixed(2)}`)
+    await say(`${textlist.join(' | ')}`)
+}, { aliases: ['kdleaderboard'] })

src/commands/modme.ts

@@ -1,11 +1,9 @@
 import { createBotCommand } from "@twurple/easy-bot";
 import api, { broadcasterApi } from "../lib/api";
-
-const MODS = process.env.MODS
-if (!MODS) { console.error("Please set the MODS environment variable."); process.exit(1) }
+import { MODS } from "../lib/timeoutHelper";
 
 export default createBotCommand('modme', async (_params, { userName, broadcasterId, userId }) => {
-    if (!MODS.includes(userName)) return
+    if (!MODS!.includes(userName)) return
 
     if (broadcasterApi) await broadcasterApi.moderation.addModerator(broadcasterId, userId)
     else await api.moderation.addModerator(broadcasterId, userId)

src/commands/qbucks.ts

@@ -14,6 +14,6 @@ export default createBotCommand('balance', async (params, { userName, say }) =>
     }
 
     const data = await getBalance(user)
-    await say(`${user.name} has ${data.balance} qbucks`)
+    await say(`${user.displayName} has ${data.balance} qbucks`)
 
 }, { aliases: ['qbucks', 'qweribucks', 'bal'] })

src/commands/stats.ts

@@ -3,7 +3,7 @@ import api from "../lib/api";
 import { getStats } from "../lib/userHelper";
 import { HelixUser } from "@twurple/api";
 
-const stats = createBotCommand('stats', async (params, { say, userName }) => {
+const stats = createBotCommand('stats', async (params, { say, userName, userDisplayName }) => {
     let user: HelixUser | null
     if (params.length !== 0) {
         user = await api.users.getUserByName(params[0].replace(/[@]/g, ''))
@@ -21,9 +21,9 @@ const stats = createBotCommand('stats', async (params, { say, userName }) => {
 
     await say(
         `
-        THIS MONTH: Stats of ${data.me ? userName : params[0]}: 
+        THIS MONTH: Stats of ${data.me ? userDisplayName : user.displayName}: 
         Users blasted: ${data.stats.shot.blaster},
-        Blasted by others: ${data.stats.hit.blaster} (${isNaN(KD) ? 0 : KD.toFixed(3)} K/D).
+        Blasted by others: ${data.stats.hit.blaster} (${isNaN(KD) ? 0 : KD.toFixed(2)} K/D).
         Grenades lobbed: ${data.stats.used.grenade}
         TNTs lit: ${data.stats.used.tnt},
         Silver bullets fired: ${data.stats.shot.silverbullet},
@@ -32,7 +32,7 @@ const stats = createBotCommand('stats', async (params, { say, userName }) => {
     )
 })
 
-const alltime = createBotCommand('alltime', async (params, { say, userName }) => {
+const alltime = createBotCommand('alltime', async (params, { say, userName, userDisplayName }) => {
     let user: HelixUser | null
     if (params.length !== 0) {
         user = await api.users.getUserByName(params[0].replace(/[@]/g, ''))
@@ -48,9 +48,9 @@ const alltime = createBotCommand('alltime', async (params, { say, userName }) =>
 
     await say(
         `
-        ALLTIME: Stats of ${data.me ? userName : params[0]}: 
+        ALLTIME: Stats of ${data.me ? userDisplayName : user.displayName}: 
         Users blasted: ${data.stats.shot.blaster},
-        Blasted by others: ${data.stats.hit.blaster} (${isNaN(KD) ? 0 : KD.toFixed(3)} K/D).
+        Blasted by others: ${data.stats.hit.blaster} (${isNaN(KD) ? 0 : KD.toFixed(2)} K/D).
         Grenades lobbed: ${data.stats.used.grenade}
         TNTs lit: ${data.stats.used.tnt},
         Silver bullets fired: ${data.stats.shot.silverbullet},

src/commands/timeout.ts

@@ -3,7 +3,7 @@ import { addTimeoutToDB, timeout } from "../lib/timeoutHelper";
 import { changeBalance, getBalance } from "../lib/userHelper";
 import api from "../lib/api";
 
-export default createBotCommand('timeout', async (params, { say, broadcasterId, userName }) => {
+export default createBotCommand('timeout', async (params, { say, broadcasterId, userName, userDisplayName }) => {
     const attacker = await api.users.getUserByName(userName)
     const userbal = await getBalance(attacker!)
     if (userbal.balance < 100) { await say('not enough qbucks'); return }
@@ -11,7 +11,7 @@ export default createBotCommand('timeout', async (params, { say, broadcasterId,
     const target = await api.users.getUserByName(params[0].replace(/[@]/g, ''))
     const status = await timeout(broadcasterId, target!, 60, `You got blasted by ${userName}`)
     if (status.status) {
-        await say(`${params[0]} got blasted by ${userName}! ${userName} now has ${userbal.balance - 100} qbucks remaining`)
+        await say(`${target?.displayName} got blasted by ${userDisplayName}! ${userDisplayName} now has ${userbal.balance - 100} qbucks remaining`)
         await changeBalance(attacker!, -100)
         await addTimeoutToDB(attacker!, target!, 'blaster')
     }
@@ -21,7 +21,7 @@ export default createBotCommand('timeout', async (params, { say, broadcasterId,
                 await say(`${params[0]} doesn't exist!`)
                 break
             case 'banned':
-                await say(`${params[0]} is already dead!`)
+                await say(`${target?.displayName} is already dead!`)
                 break
             case 'unknown':
                 await say(`NO!`)

src/commands/use.ts

@@ -1,37 +1,38 @@
 import { createBotCommand } from "@twurple/easy-bot";
-import { useBlaster, useClipboard, useGrenade, useLootbox, useSilverBullet, useTNT } from "../lib/items";
 import api from "../lib/api";
+import items from "../items";
+import { ITEMBUSY, toggleBusy } from "../lib/items";
 
-export default createBotCommand('use', async (params, { say, broadcasterId, userId }) => {
+export default createBotCommand('use', async (params, { say, reply, broadcasterId, userId }) => {
     const user = await api.users.getUserById(userId)
 
     if (params[0] === undefined) return
+    const selection = items.find(item => item.aliases.includes(params[0].toLowerCase()))
 
-    switch (params[0].toLowerCase()) {
+    if (!selection) { reply(`${params[0]} does not exist!`); return }
+
+    if (ITEMBUSY) { await reply(`There is currently an item in use. Try again.`); return }
+
+    toggleBusy()
+    switch (selection.name) {
         case 'blaster':
-            if (params[1] === undefined) return
-            await useBlaster(broadcasterId, user!, params[1].replace(/[@]/g, ''), say)
-            break
-        case 'silver':
         case 'silverbullet':
-            if (params[1] === undefined) return
-            await useSilverBullet(broadcasterId, user!, params[1].replace(/[@]/g, ''), say)
+        case 'revive':
+        case 'superrevive':
+            if (params[1] === undefined) { await reply('Please specify a target'); return }
+            await selection.execute(user!, say, broadcasterId, params[1].replace(/[@]/g, ''))
             break
         case 'grenade':
-            await useGrenade(broadcasterId, user!, say)
-            break
         case 'tnt':
-            await useTNT(broadcasterId, user!, say)
+            await selection.execute(user!, say, broadcasterId)
             break
         case 'lootbox':
-        case 'loot':
-            await useLootbox(user!, say)
+            await selection.execute(user!, say)
             break
         case 'clipboard':
-            if (params[1] === undefined) return
-            await useClipboard(broadcasterId, user!, params.slice(1).join(' '), say)
+            if (params[1] === undefined) { await reply("Please specify what the clipboard asks") }
+            await selection.execute(user!, say, broadcasterId, params.slice(1).join(' '))
             break
-        default:
-            await say(`${params[0]} does not exist!`)
     }
+    toggleBusy()
 })

src/items/blasters.ts

@@ -0,0 +1,76 @@
+import { HelixUser } from "@twurple/api";
+import api from "../lib/api";
+import { timeout, addTimeoutToDB } from "../lib/timeoutHelper";
+import { addUsedItem, updateInventory } from "../lib/userHelper";
+import { changeItemCount } from "../lib/items";
+
+export const blaster = {
+    name: 'blaster',
+    prettyname: 'Blaster',
+    aliases: ['blast', 'blaster'],
+    plural: 's',
+    description: "Use: blaster {target}, Function: Times the target user out for 60 seconds. Aliases: !blast, !blaster",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string, targetname: string) => {
+        const target = await api.users.getUserByName(targetname)
+
+        const itemResult = await changeItemCount(user, 'blaster')
+
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no blasters!'); return }
+
+        const result = await timeout(broadcasterId, target, 60, `You got blasted by ${user.displayName}`)
+        if (result.status) {
+            await say(`${target?.displayName} got blasted by ${user.displayName}! ${user.displayName} has ${itemResult.count} blaster${itemResult.count === 1 ? '' : 's'} remaining`)
+            await addTimeoutToDB(user, target!, 'blaster')
+            await addUsedItem(user, 'blaster')
+            await updateInventory(user, itemResult.inv!)
+        } else {
+            switch (result.reason) {
+                case 'noexist':
+                    await say(`${targetname} doesn't exist!`)
+                    break
+                case 'banned':
+                    await say(`${target?.displayName} is already dead!`)
+                    break
+                case 'unknown':
+                    await say(`NO!`)
+                    await timeout(broadcasterId, user, 60, "NO!")
+                    break
+            }
+        }
+    }
+}
+
+export const silverbullet = {
+    name: 'silverbullet',
+    prettyname: 'Silver Bullet',
+    plural: 's',
+    aliases: ['execute', 'silver', 'silverbullet'],
+    description: "Use: silverbullet {target}, Function: Times the target user out for 24 hours. Aliases: !execute, !silverbullet",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string, targetname: string) => {
+        const target = await api.users.getUserByName(targetname)
+
+        const itemResult = await changeItemCount(user, 'silverbullet')
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no silver bullets!'); return }
+
+        const result = await timeout(broadcasterId, target, 60 * 60 * 24, `You got hit by a silver bullet fired by ${user.displayName}`)
+        if (result.status) {
+            await say(`${target?.name} got deleted.`)
+            await addTimeoutToDB(user, target!, 'silverbullet')
+            await addUsedItem(user, 'silverbullet')
+            await updateInventory(user, itemResult.inv!)
+        } else {
+            switch (result.reason) {
+                case 'noexist':
+                    await say(`${targetname} doesn't exist!`)
+                    break
+                case 'banned':
+                    await say(`${target?.displayName} is already dead!`)
+                    break
+                case 'unknown':
+                    await say(`NO!`)
+                    await timeout(broadcasterId, user, 60, "NO!")
+                    break
+            }
+        }
+    }
+}

src/items/clipboard.ts

@@ -0,0 +1,28 @@
+import { HelixUser } from "@twurple/api";
+import api, { broadcasterApi } from "../lib/api"
+import { changeItemCount } from "../lib/items";
+import { addUsedItem, updateInventory } from "../lib/userHelper";
+
+export const clipboard = {
+    name: 'clipboard',
+    prettyname: 'Clipboard',
+    aliases: ['clipboard'],
+    plural: 's',
+    description: "Use: clipboard {message}, Function: Starts a two minute long poll with the user specified message. Aliases: !clipboard",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string, question: string) => {
+        const tempapi = broadcasterApi ?? api
+
+        const polldata = await tempapi.polls.getPolls(broadcasterId)
+        const activepolldata = polldata.data.filter(poll => poll.status === "ACTIVE")
+        if (activepolldata.length > 0) { await say('Can\'t have two polls active at once.'); return }
+
+        const itemResult = await changeItemCount(user, 'clipboard')
+        await addUsedItem(user, 'clipboard')
+        await updateInventory(user, itemResult.inv!)
+
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no clipboards!'); return }
+
+        await tempapi.polls.createPoll(broadcasterId, { choices: ['Yes', 'No'], duration: 120, title: question })
+        await say(`${user.displayName} used a clipboard! They have ${itemResult.count} clipboard${itemResult.count === 1 ? '' : 's'} remaining`)
+    }
+}

src/items/explosives.ts

@@ -0,0 +1,76 @@
+import api from "../lib/api";
+import { addTimeoutToDB } from "../lib/timeoutHelper";
+import { addUsedItem, updateInventory } from "../lib/userHelper";
+import { changeItemCount } from "../lib/items";
+import { vulnerableUsers, timeout } from "../lib/timeoutHelper";
+import { HelixUser } from "@twurple/api";
+
+function shuffle(arrayold: any[]) {
+    let array = arrayold
+    let currentIndex = array.length;
+    while (currentIndex != 0) {
+        let randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    }
+    return array
+}
+
+export const grenade = {
+    name: 'grenade',
+    prettyname: 'Grenade',
+    aliases: ['grenade'],
+    plural: 's',
+    description: "Use: grenade, Function: Times a random chatter out for 60 seconds. Aliases: !grenade",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string) => {
+        if (vulnerableUsers.length === 0) { await say('No chatters to blow up!'); return }
+        const itemResult = await changeItemCount(user, 'grenade')
+
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no grenades!'); return }
+        const target = await api.users.getUserById(vulnerableUsers[Math.floor(Math.random() * vulnerableUsers.length)])
+        const result = await timeout(broadcasterId, target!, 60, `You got hit by ${user.displayName}'s grenade`)
+        if (result.status) {
+            await say(`${target?.displayName} got blown up by ${user.displayName}'s grenade!`)
+            await addTimeoutToDB(user, target!, 'grenade')
+            await addUsedItem(user, 'grenade')
+            await updateInventory(user, itemResult.inv!)
+        } else {
+            // Banned is not an option, and neither is noexist
+            await say(`something went wrong`)
+            console.error(result.reason)
+        }
+    }
+}
+
+export const tnt = {
+    name: 'tnt',
+    prettyname: 'TNT',
+    aliases: ['tnt'],
+    plural: 's',
+    description: "Use: tnt, Function: Times out 1 to 10 chatters for 60 seconds. Aliases: !tnt",
+    execute: async (user: HelixUser, say: (args0: string) => Promise<void>, broadcasterId: string) => {
+        if (vulnerableUsers.length === 0) { await say('No chatters to blow up!'); return }
+        const itemResult = await changeItemCount(user, 'tnt')
+
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no TNT!'); return }
+        const min = vulnerableUsers.length < 3 ? vulnerableUsers.length : 3 //if less than 3 chatters, use that else 3
+        const max = vulnerableUsers.length > 10 ? 10 : vulnerableUsers.length //if more than 10 chatters do 10 else 10
+        const blastedusers = Math.floor(Math.random() * (max - min + 1)) + min
+        const soontobedeadusers = shuffle(vulnerableUsers).slice(vulnerableUsers.length - blastedusers)
+        const targets = await api.users.getUsersByIds(soontobedeadusers)
+        for (const target of targets) {
+            const result = await timeout(broadcasterId, target!, 60, `You got hit by ${user.displayName}'s TNT`)
+            if (result.status) {
+                await say(`${target?.displayName} got blown up by TNT!`)
+                await addTimeoutToDB(user, target!, 'tnt')
+                await updateInventory(user, itemResult.inv!)
+            } else {
+                await say(`something went wrong`)
+                console.error(result.reason)
+            }
+        }
+
+        await addUsedItem(user, 'tnt')
+        await say(`${user.displayName} blew up ${blastedusers} chatters with their TNT! ${user.displayName} has ${itemResult.count} tnt${itemResult.count === 1 ? '' : 's'} remaining`)
+    }
+}

src/items/index.ts

@@ -0,0 +1,19 @@
+import { HelixUser } from "@twurple/api"
+
+import { blaster, silverbullet } from "./blasters"
+import { grenade, tnt } from "./explosives"
+import { revive, superrevive } from "./revives"
+import { lootbox } from "./lootbox"
+import { clipboard } from "./clipboard"
+
+interface item {
+    name: string,
+    prettyname: string,
+    aliases: string[],
+    plural: string,
+    description: string,
+    execute: (user: HelixUser, say: (args0: string) => Promise<void>, broadcasterId?: string, targetname?: string) => Promise<void>
+}
+const data = [blaster, silverbullet, grenade, tnt, revive, superrevive, lootbox, clipboard] as item[]
+export const ITEMS = data.map(item => item.name)
+export default data

src/items/lootbox.ts

@@ -0,0 +1,32 @@
+import { HelixUser } from "@twurple/api";
+import { changeItemCount } from "../lib/items";
+import { addUsedItem, changeBalance, getInventory, updateInventory } from "../lib/userHelper";
+
+function getRandom(): number {
+    return Math.floor(Math.random() * 100)
+}
+
+export const lootbox = {
+    name: 'lootbox',
+    prettyname: 'Lootbox',
+    aliases: ['lootbox', 'loot'],
+    plural: 'es',
+    description: "Use: lootbox, Function: Gives the user some qbucks, and possibly some items. Aliases: !lootbox",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>) => {
+        const itemResult = await changeItemCount(user, 'lootbox')
+        if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no lootboxes!'); return }
+        // Lootbox logic will for now just be get 25 qbucks, with 50% chance to get a grenade 25% chance to get a blaster and 10% chance to get TNT
+        let inventory = await getInventory(user)
+        let newitems: string[] = []
+        await changeBalance(user, 25)
+        newitems.push('25 qbucks')
+        if (getRandom() <= 50) { newitems.push('1 grenade'); inventory.grenade += 1 }
+        if (getRandom() <= 25) { newitems.push('1 blaster'); inventory.blaster += 1 }
+        if (getRandom() <= 10) { newitems.push('1 tnt'); inventory.tnt += 1 }
+        inventory.lootbox = itemResult.inv!.lootbox
+        await updateInventory(user, inventory)
+        await addUsedItem(user, 'lootbox')
+
+        await say(`${user.displayName} got: ${newitems.join(' and ')}`)
+    }
+}

src/items/revives.ts

@@ -0,0 +1,73 @@
+import { HelixUser } from "@twurple/api"
+import api from "../lib/api"
+import { changeItemCount } from "../lib/items"
+import { reviveTarget } from "../lib/timeoutHelper"
+import { addUsedItem, updateInventory } from "../lib/userHelper"
+
+export const revive = {
+    name: 'revive',
+    prettyname: 'Revive',
+    aliases: ['revive', 'heal'],
+    plural: 's',
+    description: "Use: revive {target}, Function: Reduce timeout timer of target by 30 seconds. Aliases: !revive, !heal",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string, targetname: string) => {
+        const target = await api.users.getUserByName(targetname)
+
+        const itemResult = await changeItemCount(user, 'revive')
+        if (!itemResult.result) { await say('You have no revives!'); return }
+
+        const reviveResult = await reviveTarget(broadcasterId, target, 30)
+        if (reviveResult.status) { await updateInventory(user, itemResult.inv!); await addUsedItem(target!, 'revive') }
+        switch (reviveResult.reason) {
+            case 'noexist':
+                await say(`${targetname} does not exist`)
+                break
+            case 'notbanned':
+                await say(`${target?.displayName} doesn't need revives`)
+                break
+            case 'unknown':
+                await say("Something went wrong!")
+                break
+            case 'healed':
+                await say(`${target?.displayName} got healed for 30 seconds by ${user.displayName}`)
+                break
+            case 'revived':
+                await say(`${target?.displayName} got revived by ${user.displayName}`)
+                break
+        }
+    }
+}
+
+export const superrevive = {
+    name: 'superrevive',
+    prettyname: 'Super Revive',
+    aliases: ['superrevive', 'superheal'],
+    plural: 's',
+    description: "Use: superrevive {target}, Function: Reduce timeout timer of target by 12 hours. Aliases: !superrevive, !superheal",
+    execute: async (user: HelixUser, say: (arg0: string) => Promise<void>, broadcasterId: string, targetname: string) => {
+        const target = await api.users.getUserByName(targetname)
+
+        const itemResult = await changeItemCount(user, 'superrevive')
+        if (!itemResult.result) { await say('You have no revives!'); return }
+
+        const reviveResult = await reviveTarget(broadcasterId, target, 60 * 60 * 12)
+        if (reviveResult.status) { await updateInventory(user, itemResult.inv!); await addUsedItem(target!, 'superrevive') }
+        switch (reviveResult.reason) {
+            case 'noexist':
+                await say(`${targetname} does not exist`)
+                break
+            case 'notbanned':
+                await say(`${target?.displayName} doesn't need revives`)
+                break
+            case 'unknown':
+                await say("Something went wrong!")
+                break
+            case 'healed':
+                await say(`${target?.displayName} got healed for 12 hours by ${user.displayName}`)
+                break
+            case 'revived':
+                await say(`${target?.displayName} got revived by ${user.displayName}`)
+                break
+        }
+    }
+}

src/lib/auth.ts

@@ -2,6 +2,8 @@ import { RefreshingAuthProvider, exchangeCode } from '@twurple/auth'
 import pb from './pocketbase'
 import { RecordModel } from 'pocketbase'
 
+const INTENTS = ['channel:manage:moderators', 'moderation:read', 'moderator:manage:banned_users', 'channel:manage:polls', 'channel:read:polls']
+
 let ttvauth: RecordModel | undefined
 try {
     ttvauth = await pb.collection('ttvauth').getFirstListItem('main=true')
@@ -28,17 +30,17 @@ async function firstAccess(main = true) {
     const CLIENT_SECRET = process.env.CLIENT_SECRET
     const OAUTH_CODE = process.env.OAUTH_CODE
     const BROADCASTER_OAUTH_CODE = process.env.BROADCASTER_OAUTH_CODE
-    const REDIRECT_URI = process.env.REDIRECT_URI ?? 'https://qweri0p.github.io/url-params/'
+    const REDIRECT_URI = process.env.REDIRECT_URI ?? 'https://qwerinope.github.io/url-params/'
 
     if (!CLIENT_ID) { console.error("No 'CLIENT_ID' for OAuth defined in environment variables."); process.exit(1) }
     if (!CLIENT_SECRET) { console.error("No 'CLIENT_SECRET' for OAuth defined in environment variables."); process.exit(1) }
     if ((main && !OAUTH_CODE) || (!main && !BROADCASTER_OAUTH_CODE)) {
         if (main) {
             console.error("No 'OAUTH_CODE' provided. To get the code, please visit this URL, authorize the bot and copy the 'code' from the return URL.")
-            console.error(`https://id.twitch.tv/oauth2/authorize?client_id=${CLIENT_ID}&redirect_uri=${REDIRECT_URI}&response_type=code&scope=chat:read+chat:edit+moderator:manage:banned_users+moderation:read+channel:manage:polls+channel:read:polls`)
+            console.error(`https://id.twitch.tv/oauth2/authorize?client_id=${CLIENT_ID}&redirect_uri=${REDIRECT_URI}&response_type=code&scope=chat:read+chat:edit+${INTENTS.join('+')}`)
         } else {
             console.error("No 'BROADCASTER_OAUTH_CODE' provided. To get the code, please make the broadcaster visit the following URL, and get them to return the 'code' from the return URL.")
-            console.error(`https://id.twitch.tv/oauth2/authorize?client_id=${CLIENT_ID}&redirect_uri=${REDIRECT_URI}&response_type=code&scope=moderator:manage:banned_users+moderation:read+channel:manage:moderators+channel:manage:polls+channel:read:polls`)
+            console.error(`https://id.twitch.tv/oauth2/authorize?client_id=${CLIENT_ID}&redirect_uri=${REDIRECT_URI}&response_type=code&scope=${INTENTS.join('+')}`)
         }
         process.exit(1)
     }
@@ -69,7 +71,7 @@ await authProvider.addUserForToken({
     refreshToken: auth.REFRESH_TOKEN,
     expiresIn: auth.EXPIRESIN,
     obtainmentTimestamp: auth.OBTAINMENTTIMESTAMP
-}, ['chat', 'moderator:manage:banned_users', 'channel:manage:polls', 'channel:read:polls', 'channel:manage:moderators'])
+}, ['chat', ...INTENTS])
 
 authProvider.onRefresh(async (_id, newTokenData) => {
     auth.ACCESS_TOKEN = newTokenData.accessToken
@@ -95,7 +97,7 @@ const broadcasterAuthProvider = broadcasterAuthData === undefined ? undefined :
         refreshToken: broadcasterAuthData.REFRESH_TOKEN,
         expiresIn: broadcasterAuthData.EXPIRESIN,
         obtainmentTimestamp: broadcasterAuthData.OBTAINMENTTIMESTAMP
-    }, ['moderator:manage:banned_users', 'moderation:read', 'channel:manage:moderators', 'channel:manage:polls', 'channel:read:polls'])
+    }, INTENTS)
 
     broadcasterAuthProvider.onRefresh(async (_id, newTokenData) => {
         broadcasterAuthData.ACCESS_TOKEN = newTokenData.accessToken

src/lib/items.ts

@@ -1,9 +1,6 @@
 import { HelixUser } from "@twurple/api"
-import { addUsedItem, changeBalance, getInventory, inventory, updateInventory } from "../lib/userHelper"
-import { timeout, addTimeoutToDB, vulnerableUsers } from "./timeoutHelper"
-import api, { broadcasterApi } from "./api"
-
-export const ITEMS = ['blaster', 'silverbullet', 'grenade', 'tnt', 'clipboard', 'lootbox']
+import { getInventory, inventory, updateInventory } from "../lib/userHelper"
+import { ITEMS } from "../items"
 
 interface itemChangeResult {
     result: boolean,
@@ -11,8 +8,10 @@ interface itemChangeResult {
     count: number,
     inv?: inventory
 }
-
-export async function changeItemCount(user: HelixUser, item: string, amount = -1, preconfirmed=false): Promise<itemChangeResult> {
+/** Check if the target user can use/lose item(s) and return the new inventory
+ * @param [amount=-1] If not specified, reduce count by one
+ * @param [preconfirmed=false] If it is confirmed that the change is allowed, update the inventory immediately */
+export async function changeItemCount(user: HelixUser, item: string, amount = -1, preconfirmed = false): Promise<itemChangeResult> {
     if (!ITEMS.includes(item)) return { result: false, reason: 'noexist', count: 0 }
     let inv = await getInventory(user)
 
@@ -22,160 +21,14 @@ export async function changeItemCount(user: HelixUser, item: string, amount = -1
     Object.defineProperty(inv, item, {
         value: newcount,
     })
-    
+
     if (amount > 0 || preconfirmed === true) await updateInventory(user, inv)
 
     return { result: true, reason: '', count: inv[item], inv }
 }
 
-export async function useBlaster(broadcasterId: string, attacker: HelixUser, targetname: string, say: (arg0: string) => Promise<void>) {
-    const target = await api.users.getUserByName(targetname)
+export let ITEMBUSY = false
 
-    const itemResult = await changeItemCount(attacker, 'blaster')
-
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no blasters!'); return }
-
-    const result = await timeout(broadcasterId, target!, 60, `You got blasted by ${attacker.name}`)
-    if (result.status) {
-        await say(`${targetname} got blasted by ${attacker.name}! ${attacker.name} has ${itemResult.count} blaster${itemResult.count === 1 ? '' : 's'} remaining`)
-        await addTimeoutToDB(attacker, target!, 'blaster')
-        await addUsedItem(attacker, 'blaster')
-        await updateInventory(attacker, itemResult.inv!)
-    } else {
-        switch (result.reason) {
-            case 'noexist':
-                await say(`${targetname} doesn't exist!`)
-                break
-            case 'banned':
-                await say(`${targetname} is already dead!`)
-                break
-            case 'unknown':
-                await say(`NO!`)
-                await timeout(broadcasterId, attacker, 60, "NO!")
-                break
-        }
-    }
-}
-
-export async function useSilverBullet(broadcasterId: string, attacker: HelixUser, targetname: string, say: (arg0: string) => Promise<void>) {
-    const target = await api.users.getUserByName(targetname)
-
-    const itemResult = await changeItemCount(attacker, 'silverbullet')
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no silver bullets!'); return }
-
-    const result = await timeout(broadcasterId, target!, 60 * 60 * 24, `You got hit by a silver bullet fired by ${attacker.name}`)
-    if (result.status) {
-        await say(`${target?.name} got deleted.`)
-        await addTimeoutToDB(attacker, target!, 'silverbullet')
-        await addUsedItem(attacker, 'silverbullet')
-        await updateInventory(attacker, itemResult.inv!)
-    } else {
-        switch (result.reason) {
-            case 'noexist':
-                await say(`${targetname} doesn't exist!`)
-                break
-            case 'banned':
-                await say(`${targetname} is already dead!`)
-                break
-            case 'unknown':
-                await say(`NO!`)
-                await timeout(broadcasterId, attacker, 60, "NO!")
-                break
-        }
-    }
-}
-
-export async function useGrenade(broadcasterId: string, attacker: HelixUser, say: (arg0: string) => Promise<void>) {
-    if (vulnerableUsers.length === 0) { await say('No chatters to blow up!'); return }
-    const itemResult = await changeItemCount(attacker, 'grenade')
-
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no grenades!'); return }
-    const target = await api.users.getUserById(vulnerableUsers[Math.floor(Math.random() * vulnerableUsers.length)])
-    const result = await timeout(broadcasterId, target!, 60, `You got hit by ${attacker.name}'s grenade`)
-    if (result.status) {
-        await say(`${target?.name} got blown up by ${attacker.name}'s grenade!`)
-        await addTimeoutToDB(attacker, target!, 'grenade')
-        await addUsedItem(attacker, 'grenade')
-        await updateInventory(attacker, itemResult.inv!)
-    } else {
-        // Banned is not an option, and neither is noexist
-        await say(`something went wrong`)
-        console.error(result.reason)
-    }
-}
-
-export async function useTNT(broadcasterId: string, attacker: HelixUser, say: (args0: string) => Promise<void>) {
-    if (vulnerableUsers.length === 0) { await say('No chatters to blow up!'); return }
-    const itemResult = await changeItemCount(attacker, 'tnt')
-
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no TNT!'); return }
-    const min = vulnerableUsers.length < 3 ? vulnerableUsers.length : 3 //if less than 3 chatters, use that else 3
-    const max = vulnerableUsers.length > 10 ? 10 : vulnerableUsers.length //if more than 10 chatters do 10 else 10
-    const blastedusers = Math.floor(Math.random() * (max - min + 1)) + min
-    const soontobedeadusers = shuffle(vulnerableUsers).slice(vulnerableUsers.length - blastedusers)
-    const targets = await api.users.getUsersByIds(soontobedeadusers)
-    for (const target of targets) {
-        const result = await timeout(broadcasterId, target!, 60, `You got hit by ${attacker.name}'s TNT`)
-        if (result.status) {
-            await say(`${target?.name} got blown up by TNT!`)
-            await addTimeoutToDB(attacker, target!, 'tnt')
-            await updateInventory(attacker, itemResult.inv!)
-        } else {
-            await say(`something went wrong`)
-            console.error(result.reason)
-        }
-    }
-
-    await addUsedItem(attacker, 'tnt')
-    await say(`${attacker.name} blew up ${blastedusers} chatters with their TNT! ${attacker.name} has ${itemResult.count} tnt${itemResult.count === 1 ? '' : 's'} remaining`)
-}
-
-function getRandom(): number {
-    return Math.floor(Math.random() * 100)
-}
-
-export async function useLootbox(user: HelixUser, say: (arg0: string) => Promise<void>) {
-    const itemResult = await changeItemCount(user, 'lootbox')
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no lootboxes!'); return }
-    // Lootbox logic will for now just be get 25 qbucks, with 50% chance to get a grenade 25% chance to get a blaster and 10% chance to get TNT
-    let inventory = await getInventory(user)
-    let newitems: string[] = []
-    await changeBalance(user, 25)
-    newitems.push('25 qbucks')
-    if (getRandom() <= 50) { newitems.push('1 grenade'); inventory.grenade += 1 }
-    if (getRandom() <= 25) { newitems.push('1 blaster'); inventory.blaster += 1 }
-    if (getRandom() <= 10) { newitems.push('1 tnt'); inventory.tnt += 1 }
-    inventory.lootbox = itemResult.inv!.lootbox
-    await updateInventory(user, inventory)
-    await addUsedItem(user, 'lootbox')
-
-    await say(`${user.name} got: ${newitems.join(' and ')}`)
-}
-
-function shuffle(arrayold: any[]) {
-    let array = arrayold
-    let currentIndex = array.length;
-    while (currentIndex != 0) {
-        let randomIndex = Math.floor(Math.random() * currentIndex);
-        currentIndex--;
-        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
-    }
-    return array
-}
-
-export async function useClipboard(broadcasterId: string, user: HelixUser, question: string, say: (arg0: string) => Promise<void>) {
-    const tempapi = broadcasterApi ?? api
-
-    const polldata = await tempapi.polls.getPolls(broadcasterId)
-    const activepolldata = polldata.data.filter(poll => poll.status === "ACTIVE")
-    if (activepolldata.length > 0) { await say('Can\'t have two polls active at once.'); return }
-
-    const itemResult = await changeItemCount(user, 'clipboard')
-    await addUsedItem(user, 'clipboard')
-    await updateInventory(user, itemResult.inv!)
-
-    if (!itemResult.result && itemResult.reason === 'negative') { await say('You have no clipboards!'); return }
-
-    await tempapi.polls.createPoll(broadcasterId, { choices: ['Yes', 'No'], duration: 120, title: question })
-    await say(`${user.name} used a clipboard! They have ${itemResult.count} clipboard${itemResult.count === 1 ? '' : 's'} remaining`)
+export function toggleBusy() {
+    ITEMBUSY = !ITEMBUSY
 }

src/lib/lootboxes.ts

@@ -1,7 +1,6 @@
 import { HelixUser } from "@twurple/api"
 import pb, { User } from "./pocketbase"
 
-
 export const COOLDOWN = (!process.env.COOLDOWN ? 60 * 60 * 24 : Number(process.env.COOLDOWN)) * 1000
 
 interface lootboxReadyResult {
@@ -9,13 +8,14 @@ interface lootboxReadyResult {
     lastlootbox: number,
     DBuser: User
 }
-
-export async function lootboxReady(user: HelixUser | null): Promise<lootboxReadyResult> {
+/** Check if the lootbox is ready for specified user */
+export async function lootboxReady(user: HelixUser): Promise<lootboxReadyResult> {
     const DBuser = await pb.collection('users').getFirstListItem(`id="${user!.id}"`)
     if ((Date.parse(DBuser.lastlootbox) + COOLDOWN) > Date.now()) return { result: false, lastlootbox: Date.parse(DBuser.lastlootbox), DBuser }
     return { result: true, lastlootbox: 0, DBuser }
 }
 
+/** Set the time for last time user got lootbox to now */
 export async function resetLootboxTimer(user: User) {
     const data = { lastlootbox: new Date(Date.now()).toISOString() }
     await pb.collection('users').update(user.id, data)

src/lib/timeoutHelper.ts

@@ -3,6 +3,10 @@ import api, { broadcasterApi } from "./api";
 import pb from "./pocketbase";
 import { DBValidation } from "./userHelper";
 
+const MODSSTRING = process.env.MODS
+if (!MODSSTRING) { console.error("Please set the MODS environment variable."); process.exit(1) }
+export const MODS = MODSSTRING.split(',')
+
 type shooter = 'blaster' | 'grenade' | 'silverbullet' | 'tnt'
 
 interface statusmessage {
@@ -10,18 +14,21 @@ interface statusmessage {
     reason: string
 }
 
-export async function timeout(broadcasterid: string, target: HelixUser, duration: number, reason: string): Promise<statusmessage> {
+/** Ban a specific user out by another user for specified amout of time, with specific reason
+ * If the user does not exist or is already banned return status: false
+ * If the user is a moderator, make sure they get their status back after timeout has elapsed */
+export async function timeout(broadcasterid: string, target: HelixUser | null, duration: number, reason: string): Promise<statusmessage> {
     if (!target) return { status: false, reason: 'noexist' }
     const tmpapi = broadcasterApi ?? api
     if (target.name === process.env.BOT_NAME) return { status: false, reason: 'unknown' }
-    if (await tmpapi.moderation.checkUserBan(broadcasterid, target)) return { status: false, reason: 'banned' }
+    if (await tmpapi.moderation.checkUserBan(broadcasterid, target.id)) return { status: false, reason: 'banned' }
 
     try {
-        if (await tmpapi.moderation.checkUserMod(broadcasterid, target)) {
-            await tmpapi.moderation.removeModerator(broadcasterid, target)
+        if (await tmpapi.moderation.checkUserMod(broadcasterid, target.id)) {
+            await tmpapi.moderation.removeModerator(broadcasterid, target.id)
             remodMod(broadcasterid, target, duration * 1000, tmpapi)
         }
-        await tmpapi.moderation.banUser(broadcasterid, { duration, reason, user: target })
+        await tmpapi.moderation.banUser(broadcasterid, { duration, reason, user: target.id })
         await DBValidation(target)
         return { status: true, reason: '' }
     } catch (err) {
@@ -30,9 +37,32 @@ export async function timeout(broadcasterid: string, target: HelixUser, duration
     }
 }
 
+/** Revive a specific target for a certain amount of time */
+export async function reviveTarget(broadcasterId: string, target: HelixUser | null, duration: number): Promise<statusmessage> {
+    if (!target) return { status: false, reason: 'noexist' }
+    const tmpapi = broadcasterApi ?? api
+    const bandata = await tmpapi.moderation.getBannedUsers(broadcasterId, { userId: target.id })
+    if (!bandata.data[0]) return { status: false, reason: 'notbanned' }
+    const newduration = Math.floor((Date.parse(bandata.data[0].expiryDate?.toString()!) - Date.now()) / 1000 - duration) // (timestamp to freedom - current timestamp) / 1000 (to seconds) - duration
+    try {
+        if (newduration < 3) { // If the target is going to be unbanned in duration + 3 seconds, unban them anyway
+            await tmpapi.moderation.unbanUser(broadcasterId, target)
+            if (MODS.includes(target.name)) remodMod(broadcasterId, target, 0, tmpapi)
+            return { status: true, reason: 'revived' }
+        } else {
+            await tmpapi.moderation.banUser(broadcasterId, { duration: newduration, reason: bandata.data[0].reason!, user: target.id })
+            if (MODS.includes(target.name)) remodMod(broadcasterId, target, newduration * 1000, tmpapi)
+            return { status: true, reason: 'healed' }
+        }
+    } catch (err) {
+        console.error(err)
+        return { status: false, reason: 'unknown' }
+    }
+}
+
+/** Add an entry to the timeouts table */
 export async function addTimeoutToDB(attacker: HelixUser, target: HelixUser, source: shooter) {
     // This has passed the existance check so there's no need to check if the users exist (twitch)
-
     const timeoutobj = {
         source,
         attacker: attacker.id,
@@ -43,16 +73,17 @@ export async function addTimeoutToDB(attacker: HelixUser, target: HelixUser, sou
     await pb.collection('timeouts').create(timeoutobj)
 }
 
+/** Give the target mod status back after timeout */
 function remodMod(broadcasterid: string, target: HelixUser, duration: number, api: ApiClient) {
     setTimeout(async () => {
         const bandata = await api.moderation.getBannedUsers(broadcasterid, { userId: target.id })
         if (bandata.data.length !== 0) {
-            const timeoutleft = -Date.now() + Date.parse(bandata.data[0].expiryDate?.toString()! + 3000) // date when timeout expires - current date + 3 seconds constant
+            const timeoutleft = Date.parse(bandata.data[0].expiryDate?.toString()!) - Date.now() // date when timeout expires - current date + 3 seconds constant
             remodMod(broadcasterid, target, timeoutleft, api) // Call the current function with new time (recursion)
         } else { // If user is still timed out it doesn't try to remod the target
             try {
-                await api.moderation.addModerator(broadcasterid, target)
-            } catch (err) { console.log(err) } // This triggers when the timeout got shortened. try/catch so no runtime error
+                await api.moderation.addModerator(broadcasterid, target.id)
+            } catch (err) { } // This triggers when the timeout got shortened. try/catch so no runtime error
         }
     }, duration + 3000) // callback gets called after duration of timeout + 3 seconds
 }

src/lib/userHelper.ts

@@ -1,16 +1,14 @@
 import pb, { User } from './pocketbase'
 import { HelixUser } from '@twurple/api'
+import itemData, { ITEMS } from '../items'
 
-export const EMPTYINV: inventory = {
-    version: 1,
+const EMPTYINV = itemData.reduce((acc, item) => {
+    acc[item.name] = 0
+    return acc
+}, {} as Record<string, number>)
 
-    blaster: 0,
-    grenade: 0,
-    silverbullet: 0,
-    tnt: 0,
-
-    clipboard: 0,
-    lootbox: 0
+export type inventory = {
+    [K in (keyof typeof EMPTYINV)]: number
 }
 
 type balanceGetResult = {
@@ -18,6 +16,8 @@ type balanceGetResult = {
     data: User
 }
 
+/** Ensures that the user exists in the database
+ * Returns an object with balance as well as the entire user entry from the database */
 export async function getBalance(user: HelixUser): Promise<balanceGetResult> {
     await DBValidation(user)
     const data = await pb.collection('users').getFirstListItem(`id="${user!.id}"`)
@@ -30,6 +30,7 @@ type balanceChangeResult = {
     count: number
 }
 
+/** Changes the balance of the current user by the requested amount */
 export async function changeBalance(user: HelixUser, amount: number): Promise<balanceChangeResult> {
     let { balance, data } = await getBalance(user)
     if (amount < 0 && balance - amount < 0) return { result: false, reason: 'negative', count: balance }
@@ -51,7 +52,9 @@ interface timeoutsGetResult {
 
 const BLASTERS = ['blaster', 'grenade', 'tnt']
 
-async function getTimeouts(userId: string, monthdata?: string): Promise<timeoutsGetResult> {
+/** Get the amount of times the user has (been) shot (by) another user
+ * The 'blaster' data is all timeouts excluding silver bullets */
+export async function getTimeouts(userId: string, monthdata?: string): Promise<timeoutsGetResult> {
     let monthquery = ''
     if (monthdata) monthquery = ` && created~"${monthdata}"`
     const hit = await pb.collection('timeouts').getFullList({ filter: `target="${userId}"${monthquery}` })
@@ -74,33 +77,19 @@ async function getTimeouts(userId: string, monthdata?: string): Promise<timeouts
     }
 }
 
+/** Get the amount of grenades and tnt used by specified user
+ * The monthdata should be something like "2025-01" if specified */
 async function getItemUses(userId: string, monthdata?: string): Promise<inventory> {
     let monthquery = ''
     if (monthdata) monthquery = ` && created~"${monthdata}"`
     const items = await pb.collection('itemuses').getFullList({ filter: `user="${userId}"${monthquery}` })
     return {
-        version: 1,
-        blaster: items.filter((item) => item.name === 'blaster').length,
         grenade: items.filter((item) => item.name === 'grenade').length,
-        silverbullet: items.filter((item) => item.name === 'silverbullet').length,
         tnt: items.filter((item) => item.name === 'tnt').length,
-        clipboard: items.filter((item) => item.name === 'clipboard').length,
-        lootbox: items.filter((item) => item.name === 'lootbox').length
     }
 }
 
-export interface inventory {
-    version: number,
-
-    blaster: number,
-    grenade: number,
-    silverbullet: number,
-    tnt: number,
-
-    clipboard: number,
-    lootbox: number
-}
-
+/** Get the inventory of specific user */
 export async function getInventory(user: HelixUser): Promise<inventory> {
     await DBValidation(user)
     const data = await pb.collection('users').getFirstListItem(`id="${user.id}"`)
@@ -111,39 +100,48 @@ interface statsGetResult extends timeoutsGetResult {
     used: inventory
 }
 
+/** Get the hits, shoot and used item stats from specific user
+ * The monthdata should be something like "2025-01" if specified */
 export async function getStats(user: HelixUser, monthdata?: string): Promise<statsGetResult> {
     await DBValidation(user)
     const { hit, shot } = await getTimeouts(user.id, monthdata)
-    const uses = await getItemUses(user.id, monthdata)
-    return { hit, shot, used: uses }
+    const used = await getItemUses(user.id, monthdata)
+    return { hit, shot, used }
 }
 
+/** Update the inventory of the target user with new inventory data */
 export async function updateInventory(user: HelixUser, newinv: inventory) {
     await DBValidation(user)
     const data = await pb.collection('users').getFirstListItem(`id="${user.id}"`)
     const recordid = data.id
     await pb.collection('users').update(recordid, { inventory: newinv })
 }
-
+/** Creates a new entry in the useditems table */
 export async function addUsedItem(user: HelixUser, item: string) {
     await DBValidation(user)
     await pb.collection('itemuses').create({ user: user.id, name: item })
 }
 
+/** Validate if the HelixUser has an entry in the database
+ * Add missing inventory items*/
 export async function DBValidation(user: HelixUser) {
     try {
-        await pb.collection('users').getFirstListItem(`id="${user.id}"`)
+        let { inventory } = await pb.collection('users').getFirstListItem(`id="${user.id}"`)
+        if (Object.keys(inventory).sort().toString() === ITEMS.sort().toString()) return
+        ITEMS.forEach(key => {
+            if (!(key in inventory)) inventory[key] = 0
+        })
+        await pb.collection('users').update(user.id, { inventory })
     } catch (error) {
         await createUser(user!)
     }
 }
-
+/** Create the user in the database */
 async function createUser(user: HelixUser) {
     const data = {
         id: user.id,
         firstname: user.name,
         inventory: EMPTYINV,
-        itemuses: EMPTYINV,
         lastlootbox: "1970-01-01 12:00:00.000Z",
         balance: 0
     }