added invulnerable chatters, completely reworked the way vulnerable chatters and admins is stored

src/commands/addadmin.ts

@@ -9,6 +9,6 @@ export default new Command('addadmin', ['addadmin'], 'streamer', async msg => {
   const target = await User.initUsername(args[0].toLowerCase());
   if (!target) { await sendMessage(`Chatter ${args[0]} doesn't exist`, msg.messageId); return; };
   const data = await addAdmin(target.id);
-  if (data === 1) await sendMessage(`${target.displayName} is now an admin`, msg.messageId);
+  if (data === "OK") await sendMessage(`${target.displayName} is now an admin`, msg.messageId);
   else await sendMessage(`${target.displayName} is already an admin`, msg.messageId);
 }, false);

src/commands/addinvuln.ts

@@ -0,0 +1,14 @@
+import { Command, sendMessage } from ".";
+import { addInvuln } from "../lib/invuln";
+import parseCommandArgs from "../lib/parseCommandArgs";
+import { User } from "../user";
+
+export default new Command('addinvuln', ['addinvuln'], 'streamer', async msg => {
+  const args = parseCommandArgs(msg.messageText);
+  if (!args[0]) { await sendMessage('Please specify a target', msg.messageId); return; };
+  const target = await User.initUsername(args[0].toLowerCase());
+  if (!target) { await sendMessage(`Chatter ${args[0]} doesn't exist`, msg.messageId); return; };
+  const data = await addInvuln(target.id);
+  if (data === "OK") await sendMessage(`${target.displayName} is now an invuln`, msg.messageId);
+  else await sendMessage(`${target.displayName} is already an invuln`, msg.messageId);
+}, false);

src/commands/getinvulns.ts

@@ -0,0 +1,13 @@
+import { Command, sendMessage } from ".";
+import { getInvulns } from "../lib/invuln";
+import { User } from "../user";
+
+export default new Command('getinvulns', ['getinvulns'], 'chatter', async msg => {
+  const invulns = await getInvulns()
+  const invulnnames: string[] = [];
+  for (const id of invulns) {
+    const invuln = await User.initUserId(id);
+    invulnnames.push(invuln?.displayName!);
+  };
+  await sendMessage(`Current invulnerable chatters: ${invulnnames.join(', ')}`, msg.messageId);
+}, false);

src/commands/removeinvuln.ts

@@ -0,0 +1,16 @@
+import { Command, sendMessage } from ".";
+import { streamerUsers } from "..";
+import { removeInvuln } from "../lib/invuln";
+import parseCommandArgs from "../lib/parseCommandArgs";
+import { User } from "../user";
+
+export default new Command('removeinvuln', ['removeinvuln'], 'streamer', async msg => {
+  const args = parseCommandArgs(msg.messageText);
+  if (!args[0]) { await sendMessage('Please specify a target', msg.messageId); return; };
+  const target = await User.initUsername(args[0].toLowerCase());
+  if (!target) { await sendMessage(`Chatter ${args[0]} doesn't exist`, msg.messageId); return; };
+  if (streamerUsers.includes(target.id)) { await sendMessage(`Can't remove invulnerability from ${target.displayName} as they are managed by the bot program`, msg.messageId); return; };
+  const data = await removeInvuln(target.id);
+  if (data === 1) await sendMessage(`${target.displayName} is no longer invulnerable`, msg.messageId);
+  else await sendMessage(`${target.displayName} isn't invulnerable`, msg.messageId);
+}, false);

src/commands/vulnchatters.ts

@@ -2,7 +2,7 @@ import { redis } from "bun";
 import { Command, sendMessage } from ".";
 
 export default new Command('vulnchatters', ['vulnchatters', 'vulnc'], 'chatter', async msg => {
-  const data = await redis.keys('vulnchatters:*');
+  const data = await redis.keys('user:*:vulnerable');
   const one = data.length === 1;
   await sendMessage(`There ${one ? 'is' : 'are'} ${data.length} vulnerable chatter${one ? '' : 's'}`, msg.messageId);
 });

src/events/message.ts

@@ -7,6 +7,7 @@ import { isAdmin } from "../lib/admins";
 import cheers from "../cheers";
 import logger from "../lib/logger";
 import { addMessageToChatWidget } from "../chatwidget/message";
+import { isInvuln } from "../lib/invuln";
 
 logger.info(`Loaded the following commands: ${commands.keys().toArray().join(', ')}`);
 
@@ -14,8 +15,6 @@ eventSub.onChannelChatMessage(streamerId, streamerId, parseChatMessage);
 
 async function parseChatMessage(msg: EventSubChannelChatMessageEvent) {
   addMessageToChatWidget(msg);
-  if (!singleUserMode && msg.chatterId === chatterId) return;
-  // return if double user mode is on and the chatter says something, we don't need them
 
   const user = await User.initUsername(msg.chatterName);
 
@@ -27,7 +26,7 @@ async function parseChatMessage(msg: EventSubChannelChatMessageEvent) {
   // and both are usable to target the same user (id is the same)
   // The only problem would be if a user changed their name and someone else took their name right after
 
-  if (!streamerUsers.includes(msg.chatterId)) user?.makeVulnerable(); // Make the user vulnerable to explosions if not streamerbot or chatterbot
+  if (!await isInvuln(user?.id!)) user?.setVulnerable(); // Make the user vulnerable to explosions if not marked as invuln
 
   if (!msg.isCheer && !msg.isRedemption) await handleChatMessage(msg, user!)
   else if (msg.isCheer && !msg.isRedemption) await handleCheer(msg, msg.bits, user!);

src/index.ts

@@ -3,6 +3,7 @@ import { ApiClient } from "@twurple/api";
 import { EventSubWsListener } from "@twurple/eventsub-ws";
 import { addAdmin } from "./lib/admins";
 import logger from "./lib/logger";
+import { addInvuln } from "./lib/invuln";
 
 const CHATTERINTENTS = ["user:read:chat", "user:write:chat", "user:bot"];
 const STREAMERINTENTS = ["user:read:chat", "moderation:read", "channel:manage:moderators", "moderator:manage:banned_users", "bits:read"];
@@ -28,7 +29,7 @@ export const eventSub = new EventSubWsListener({ apiClient: streamerApi });
 export const commandPrefix = process.env.COMMAND_PREFIX ?? "!";
 
 export const streamerUsers = [chatterId, streamerId];
-streamerUsers.forEach(async id => await addAdmin(id));
+streamerUsers.forEach(async id => await Promise.all([addAdmin(id), addInvuln(id)]));
 
 await import("./events");
 

src/items/grenade.ts

@@ -15,10 +15,10 @@ export default new Item(ITEMNAME, 'Grenade', 's',
   async (msg, user) => {
     const userObj = await getUserRecord(user);
     if (userObj.inventory[ITEMNAME]! < 1) { await sendMessage(`You don't have any grenades!`, msg.messageId); return; };
-    const targets = await redis.keys('vulnchatters:*');
+    const targets = await redis.keys(`user:*:vulnerable`);
     if (targets.length === 0) { await sendMessage('No vulnerable chatters to blow up', msg.messageId); return; };
     const selection = targets[Math.floor(Math.random() * targets.length)]!;
-    const target = await User.initUserId(selection.split(':')[1]!);
+    const target = await User.initUserId(selection.slice(5, -11));
 
     await getUserRecord(target!); // make sure the user record exist in the database
 

src/items/tnt.ts

@@ -15,7 +15,7 @@ export default new Item(ITEMNAME, 'TNT', 's',
   async (msg, user) => {
     const userObj = await getUserRecord(user);
     if (userObj.inventory[ITEMNAME]! < 1) { await sendMessage(`You don't have any TNTs!`, msg.messageId); return; };
-    const vulntargets = await redis.keys('vulnchatters:*');
+    const vulntargets = await redis.keys('user:*:vulnerable').then(a => a.map(b => b.slice(5, -11)));
     if (vulntargets.length === 0) { await sendMessage('No vulnerable chatters to blow up', msg.messageId); return; };
     const targets = getTNTTargets(vulntargets);
 
@@ -23,7 +23,7 @@ export default new Item(ITEMNAME, 'TNT', 's',
     await user.setLock();
 
     await Promise.all(targets.map(async targetid => {
-      const target = await User.initUserId(targetid.split(':')[1]!);
+      const target = await User.initUserId(targetid);
       await getUserRecord(target!); // make sure the user record exist in the database
       await Promise.all([
         timeout(target!, `You got hit by ${user.displayName}'s TNT!`, 60),

src/lib/admins.ts

@@ -1,14 +1,15 @@
 import { redis } from "bun";
 
 export async function getAdmins() {
-  return await redis.smembers('admins');
+  const data = await redis.keys('user:*:admin');
+  return data.map(a => a.slice(5, -6));
 };
 export async function isAdmin(userid: string) {
-  return await redis.sismember('admins', userid);
+  return await redis.exists(`user:${userid}:admin`);
 };
 export async function addAdmin(userid: string) {
-  return await redis.sadd('admins', userid);
+  return await redis.set(`user:${userid}:admin`, '1');
 };
 export async function removeAdmin(userid: string) {
-  return await redis.srem('admins', userid);
+  return await redis.del(`user:${userid}:admin`);
 };

src/lib/invuln.ts

@@ -0,0 +1,16 @@
+import { redis } from "bun";
+
+export async function getInvulns() {
+  const data = await redis.keys('user:*:invulnerable');
+  return data.map(a => a.slice(5, -13));
+};
+export async function isInvuln(userid: string) {
+  return await redis.exists(`user:${userid}:invulnerable`);
+};
+export async function addInvuln(userid: string) {
+  await redis.del(`user:${userid}:vulnerable`);
+  return await redis.set(`user:${userid}:invulnerable`, '1');
+};
+export async function removeInvuln(userid: string) {
+  return await redis.del(`user:${userid}:invulnerable`);
+};

src/lib/timeout.ts

@@ -1,9 +1,10 @@
-import { streamerApi, streamerId, streamerUsers } from "..";
+import { streamerApi, streamerId } from "..";
 import logger from "./logger";
 import { User } from "../user";
+import { isInvuln } from "./invuln";
 
-type SuccessfulTimeout = { status: true };
-type UnSuccessfulTimeout = { status: false; reason: 'banned' | 'unknown' | 'illegal' };
+type SuccessfulTimeout = { status: true; };
+type UnSuccessfulTimeout = { status: false; reason: 'banned' | 'unknown' | 'illegal'; };
 type TimeoutResult = SuccessfulTimeout | UnSuccessfulTimeout;
 
 /** Give a user a timeout/ban
@@ -11,7 +12,7 @@ type TimeoutResult = SuccessfulTimeout | UnSuccessfulTimeout;
  * @param reason - reason for timeout/ban
  * @param duration - duration of timeout. don't specifiy for ban */
 export const timeout = async (user: User, reason: string, duration?: number): Promise<TimeoutResult> => {
-  if (streamerUsers.includes(user.id)) return { status: false, reason: 'illegal' };
+  if (await isInvuln(user.id)) return { status: false, reason: 'illegal' }; // Don't timeout invulnerable chatters
 
   // Check if user already has a timeout
   const banStatus = await streamerApi.moderation.getBannedUsers(streamerId, { userId: user.id }).then(a => a.data);

src/user.ts

@@ -89,12 +89,12 @@ export class User {
     await redis.set(`user:${this.id}:itemlock`, '0');
   };
 
-  public async makeVulnerable(): Promise<void> {
-    await redis.set(`vulnchatters:${this.id}`, this.displayName);
-    await redis.expire(`vulnchatters:${this.id}`, Math.floor(EXPIRETIME / 2)); // Vulnerable chatter gets removed from the pool after 30 minutes
+  public async setVulnerable(): Promise<void> {
+    await redis.set(`user:${this.id}:vulnerable`, '1');
+    await redis.expire(`user:${this.id}:vulnerable`, Math.floor(EXPIRETIME / 2)); // Vulnerable chatter gets removed from the pool after 30 minutes
   };
 
-  public async makeInvulnerable(): Promise<void> {
-    await redis.del(`vulnchatters:${this.id}`);
+  public async clearVulnerable(): Promise<void> {
+    await redis.del(`user:${this.id}:vulnerable`);
   };
 };