Connect with us


Constructing a Wheel of Fortune JavaScript Recreation for Zoom Calls – SitePoint

On this article, I describe how I developed a JavaScript “Wheel of Fortune” sport to make on-line conferences by way of Zoom a bit of extra enjoyable throughout the international pandemic.

The present pandemic has compelled many social actions to go digital. Our native Esperanto group, for instance, now meets on-line (as a substitute of in individual) for our month-to-month language examine meetups. And because the group’s organizer, I’ve needed to to re-think lots of our actions due to the coronavirus. Beforehand, I may add watching a movie, or perhaps a stroll by means of the park, to our mixture of actions in an effort to keep away from fatigue (fixed grammar drills don’t encourage repeat attendance).

Our new Wheel of Fortune sport was properly acquired. In fact, SitePoint is a tech weblog, so I’ll be presenting an summary of what went into constructing a rudimentary model of the sport to screenshare in our on-line conferences. I’ll focus on among the trade-offs I made alongside the way in which, in addition to spotlight some prospects for enchancment and issues I ought to have performed in another way in hindsight.

First Issues First

In case you’re from the USA, you’re in all probability already aware of Wheel of Fortune, because it’s the longest-running American sport present in historical past. (Even if you happen to’re not in the USA, you’re in all probability aware of some variant of the present, because it’s been tailored and aired in over 40 worldwide markets.) The sport is actually Hangman: contestants attempt to remedy a hidden phrase or phrase by guessing its letters. Prize quantities for every appropriate letter is set by spinning a big roulette-style wheel bearing greenback quantities — and the dreaded Bankrupt spots. A contestant spins the wheel, guesses a letter, and any situations of mentioned letter within the puzzle are revealed. Right guesses earn the contestant one other likelihood to spin and guess, whereas incorrect guesses advance sport play to the following contestant. The puzzle is solved when a contestant efficiently guesses the phrase or phrase. The principles and numerous components of the sport have been tweaked over time, and you’ll definitely adapt your personal model to the wants of your gamers.

For me, the primary order of enterprise was to resolve how we bodily (just about) would play the sport. I solely wanted the sport for one or two conferences, and I wasn’t prepared to take a position plenty of time constructing a full-fledged gaming platform, so constructing the app as an internet web page that I may load domestically and screenshare with others was nice. I might emcee the exercise and drive the gameplay with numerous keystrokes based mostly on what the gamers needed. I additionally determined to maintain rating utilizing pencil and paper —one thing I’d later remorse. However in the long run, plain ol’ JavaScript, a bit of little bit of canvas, and a handful of photos and sound impact recordsdata was all I wanted to construct the sport.

The Recreation Loop and Recreation State

Though I used to be envisioning this as a “fast and soiled” challenge reasonably than some brilliantly coded masterpiece following each recognized finest observe, my first thought was nonetheless to start out constructing a sport loop. Usually talking, gaming code is a state machine that maintains variables and such, representing the present state of the sport with some additional code bolted on to deal with consumer enter, handle/replace the state, and render the state with fairly graphics and sound results. Code referred to as the sport loop repeatedly executes, triggering the enter checks, state updates, and rendering. In case you’re going to construct a sport correctly, you’ll most certainly be following this sample. However I quickly realized I didn’t want fixed state monitoring/updating/rendering, and so I forwent the sport loop in favor of primary occasion dealing with.

When it comes to sustaining state, the code wanted to know the present puzzle, which letters have been guessed already, and which view to show (both the puzzle board or the spinning wheel). These can be globally out there to any callback logic. Any actions inside the sport can be triggered when dealing with a keypress.

Right here’s what the core code began to appear like:

(operate (appId) {
  const canvas = doc.getElementById(appId);
  const ctx = canvas.getContext('second');

  let puzzles = [];
  let currentPuzzle = -1;
  let guessedLetters = [];
  let isSpinning = false;

  window.addEventListener('keypress', (evt) => {

The Recreation Board and Puzzles

Wheel of Fortune’s sport board is actually a grid, with every cell in considered one of three states:

  • empty: empty cells aren’t used within the puzzle (inexperienced)
  • clean: the cell represents a hidden letter within the puzzle (white)
  • seen: the cell reveals a letter within the puzzle

One strategy to writing the sport can be to make use of an array representing the sport board, with every component as a cell in a type of states, and rendering that array might be completed a number of other ways. Right here’s one instance:

let puzzle = [...'########HELLO##WORLD########'];

const cols = 7;
const width = 30;
const top = 35;

puzzle.forEach((letter, index) => {
  let x = width * (index % cols);
  let y = top * Math.flooring(index / cols);

  ctx.fillStyle = (letter === '#') ? 'inexperienced' : 'white';
  ctx.fillRect(x, y, width, top);

  ctx.strokeStyle = 'black';
  ctx.strokeRect(x, y, width, top);

  if (guessedLetters.consists of(letter)) {
      ctx.fillStyle = 'black';
      ctx.fillText(letter, x + (width / 2), y + (top / 2));

This strategy iterates by means of every letter in a puzzle, calculating the beginning coordinates, drawing a rectangle for the present cell based mostly on the index and different particulars — such because the variety of columns in a row and the width and top of every cell. It checks the character and colours the cell accordingly, assuming # is used to indicate an empty cell and a letter denotes a clean. Guessed letters are then drawn on the cell to disclose them.

One other strategy can be to arrange a static picture of the board for every puzzle beforehand, which might be drawn to the canvas. This strategy can add a good quantity of effort to puzzle preparation, as you’ll must create extra photos, presumably decide the place of every letter to attract on the customized board, and encode all of that info into an information construction appropriate for rendering. The trade-off can be better-looking graphics and maybe higher letter positioning.

That is what a puzzle would possibly appear like following this second strategy:

let puzzle = {
  background: 'img/puzzle-01.png',
  letters: [
    {chr: 'H', x: 45,  y: 60},
    {chr: 'E', x: 75,  y: 60},
    {chr: 'L', x: 105, y: 60},
    {chr: 'L', x: 135, y: 60},
    {chr: 'O', x: 165, y: 60},
    {chr: 'W', x: 45,  y: 100},
    {chr: 'O', x: 75,  y: 100},
    {chr: 'R', x: 105, y: 100},
    {chr: 'L', x: 135, y: 100},
    {chr: 'D', x: 165, y: 100}

For the sake of effectivity, I’d suggest together with one other array to trace matching letters. With solely the guessedLetters array out there, you’d must scan the puzzle’s letters repeatedly for a number of matches. As a substitute, you’ll be able to arrange an array to trace the solved letters and simply copy the matching definitions to it when the participant makes their guess, like so:

const solvedLetters = [];

puzzle.letters.forEach((letter) => {
  if (letter.chr === evt.key) {

Rendering this puzzle then seems to be like this:

const imgPuzzle = new Picture();
imgPuzzle.onload = operate () {
  ctx.drawImage(this, 0, 0);
imgPuzzle.src = puzzle.background;

solvedLetters.forEach((letter) => {
  ctx.fillText(letter.chr, letter.x, letter.y);

A potential game board rendered using the alternative approach

For the file, I took the second strategy when writing my sport. However the essential takeaway right here is that there are sometimes a number of options to the identical drawback. Every answer comes with its personal execs and cons, and deciding on a selected answer will inevitably have an effect on the design of your program.

Spinning the Wheel

At first blush, spinning the wheel gave the impression to be difficult: render a circle of coloured segments with prize quantities, animate it spinning, and cease the animation on a random prize quantity. However a bit of little bit of artistic pondering made this the simplest process in all the challenge.

No matter your strategy to encoding puzzles and rendering the sport board, the wheel might be one thing you’ll wish to use a graphic for. It’s a lot simpler to rotate a picture than draw (and animate) a segmented circle with textual content; utilizing a picture does away with a lot of the complexity up entrance. Then, spinning the wheel turns into a matter of calculating a random quantity higher than 360 and repeatedly rotating the picture that many levels:

const maxPos = 360 + Math.flooring(Math.random() * 360);
for (let i = 1; i < maxPos; i++) {
  setTimeout(() => {;
    ctx.translate(640, 640);
    ctx.rotate(i * 0.01745); 
    ctx.translate(-640, -640);
    ctx.drawImage(imgWheel, 0, 0);
  }, i * 10);

I created a crude animation impact through the use of setTimeout to schedule rotations, with every rotation scheduled additional and additional into the longer term. Within the code above, the primary 1 diploma rotation is scheduled to be rendered after 10 milliseconds, the second is rendered after 20 milliseconds, and so on. The online impact is a rotating wheel at roughly one rotation each 360 milliseconds. And guaranteeing the preliminary random quantity is larger than 360 ensures I animate at the very least one full rotation.

A short word value mentioning is that you need to be at liberty to mess around with the “magic values” offered to set/reset the middle level round which the canvas is rotated. Relying on the scale of your picture, and whether or not you need the all the picture or simply the highest portion of the wheel to be seen, the precise midpoint might not produce what you take into consideration. It’s okay to tweak the values till you obtain a passable consequence. The identical goes for the timeout multiplier, which you’ll modify to vary the animation velocity of the rotation.

Going Bankrupt

I believe all of us expertise a little bit of schadenfreude when a participant’s spin lands on Bankrupt. It’s enjoyable to look at a grasping contestant spin the wheel to rack up just a few extra letters when it’s apparent they already know the puzzle’s answer — solely to lose all of it. And there’s the enjoyable chapter sound impact, too! No sport of Wheel of Fortune can be full with out it.

For this, I used the Audio object, which provides us the power to play sounds in JavaScript:

operate playSound(sfx) {
  sfx.currentTime = 0;;

const sfxBankrupt = new Audio('sfx/bankrupt.mp3');


However what triggers the sound impact?

One answer can be to press a button to set off the impact, since I’d be controlling the gameplay already, however it was extra fascinating for the sport to routinely play the sound. Since Bankrupt wedges are the one black wedges on the wheel, it’s attainable to know whether or not the wheel stops on Bankrupt just by wanting on the pixel colour:

const maxPos = 360 + Math.flooring(Math.random() * 360);
for (let i = 1; i < maxPos; i++) {
  setTimeout(() => {;
    ctx.translate(640, 640);
    ctx.rotate(i * 0.01745); 
    ctx.translate(-640, -640);
    ctx.drawImage(imgWheel, 0, 0);

    if (i === maxPos - 1) {
      const colour = ctx.getImageData(640, 12, 1, 1).information;
      if (colour[0] === 0 && colour[1] === 0 && colour[2] === 0) {
  }, i * 10);

I solely targeted on bankruptcies in my code, however this strategy might be expanded to find out prize quantities as properly. Though a number of quantities share the identical wedge colour — for instance $600, $700, and $800 all seem on purple wedges — you would use barely completely different shades to distinguish the quantities: rgb(255, 50, 50), rgb(255, 51, 50), and rgb(255, 50, 51) are indistinguishable to human eyes however are simply recognized by the applying. In hindsight, that is one thing I ought to have pursued additional. I discovered it mentally taxing to manually hold rating whereas urgent keys and operating the sport, and the additional effort to automate rating conserving would undoubtedly have been value it.

The differences between these shades of red are indistinguishable to the human eye


In case you’re curious, you’ll find my code on GitHub. It isn’t the epitome and finest practices, and there’s plenty of bugs (similar to plenty of real-world code operating in manufacturing environments!) however it served its function. However in the end the aim of this text was to encourage you and invite you to suppose critically about your personal trade-off decisions.

In case you have been constructing the same sport, what trade-offs would you make? What options would you deem essential? Maybe you’d need correct animations, rating conserving, or maybe you’d even use internet sockets so contestants may play collectively in their very own browsers reasonably than by way of screensharing the emcee’s display.

Wanting past this specific instance, what decisions are you confronted with in your each day work? How do you stability enterprise priorities, correct coding practices, and tech debt? When does the need to make issues good grow to be an impediment to transport a product? Let me know on Twitter.

Click to comment

Leave a Reply

Your email address will not be published. Required fields are marked *