BINGO! Or BitNGo

A few weeks ago, I attended a family bingo game. Not so much happened, we won a couple of prizes, but nothing else.
The thing is, I took notes and registered every number that came through before marking it, so I have a log of around 15 games. I thought about using that data to analyze it and do something with statistics. But things have taken a turn.
I decided to just simulate a game of bingo in a small program that I decided to call "BitNGo", because uhhhh bits and computers and bingo.
So yeah that's what I'm going to talk about in this post.

Warning: Madness Ahead

By the time I'm writing this, I have already written some lines of code, so I'll just try to explain how it works.
Spoiler: I am going to absolutely abuse the use of arrays.

And no, the "concept" that I first wrote on my whiteboard, doesn't necessarily have to make sense.

Creating the boards

First, I have to know how many boards I am going to have. As of right now, this needs to be defined through the console.
Then, we execute the create_boards() function. What this does, basically, is that it generates a random number for each BINGO letter, without repeating them; it repeats this process for each board that is going to be created.
But in the first position of the array, we assign the board id, which will help us identify said board later in case of a bingo.
The function looks like this: 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
function create_boards() //creates a number of boards depending on number_of_boards
{
    for(i = 0; i<number_of_boards; i++)
    {
        var used_numbers = []; //contains all the already used numbers in the board
        var id = i.toString(); //assigns an id to each board, starting from 0
        var board = [[],[],[],[],[]]; //a subarray for each bingo letter
        board.unshift(id); //puts the id before the letters on the board
        console.table(board);
        for(l = 1; l<6; l++)
        {
            for(n = 0; n<5; n++)
            {
                var newnum = random(((15 * l - 15) + 1), ((15 * l) + 1)); //creates a new number based on the letter
                while(used_numbers.includes(newnum))
                {
                    newnum = random(((15 * l - 15) + 1), (15 * l)); //if the  number already exists in the table, another one is created
                }
                used_numbers.push(newnum); //pushes the new number inside the used_numbers array
                board[l].push(newnum); //pushes the new number inside its letter array
            }
        }
        boards.push(board); //pushes the new board inside the boards array
    }
    for(i=0; i<boards.length; i++) //function that already puts a chip in the center of the board
    {
        boards[i][3][2] = "X";
    }
}

Playing

Then, we start playing.
We do this by simply playing a certain chip, this is random.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function play_chip() //normal function to pick a chip randomly
{
    var letter = random(1, 5); //gets the letter between BINGO
    var num = random((15 * letter - 15) + 1, 15 * letter); //gets a number from that letter range
    while(played_nums.includes(num))
    {
        num = random((15 * letter - 15) + 1, 15 * letter); //if the number already exists, picks another one. HERE THERE WILL BE A BUG
    }
    played_nums.push(num); //puts the new number in the played numbers array
    console.log(bingo_letters[letter-1] + num); 
    check_boards(letter, num); //marks "X" through the boards globally
    win_conditions[curr_wc](); //looks for bingos depending on the current win condition
}

Although it works fine for playing, sometimes, for testing purposes, I need a specific chip to be played. For this, I made a function to help me do exactly that:

1
2
3
4
5
6
7
function hack_chip(hackl, hackn) //get whatever chip i want, like hacking. It's just a devtool to test things out. haclk is for intended letter, hackn is for intended number
{
    played_nums.push(hackl);
    console.log(bingo_letters[hackl-1] + hackn);
    check_boards(hackl, hackn);
    win_conditions[curr_wc]();
}

Checking the boards

When a chip is played, we need to look for that number in each and every board that is currently playing.
So we do that by using a series of for loops, and by knowing the letter and the numbers that we need to look for:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
function check_boards(ltr, nm) //puts chips in played numbers
{
    for(i=0; i<boards.length; i++) //checks each board
    {
        if(boards[i][ltr].includes(nm)) //if it includes the number...
        {
            boards[i][ltr][boards[i][ltr].indexOf(nm)] = "X"; //it marks it as "X"
        }
    }
    console.table(boards[0]);
}

Win Conditions

As you may already know, there are a lot of game modes in a game of bingo.
  1. Normal Bingo: Horizontal, vertical, or diagonal lines.
  2. Full table: The whole 25 boxes checked.
  3. Four corners: Well, obviously, the four corners checked.
  4. Linked four corners: The outer ring of the board checked (16 boxes).
Each of these win conditions require a specific function, but the fundamentals are the same, we just loop through the boxes to find a whole line, or whatever condition we need.

The Normal Bingo function:

Although it is the first and most common win condition, I think it also is the most complex one to loop through. The thing is that with this one, you can have around 12 different bingo combinations, whereas with the other ones, you are very specific 
Full table, four corners, and linked four corners have all just one combination; and you can even optimize it in such a way where you only start looking for bingos once the minimum amount of chips to win has been played, so in full table for example, you would only start checking for bingos after the 24th chip, since it's the minimum amount of chips required to win in that specific game mode.

Now, I have to be clear about something, I don't think that the way this function works is very fast, or very resource optimizing, so even though I'll live it like that for now, I will definitely work on optimizing it in the future.

The function is this:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function wc_bingo() //normal bingo win condition
{
    for(i=0; i<boards.length; i++)
    {
        for(l=1; l<=5; l++)
        {
            if(boards[i][l].every(element => element === "X")) //bingo on one letter
            {
                console.log("Bingo on board " + i);
            }
            if(boards[i][1][l] === "X" && boards[i][2][l] === "X" && boards[i][3][l] === "X" && boards[i][4][l] === "X" && boards[i][5][l] === "X") //sideways bingo
            {
                console.log("sideways bingo on board " + i);
            }
        }
        //diagonal bingo. We don't check boards[i][3][2] because it is the center and already has an "X"
        if(boards[i][1][0] === "X" && boards[i][2][1] === "X" && boards[i][4][3] === "X" && boards[i][5][4] === "X")
        {
            console.log("Diagonal bingo on board " + i);
        }
        if(boards[i][5][4] === "X" && boards[i][4][3] === "X" && boards[i][2][1] === "X" && boards[i][1][0] === "X")
        {
            console.log("Diagonal bingo on board " + i);
        }
    }
}

As you can see, it's not very optimized, but it works for now.
I think that a good way of optimizing it would be by indexing all the boards that have a specific number somewhere, so we don't waste time looking for empty boards. But we will leave that for the future.

I don't want to make these posts too long, so I'll leave it here. I'm going to code and explain the remaining win conditions in later posts. I am also going to enjoy some free time by playing Stardew Valley, best game of all time.

Comments

Post a Comment

Popular posts from this blog

An Audioguide about the Geology of Ecuador

Image
Hello again. I've stayed a little AFK lately due to a big variety of reasons, such as my admission to college, a couple of life events, and some time away from home. But now I'm back. Today I'll write about a project I worked on during the first week of august. As you may have realized throughout this entire blog, all projects I write about are 100% mine; however, this project was not for me, but for my sister. She studies geology and had an assignment with creative freedom, so,  to finish her project on time,  I put Rubikraze temporarily aside (my current personal project). Like I said, my sister could choose any format for her assignment; the topic was geological formations of Ecuador. So, she asked me if I could make an HTML file with a map of Ecuador, and a list of audios (recorded by her of course) talking about different geological formations. As the good brother I am I said yes; the file in itself was not that complex or sophisticated, it was just an image of a map...
Read more

Active Projects as of Today

Hello again, I've been traveling quite a lot recently so I haven't had the opportunity to dedicate the necessary time and effort for writing  here and developing Rubikraze (the project I'm currently working on). This will be a small journal post just to talk about next goals and objectives in my projects and my occupations in general. Regarding Rubikraze, I'm still trying to find out whether the Color-Driven Summation (CDS) method I developed is useful to determine if a Rubik's Cube is solvable or not. My plan to use brute force by calculating the CDS of a bunch of cubes (both solvable and unsolvable) that I'll generate automatically using simple algorithms, and compare both kinds of CDS; therefore, if a solvable cube's CDS is the same as that of an unsolvable one, it would be evidence that my method doesn't work, so I would have to either completely scrap it or modify it. I'm quite optimistic that there has to be a numerical (yet not unique) harmony...
Read more

Explaining Color-Driven Summation

Image
One of my goals with Rubikraze is implementing a function that can solve any Rubik's cube thrown at it using the beginner's level method. In my previous post about Rubikraze I talked about how there are Rubik's cube configurations that are not possible to solve. For example, if you take a completely solved Rubik's cube, and rotate just one piece of it by manually taking it out and putting it back again, you'll end up with something like this: Assuming that's the only altered piece in the whole cube, we can consider that cube as impossible to solve. There's not a single pattern of movements that could possibly undo those changes without taking that piece out and putting it back again in the right orientation. With the example above it's pretty obvious that said cube is impossible to solve, but what if you took an unsolvable Rubik's cube, and mixed it? It'll still be unsolvable, and you know that because you knew it was unsolvable from the start, b...
Read more