Newer Win Conditions

 In my last post I went through the process of explaining the basic functioning of the small bingo simulator which I'm calling BitNGo. Now, I'm going to explain how each win condition works.

This probably won't be a long post.

Full Table

This probably was the easiest one to code. We just make a for loop that checks if every letter of the board has the complete 5 chips. If every letter is indeed full, a bingo is announced. For this win condition, we applied the very useful array.prototype.every() function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function wc_full_table()
{
    if(played_nums.length >= 24)
    {
        for(i=0; i<boards.length; i++)
        {
            if(boards[i][1].every(element => element === "X") && boards[i][2].every(element => element === "X") && boards[i][3].every(element => element === "X") && boards[i][4].every(element => element === "X") && boards[i][5].every(element => element === "X"))
            {
                console.log("Full table on board " + i);
            }
        }
    }
}

We also added an if() condition that checks that at least 24 chips have been played, since it would be impossible for a board to be full if the minimum amount of chips haven't been played. Although not very elegant, I did this for optimization purposes.

Four Corners

Another piece of cake to code. We just have to check 4 boxes on this one. This one is also very resource friendly.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function wc_four_corners()
{
    if(played_nums.length >= 4)
    {
        for(i=0; i<boards.length; i++)
        {
            if(boards[i][1][0] === "X" && boards[i][1][4] === "X" && boards[i][5][0] === "X" && boards[i][5][4] === "X")
            {
                console.log("Four corners on board " + i);
            }
        }
    }
}

There's nothing much to that one as you can see. Pretty simple.

Linked Four Corners

Finally, the linked four corners is just a frame around the board, covering the 16 outer boxes. This one is a little tricky because it just looks terrible to code. But whatever.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function wc_linked_four_corners()
{
    if(played_nums.length >= 16)
    {
        for(i=0; i<boards.length; i++)
        {
            if(boards[i][1].every(element => element === "X") && boards[i][5].every(element => element === "X") && boards[i][2][0] === "X" && boards[i][2][4] === "X" && boards[i][3][0] === "X" && boards[i][3][4] === "X" && boards[i][4][0] === "X" && boards[i][4][4] === "X")
            {
                console.log("Linked four corners on board " + i);
            }
        }
    }
}

As you can see, we check if the letter B and O are complete, and then we check the check the last 6 boxes separately. This illustration explains it a little better (the dark rectangles being the letters B and O, and the green circles being the 6 remaining letters).


As you can see, it is not a very elegant solution, but for now it will do just fine.




"Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away."

-Antoine de Saint-Exupéry


Before I finish this post, I would like to make one thing clear: this are all probably terrible solutions for the problems that I'm trying to solve. See, even though it works, it is probably very slow, and the computing time for every action (like looking up numbers on boards or checking for bingos), might even increase exponentially if we have multiple boards in game.
What I'm trying to say is, in coding, almost never your first solution will be the best; so I will be changing these functions constantly, with the main goal of saving computer power.
So don't see these lines of code as definitive solutions, but rather as a time machine where you'll be able to see the evolution of my personal problem solving.

For the next post, I will try to optimize the chip lookup time by a wide margin. Thanks for reading!

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