diff --git a/src/components/RandomTrivia/RandomTriviaRound.vue b/src/components/RandomTrivia/RandomTriviaRound.vue
new file mode 100644
index 0000000..17f1ec9
--- /dev/null
+++ b/src/components/RandomTrivia/RandomTriviaRound.vue
@@ -0,0 +1,97 @@
+<template lang="pug">
+ItemGuess(
+  v-for='round in rounds'
+  :items='round.items'
+  :winnerIndex='round.winnerIndex'
+  :prize='prize'
+  :question='question'
+  :denomination='denomination'
+  :headerImage='headerImage'
+  :fragmentItemReveal='fragmentItemReveal'
+)
+</template>
+
+<script>
+import ItemGuess from '@/components/WhichIsWhich/ItemGuess.vue'
+
+export default {
+  name: 'RandomTriviaRound',
+  components: {
+    ItemGuess
+  },
+  props: {
+    wrongAnswers: Array,
+    rightAnswers: Array,
+    question: String,
+    answersLength: {
+      type: Number,
+      default: 3
+    },
+    prize: {
+      type: Number,
+      default: 1
+    },
+    denomination: {
+      default: '$',
+      type: String
+    },
+    headerImage: {
+      default: '/images/which_is_which_cover.jpg',
+      type: String
+    },
+    fragmentItemReveal: {
+      type: Boolean,
+      default: false
+    }
+  },
+  computed: {
+    rounds () {
+      const rounds = []
+      const shuffledRightAnswers = this.shuffle(this.rightAnswers)
+      const shuffledWrongAnswers = this.shuffle(this.wrongAnswers)
+      const roundTotal = Math.floor(
+        (this.rightAnswers.length + this.wrongAnswers.length) / this.answersLength
+      )
+
+      for (let i = 0; i < roundTotal; i++) {
+        const round = {
+          items: [],
+          winnerIndex: 0
+        }
+
+        round.winnerIndex = this.getRandomInt(this.answersLength)
+
+        for (let x = 0; x < this.answersLength; x++) {
+          if (x === round.winnerIndex) {
+            round.items.push(shuffledRightAnswers.pop())
+          } else {
+            round.items.push(shuffledWrongAnswers.pop())
+          }
+        }
+
+        rounds.push(round)
+      }
+
+      return rounds
+    }
+  },
+  methods: {
+    shuffle (array) {
+      let currentIndex = array.length; let randomIndex
+
+      while (currentIndex !== 0) {
+        randomIndex = Math.floor(Math.random() * currentIndex)
+        currentIndex--
+
+        [array[currentIndex], array[randomIndex]] = [
+          array[randomIndex], array[currentIndex]]
+      }
+
+      return array
+    },
+    getRandomInt (max) {
+      return Math.floor(Math.random() * max)
+    }
+  }
+}
+</script>
diff --git a/src/components/WhichIsWhich/ItemMultiSelect.vue b/src/components/WhichIsWhich/ItemMultiSelect.vue
new file mode 100644
index 0000000..fae96e2
--- /dev/null
+++ b/src/components/WhichIsWhich/ItemMultiSelect.vue
@@ -0,0 +1,201 @@
+<template lang='pug'>
+GameContentWithSidebar(:players='players')
+  template(v-slot:header)
+    slot(name='header')
+  template(v-slot:content)
+    slot(name='content')
+    ChooseItemModal(
+      v-if='!complete'
+      :items='items'
+      :fragmentItemReveal='fragmentItemReveal'
+      :question='question'
+      :headerImage='headerImage'
+      @guess='onGuess'
+    )
+    ActionButton(
+      v-else
+      label='Find Winners'
+      @clicked='findWinners'
+      accesskey='z'
+    )
+  template(v-slot:footer)
+    WinnerCard(
+      v-if='winners.length > 0'
+      :winners='winners'
+      :answerName='correctGuess'
+      :answerValue='denominate(items[0].value)'
+    )
+    LoserCard(
+      v-if='losers.length > 0'
+      :losers='losers'
+      :answerName='correctGuess'
+      :answerValue='denominate(items[0].value)'
+    )
+</template>
+
+<script>
+import { mapState, mapActions } from 'pinia'
+import { useGameStore } from '@/store'
+
+import GameContentWithSidebar from '@/components/base/GameContentWithSidebar.vue'
+import WinnerCard from '@/components/base/WinnerCard.vue'
+import LoserCard from '@/components/base/LoserCard.vue'
+
+import ChooseItemModal from '@/components/base/ChooseItemModal.vue'
+
+import ActionButton from '@/components/base/ActionButton.vue'
+
+export default {
+  name: 'ItemMultiSelect',
+  components: {
+    GameContentWithSidebar,
+    WinnerCard,
+    LoserCard,
+    ChooseItemModal,
+    ActionButton
+  },
+  props: {
+    items: Array,
+    winnerIndice: Array,
+    question: String,
+    prize: {
+      default: 1,
+      type: Number
+    },
+    totalSelections: {
+      default: 2,
+      type: Number
+    },
+    denomination: {
+      default: '$',
+      type: String
+    },
+    headerImage: {
+      default: '/images/which_is_which_cover.jpg',
+      type: String
+    },
+    fragmentItemReveal: {
+      default: false,
+      type: Boolean
+    }
+  },
+  data () {
+    return {
+      guesses: {},
+      complete: false,
+      winners: [],
+      losers: []
+    }
+  },
+  computed: {
+    currentPlayer () {
+      if (this.game.players.length > 0) {
+        return this.game.players[this.game.playerIndex].name
+      } else {
+        return ''
+      }
+    },
+    players () {
+      const players = []
+
+      for (const player in this.guesses) {
+        players.push({
+          name: player,
+          value: this.guesses[player].items.map(x => x.emoji).toString().replace(',', ' ')
+        })
+      }
+
+      return players
+    },
+    correctGuess () {
+      return this.winnerIndice.map(x => this.items[x].name).toString().replace(',', ' and ')
+    },
+    ...mapState(useGameStore, ['game'])
+  },
+  methods: {
+    onGuess (guess) {
+      if (typeof this.guesses[guess.playerName] === 'undefined') {
+        this.guesses[guess.playerName] = {
+          items: []
+        }
+      }
+      this.guesses[guess.playerName].items.push({
+        value: guess.value,
+        emoji: guess.emoji
+      })
+
+      if (this.guesses[guess.playerName].items.length >= this.totalSelections) {
+        this.nextPlayer()
+      }
+    },
+    nextPlayer () {
+      this.guess = ''
+      this.increasePlayerIndex()
+
+      if (this.game.playerIndex === this.game.playerButton) {
+        this.complete = true
+      }
+    },
+    findWinners () {
+      const winners = []
+
+      for (const player in this.guesses) {
+        const correct = []
+
+        this.guesses[player].items.forEach(item => {
+          if (this.winnerIndice.includes(item.value)) {
+            correct.push(item)
+          }
+        })
+
+        if (correct.length === this.totalSelections) {
+          winners.push(player)
+          this.increasePlayerScore(player, this.prize)
+        }
+      }
+
+      if (winners.length === 1) {
+        this.increasePlayerScore(winners[0], this.prize)
+
+        const audio = new Audio('/sounds/sorry_for_party_rocking.mp3')
+        audio.volume = 0.2
+
+        audio.play()
+
+        this.winners = winners
+      } else if (winners.length > 0) {
+        const audio = new Audio('/sounds/fanfare.mp3')
+        audio.volume = 0.2
+        audio.play()
+
+        this.winners = winners
+      } else {
+        const audio = new Audio('/sounds/loser_sound.mp3')
+        audio.volume = 0.2
+        audio.play()
+
+        this.losers = this.players.map(player => player.name)
+      }
+
+      this.increasePlayerButton()
+    },
+    denominate (value) {
+      return this.denomination + value
+    },
+    ...mapActions(useGameStore, ['increasePlayerScore',
+      'increasePlayerButton',
+      'increasePlayerIndex'])
+  }
+}
+</script>
+
+<style lang="scss">
+.actionButton {
+  @apply inline-flex justify-center px-6 py-3 border border-transparent leading-6 font-medium rounded-md text-white text-2xl uppercase bg-darkgray transition ease-in-out duration-150 my-2 hover:bg-slate-300 focus:outline-none focus:border-slate-300 active:bg-slate-300;
+}
+
+.reveal img {
+  margin: 0 !important;
+  @apply max-w-full;
+}
+</style>
diff --git a/src/components/base/GameContentWithSidebar.vue b/src/components/base/GameContentWithSidebar.vue
index 0f602d9..176245b 100644
--- a/src/components/base/GameContentWithSidebar.vue
+++ b/src/components/base/GameContentWithSidebar.vue
@@ -1,6 +1,6 @@
 <template lang='pug'>
 GameSlide(:dataState='dataState')
-  PlayersSidebar(:players='players')
+  PlayersSidebar(:players='playersToDisplay')
   GameContent
     template(v-slot:header)
       slot(name='header')
@@ -26,6 +26,10 @@ export default {
     GameContent
   },
   props: {
+    players: {
+      type: Array,
+      default: null
+    },
     dataState: {
       type: String,
       default: null
@@ -33,14 +37,18 @@ export default {
   },
   computed: {
     ...mapGetters(useGameStore, ['getPlayersByScore']),
-    players () {
-      const players = this.getPlayersByScore
+    playersToDisplay () {
+      if (this.players === null) {
+        const players = this.getPlayersByScore
 
-      players.forEach((player) => {
-        player.value = player.score
-      })
+        players.forEach((player) => {
+          player.value = player.score
+        })
 
-      return players
+        return players
+      } else {
+        return this.players
+      }
     }
   }
 }
diff --git a/tests/unit/RandomTrivia/RandomTriviaRound.spec.js b/tests/unit/RandomTrivia/RandomTriviaRound.spec.js
new file mode 100644
index 0000000..6557b05
--- /dev/null
+++ b/tests/unit/RandomTrivia/RandomTriviaRound.spec.js
@@ -0,0 +1,31 @@
+import { mount } from '@vue/test-utils'
+
+import { createTestingPinia } from '@pinia/testing'
+
+import RandomTriviaRound from '@/components/RandomTrivia/RandomTriviaRound.vue'
+
+describe('RandomTriviaRound Empty', () => {
+  let wrapper
+
+  beforeEach(() => {
+    wrapper = mount(RandomTriviaRound, {
+      props: {
+        wrongAnswers: [
+          { name: 'Merc' },
+          { name: 'Ferrari' }
+        ],
+        rightAnswers: [
+          { name: 'Red Bull' }
+        ],
+        question: 'Which is the fastest car?'
+      },
+      global: {
+        plugins: [createTestingPinia()]
+      }
+    })
+  })
+
+  it('renders with no players', async () => {
+    expect(wrapper.vm.rounds.length).toBe(1)
+  })
+})
diff --git a/tests/unit/SnackTrack/SnackTrackRound.spec.js b/tests/unit/SnackTrack/SnackTrackRound.spec.js
index ebfd4d5..47c57b3 100644
--- a/tests/unit/SnackTrack/SnackTrackRound.spec.js
+++ b/tests/unit/SnackTrack/SnackTrackRound.spec.js
@@ -153,3 +153,105 @@ describe('SnackTrackRound', () => {
     expect(loserCard.exists()).toBe(true)
   })
 })
+
+describe('SnackTrackRoundLowScore', () => {
+  let wrapper
+
+  beforeEach(() => {
+    wrapper = mount(SnackTrackRound, {
+      props: {
+        tracks: ['/sounds/1.mp3', '/sounds/2.mp3', 'sounds/3.mp3'],
+        items: ['Right', 'Wrong'],
+        winnerIndex: 0,
+        answer: 'Super Max by the Pit Stop Boys',
+        playerOrder: 'lowestScoreFirst'
+      },
+      global: {
+        plugins: [createTestingPinia({
+          initialState: {
+            'hack.party game board': {
+              game: {
+                players: [
+                  {
+                    index: 0,
+                    name: 'Morty',
+                    score: 1,
+                    team: undefined
+                  },
+                  {
+                    index: 1,
+                    name: 'noob noob',
+                    score: 2,
+                    team: undefined
+                  },
+                  {
+                    index: 2,
+                    name: 'Rick',
+                    score: 3,
+                    team: undefined
+                  }
+                ]
+              }
+            }
+          },
+          stubActions: false
+        })]
+      }
+    })
+  })
+  it('renders with players in reverse order by score', async () => {
+    const currentPlayer = await wrapper.vm.currentPlayer
+    expect(currentPlayer).toBe('Morty')
+  })
+})
+
+describe('SnackTrackRoundLowScore', () => {
+  let wrapper
+
+  beforeEach(() => {
+    wrapper = mount(SnackTrackRound, {
+      props: {
+        tracks: ['/sounds/1.mp3', '/sounds/2.mp3', 'sounds/3.mp3'],
+        items: ['Right', 'Wrong'],
+        winnerIndex: 0,
+        answer: 'Super Max by the Pit Stop Boys',
+        playerOrder: 'button'
+      },
+      global: {
+        plugins: [createTestingPinia({
+          initialState: {
+            'hack.party game board': {
+              game: {
+                players: [
+                  {
+                    index: 0,
+                    name: 'Morty',
+                    score: 1,
+                    team: undefined
+                  },
+                  {
+                    index: 1,
+                    name: 'noob noob',
+                    score: 2,
+                    team: undefined
+                  },
+                  {
+                    index: 2,
+                    name: 'Rick',
+                    score: 3,
+                    team: undefined
+                  }
+                ]
+              }
+            }
+          },
+          stubActions: false
+        })]
+      }
+    })
+  })
+  it('renders with players in button order', async () => {
+    const currentPlayer = await wrapper.vm.currentPlayer
+    expect(currentPlayer).toBe('Morty')
+  })
+})
diff --git a/tests/unit/WhichIsWhich/ItemMultiSelect.spec.js b/tests/unit/WhichIsWhich/ItemMultiSelect.spec.js
new file mode 100644
index 0000000..64eefc4
--- /dev/null
+++ b/tests/unit/WhichIsWhich/ItemMultiSelect.spec.js
@@ -0,0 +1,205 @@
+import { mount } from '@vue/test-utils'
+
+import { createTestingPinia } from '@pinia/testing'
+
+import { mocks } from '../../test-utils'
+
+import { useGameStore } from '@/store'
+
+import ItemMultiSelect from '@/components/WhichIsWhich/ItemMultiSelect.vue'
+
+describe('ItemMultiSelect Empty', () => {
+  let wrapper
+
+  beforeEach(() => {
+    wrapper = mount(ItemMultiSelect, {
+      props: {
+        items: ['Merc', 'Red Bull', 'Ferrari'],
+        winnerIndice: [1, 2],
+        question: 'Which are the fastest cars?'
+      },
+      global: {
+        plugins: [createTestingPinia()]
+      }
+    })
+  })
+
+  it('renders with no players', async () => {
+    expect(wrapper.vm.currentPlayer).toBe('')
+  })
+})
+
+describe('ItemMultiSelect', () => {
+  let wrapper
+  let store
+
+  beforeEach(() => {
+    wrapper = mount(ItemMultiSelect, {
+      props: {
+        items: ['Merc', 'Red Bull', 'Ferrari'],
+        winnerIndice: [1, 2],
+        question: 'Which are the fastest cars?'
+      },
+      global: {
+        plugins: [createTestingPinia({
+          stubActions: false,
+          initialState: {
+            'hack.party game board': {
+              game: {
+                players: [
+                  {
+                    index: 0,
+                    name: 'Morty',
+                    score: 0,
+                    team: undefined
+                  },
+                  {
+                    index: 1,
+                    name: 'noob noob',
+                    score: 0,
+                    team: undefined
+                  },
+                  {
+                    index: 2,
+                    name: 'Rick',
+                    score: 0,
+                    team: undefined
+                  }
+                ]
+              }
+            }
+          }
+        })]
+      }
+    })
+
+    store = useGameStore()
+  })
+
+  it('renders with players', async () => {
+    const currentPlayer = await wrapper.vm.currentPlayer
+    expect(currentPlayer).toBe('Morty')
+  })
+
+  it('stores a guess for the player', async () => {
+    const button = await wrapper.find('button')
+    await button.trigger('click')
+
+    expect(wrapper.vm.players.length).toBe(1)
+  })
+
+  it('presents the button to reveal answer after all players guess', async () => {
+    let buttons = await wrapper.findAll('button')
+
+    buttons.forEach((button) => {
+      expect(button.text()).not.toBe('Which is Which?')
+    })
+
+    await buttons[0].trigger('click')
+    await buttons[1].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[1].trigger('click')
+    await buttons[2].trigger('click')
+
+    buttons = await wrapper.findAll('button')
+
+    expect(buttons.length).toBe(1)
+    expect(buttons[0].text()).toBe('Find Winners')
+  })
+
+  it('presents WinnerCard after reveal button is clicked', async () => {
+    const spy = jest.spyOn(wrapper.vm, 'findWinners')
+
+    let buttons = await wrapper.findAll('button')
+
+    buttons.forEach((button) => {
+      expect(button.text()).not.toBe('Find Winner')
+    })
+
+    await buttons[1].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[1].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+
+    buttons = await wrapper.findAll('button')
+
+    expect(buttons.length).toBe(1)
+    expect(buttons[0].text()).toBe('Find Winners')
+
+    await buttons[0].trigger('click')
+
+    debugger
+
+    const winnerCard = await wrapper.findComponent({ name: 'WinnerCard' })
+
+    expect(spy).toHaveBeenCalled()
+    expect(mocks.Audio.play).toHaveBeenCalled()
+    expect(winnerCard.exists()).toBe(true)
+  })
+
+  it('presents LoserCard if no correct answer is guessed', async () => {
+    const spy = jest.spyOn(wrapper.vm, 'findWinners')
+
+    let buttons = await wrapper.findAll('button')
+
+    buttons.forEach((button) => {
+      expect(button.text()).not.toBe('Find Winners')
+    })
+
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[0].trigger('click')
+
+    buttons = await wrapper.findAll('button')
+
+    expect(buttons.length).toBe(1)
+    expect(buttons[0].text()).toBe('Find Winners')
+
+    await buttons[0].trigger('click')
+
+    const loserCard = await wrapper.findComponent({ name: 'LoserCard' })
+
+    expect(spy).toHaveBeenCalled()
+    expect(mocks.Audio.play).toHaveBeenCalled()
+    expect(loserCard.exists()).toBe(true)
+  })
+
+  it('presents WinnerCard and awards contrarian bonus if only one player guesses correctly', async () => {
+    const spy = jest.spyOn(wrapper.vm, 'findWinners')
+
+    let buttons = await wrapper.findAll('button')
+
+    buttons.forEach((button) => {
+      expect(button.text()).not.toBe('Which is Which?')
+    })
+
+    await buttons[1].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[0].trigger('click')
+    await buttons[2].trigger('click')
+    await buttons[0].trigger('click')
+
+    buttons = await wrapper.findAll('button')
+
+    expect(buttons.length).toBe(1)
+    expect(buttons[0].text()).toBe('Find Winners')
+
+    await buttons[0].trigger('click')
+
+    const winnerCard = await wrapper.findComponent({ name: 'WinnerCard' })
+
+    expect(spy).toHaveBeenCalled()
+    expect(mocks.Audio.play).toHaveBeenCalled()
+    expect(winnerCard.exists()).toBe(true)
+
+    expect(store.increasePlayerScore).nthCalledWith(1, 'Morty', 1)
+    expect(store.increasePlayerScore).nthCalledWith(2, 'Morty', 1)
+  })
+})
diff --git a/tests/unit/base/GameContentWithSidebar.spec.js b/tests/unit/base/GameContentWithSidebar.spec.js
index e216b24..185a3fa 100644
--- a/tests/unit/base/GameContentWithSidebar.spec.js
+++ b/tests/unit/base/GameContentWithSidebar.spec.js
@@ -29,6 +29,7 @@ describe('GameContentWithSidebar', () => {
     wrapper = mount(GameContentWithSidebar, {
       global: {
         plugins: [createTestingPinia({
+          stubActions: false,
           initialState: {
             'hack.party game board': {
               game: {
@@ -61,7 +62,7 @@ describe('GameContentWithSidebar', () => {
   })
 
   it('renders with players', async () => {
-    const players = await wrapper.vm.players
+    const players = await wrapper.vm.playersToDisplay
     expect(players).toStrictEqual([
       { name: 'Rick', value: 0, score: 0, index: 2, team: undefined },
       { name: 'noob noob', value: 0, score: 0, index: 1, team: undefined },