feat(Jackbox): add The Jackbox Survey Scramble (#9338)

* feat(bigsurvery): add game details

* feat: support additional player name location

* chore: format code for new style

* feat: update logo

* refactor: remove debug warn log

Author: theusaf

websites/J/Jackbox/games/Non-Pack/bigsurvey.ts

@@ -0,0 +1,113 @@
+import type { GameCallbackParams } from '../../types.js'
+import { Assets } from 'premid'
+
+export const name = 'The Jackbox Survey Scramble'
+export const logo = 'https://i.imgur.com/Uq3wXdV.png'
+
+function getGoalString(goal: string) {
+  switch (goal) {
+    case 'High':
+      return 'most popular'
+    case 'Low':
+      return 'least popular'
+  }
+}
+
+export async function getPresenceData({
+  playerState,
+}: GameCallbackParams): Promise<PresenceData> {
+  switch (playerState.kind) {
+    case 'lobby': {
+      if (playerState.textEntry) {
+        const input = document.querySelector<HTMLInputElement>('#input')
+        let detailsText = playerState.textEntry.prompt
+        if (input?.value)
+          detailsText += ` - "${input.value}"`
+
+        return {
+          state: 'Waiting in lobby',
+          smallImageKey: Assets.Question,
+          smallImageText: detailsText,
+        }
+      }
+      return { state: 'Waiting in lobby' }
+    }
+    case 'postGame': {
+      return { state: 'Viewing the results' }
+    }
+    case 'choices': {
+      switch (playerState.responseKey) {
+        case 'objectGuess:3': {
+          const prompt = playerState.prompt as string
+          if (prompt?.includes('MORE'))
+            return { state: `Dare: Guessing ${prompt}` }
+
+          return { state: 'High-Low: Guessing the more popular answer' }
+        }
+        case 'voteResponse:3': {
+          return { state: 'Voting for a topic' }
+        }
+      }
+      return { state: 'Making a choice' }
+    }
+    case 'teamChoice': {
+      return { state: 'Choosing their team' }
+    }
+    case 'bounce': {
+      if (playerState.instructions?.includes('Try'))
+        return { state: 'Bounce: Practicing answers' }
+
+      return {
+        state: 'Bounce: Submitting answers',
+      }
+    }
+    case 'ticTacToe': {
+      return {
+        state: `Tic Tac Toe: ${
+          playerState.instructions?.includes('next') ? 'Suggesting' : 'Guessing'
+        } prompts`,
+        smallImageKey: Assets.Question,
+        smallImageText: document.querySelector('.prompt'),
+      }
+    }
+    case 'speed': {
+      return {
+        state: 'Speed: Guessing answers',
+        smallImageKey: Assets.Question,
+        smallImageText: document.querySelector('.prompt'),
+      }
+    }
+    case 'highLow': {
+      return {
+        state: `High-Low: Guessing the ${getGoalString(
+          playerState.goal!,
+        )} answer`,
+        smallImageKey: Assets.Question,
+        smallImageText: document.querySelector('.prompt'),
+      }
+    }
+    case 'horseRace': {
+      return {
+        state: `Dash: Guessing the ${getGoalString(playerState.goal!)} answer`,
+        smallImageKey: Assets.Question,
+        smallImageText: `Between '${playerState.options?.join(', ')}`,
+      }
+    }
+    case 'dare': {
+      return { state: 'Dare: Choosing opponent\'s difficulty' }
+    }
+    case 'dareText': {
+      if (playerState.successfulGuess)
+        return { state: 'Dare: Guessing rank of submission' }
+
+      return {
+        state: 'Dare: Providing guess',
+        smallImageKey: Assets.Question,
+        smallImageText: document.querySelector('.prompt'),
+      }
+    }
+    default: {
+      return { state: 'Waiting' }
+    }
+  }
+}

websites/J/Jackbox/games/index.ts

@@ -1,4 +1,5 @@
 import type { Game } from '../types.js'
+import * as bigsurvey from './Non-Pack/bigsurvey.js'
 import * as drawful2 from './Party Pack 1/drawful2.js'
 import * as drawful2international from './Party Pack 1/drawful2international.js'
 import * as drawful from './Party Pack 1/drawful.js'
@@ -109,4 +110,5 @@ export default {
   'risky-text': riskytext,
   'time-trivia': timetrivia,
   'us-them': usthem,
+  bigsurvey,
 } as Record<string, Game>

websites/J/Jackbox/presence.ts

@@ -15,14 +15,14 @@ let gamePlayerState: GamePlayerState = {
 let gamePlayerInfoState: GameInfoState = {
   name: null as unknown as string,
 }
-let game: Game
+let game: Game | undefined
 let browsingTimestamp = Math.round(Date.now() / 1000)
 let gametag: string
 
 if (document.location.hostname === 'jackbox.tv') {
   setInterval(async () => {
     const playerStateLogs = await presence.getLogs(
-      /recv <- .*?("key": "(bc:customer|player|info):[a-z0-9-]+",)/s,
+      /recv <- .*?("key": "(bc:customer|player|info):[a-z0-9-]+",|"opcode":\s*"client\/welcome")/s,
     )
     if (playerStateLogs.length > 0) {
       let updatedMainState = false
@@ -48,18 +48,26 @@ if (document.location.hostname === 'jackbox.tv') {
         switch (true) {
           case /recv <- .*?"entities": \{\n/s.test(latestLog): {
             if (!updatedMainState) {
-              gamePlayerState = parsedLog.result.entities[
-                latestLog.match(
-                  /"key": "((?:bc:customer|player):[a-z0-9-]+)",/,
-                )?.[1] ?? ''
-              ]?.[1].val ?? parsedLog.result.val
-              updatedMainState = true
+              const entityKey = latestLog.match(
+                /"key": "((?:bc:customer|player):[a-z0-9-]+)",/,
+              )?.[1]
+              if (entityKey) {
+                gamePlayerState
+              = parsedLog.result.entities[
+                    entityKey
+                  ]?.[1].val ?? parsedLog.result.val
+                updatedMainState = true
+              }
             }
             if (!updatedInfoState) {
-              gamePlayerInfoState = parsedLog.result.entities[
-                latestLog.match(/"key": "(info:\d+)",/)?.[1] ?? ''
-              ]?.[1].val ?? parsedLog.result
-              updatedInfoState = true
+              const entityKey = latestLog.match(/"key": "(info:\d+)",/)?.[1]
+              if (entityKey) {
+                gamePlayerInfoState
+  = parsedLog.result.entities[
+                    entityKey
+                  ]?.[1].val ?? parsedLog.result
+                updatedInfoState = true
+              }
             }
             break
           }
@@ -77,23 +85,30 @@ if (document.location.hostname === 'jackbox.tv') {
               gamePlayerInfoState = parsedLog.result.val
               updatedInfoState = true
             }
+            break
+          }
+          case /recv <- .*?"opcode": "client\/welcome"/s.test(latestLog): {
+            if (!updatedInfoState) {
+              gamePlayerInfoState = parsedLog.result
+              updatedInfoState = true
+            }
+            break
           }
         }
       }
     }
     if (!game) {
-      interface JackboxStorageLetiable {
-        tag: string
-      }
-      const { tag } = await presence.getPageletiable<JackboxStorageLetiable>(
-        'tv"]["storage',
-      )
-      gametag = tag
-      if (tag && tag !== '@connect') {
-        game = games[tag]!
-        browsingTimestamp = Math.round(Date.now() / 1000)
-        if (!game)
-          game = games.unknown!
+      const { 'tv.storage.tag': tag } = await presence.getPageVariable<
+        Record<string, string>
+      >('tv.storage.tag')
+      if (tag) {
+        gametag = tag
+        if (tag !== '@connect') {
+          game = games[tag]
+          browsingTimestamp = Math.round(Date.now() / 1000)
+          if (!game)
+            game = games.unknown
+        }
       }
     }
   }, 1000)
@@ -219,7 +234,7 @@ presence.on('UpdateData', async () => {
           else {
             presenceData.details = 'Browsing'
             presenceData.state = document.title.match(
-              /^(.*?)( - Jackbox Games)?$/,
+              /^.*?( - Jackbox Games)?$/,
             )?.[1]
           }
         }

websites/J/Jackbox/types.ts

@@ -26,6 +26,12 @@ export interface GamePlayerState {
   placeholder?: string
   choiceType?: string
   classes?: string[]
+  instructions?: string
+  goal?: string
+  options?: string[]
+  textEntry?: {
+    prompt: string
+  }
   [x: string]: unknown
 }