2048 in 3D

I've beaten 2048 (i.e., developed a general algorithm that consistently wins).

Do you end up with game boards with more than one 128 tile, 64 tile, etc.?

The game has a natural tendency to spawn multiple high-value tiles, and preventing it from doing that is the nut of the game.

Pick the bottom row and make that row your "accumulator". Pick a bottom corner; this bottom corner will store your largest value. Now, keep your bottom row sorted from low value tile to high value tile at all costs:

    4 8 16 128

Let's say the bottom two rows look like this:

    2 8  4  2
    4 8 16 128

You drop the 8 down:

    2     4  2
    4 16 16 128

Now, merge left or right? To the right of course, you want to keep that bottom row sorted:

    2     4  2
       4 32 128

Now drop down (or continue merging to the right until you can drop a tile down into the empty space in the bottom row):

      8  4  2
    2 4 32 128

This "locks" the bottom row into position, allowing you to freely move the upper three rows left and right without disturbing the ordering of the bottom row. Row-locking is more important than clearing the board.

Focus only on the bottom two rows for most of the game (until/unless most of the board fills up). Accumulate values in the bottom row, and build matching values in the row above it.

What if the game plays dirty and you end up with:

    4 32 128 2

Reverse the ordering of your bottom row. You now want to gradually shift that "128" tile to the left, so build on the "4" and "32" tiles until you get something like:

    64 64 128 4

Now shift left and left again:

    256 4

And drop new tiles into the bottom row:

    256 4 2 2

And your bottom row is ordered once again.

What if a higher value tile drops into the bottom row out of order?

    32 4 16 128

Ignore it. Build those "4" and "16" tiles:

    32 32 32 128

And then merge right and right again:

      32 64 128

And drop a new tile into the empty position:

    2 32 64 128

This is the situation you want to avoid:

    16 64 128 64

This is a natural result of the rules of the game, and this is where it becomes difficult for the player to win, especially when those values start to look more like:

    32 128 512 128

Now you suddenly have to do a lot of work in just three rows of space to double one of those 128 values.

This approach makes the game pretty easy.

This version is actually much easier than the original.

"128" or even "64" is more my cup of tea :)

Did you know that using only three directions drastically increases the chance of you winning, because it alters the way numbers are being stacked?

Another option would be to have them "jump".

Up if it moves to an adjacent plane, down if it goes from one extreme to the other.

Clearly that's next.

Don't even need JS. Just use three CSS transforms.

Rubik's cube 2048?

It's not like 2048 is taking over the front page. People iterate on an idea that's fun for them, where's the harm in that? What have you done today that you'd like to show us?

Watching the stories about these games float right to the top of HN has inspired me to make Flappy 2048 for some easy pageviews, so there's that.

It's good because it has slightly more sophisticated gameplay than flappy bird and is still straight forward to implement and therefor iterate on.

It's quite fun to see a game literally evolve.

Completely agree.

Agreed. Though I've only played the 3D version twice, my win rate is 50% and i only see it increasing. The 2D version is a little more challenging.. I think I win roughly 25% of the time as luck plays a bigger role (at least with my strategy).

Plus you don't seem to be able to lose (or at least for me). So it's really easy!

Yet it can't be solved by mashing and requires some thought.

It is significantly easier if you have the patience to reason about it for a bit longer.

It's not even that subtle, there's a lot more room and the extra dimension helps a lot in unscrewing yourself after filling the whole board.

Just built 0x800; find it here: http://pages.cs.wisc.edu/~sohn/0x800/.

Source: https://github.com/jaredsohn/0x800.

(I was already working on a binary derivative at the time, but figuring out the font sizes is a little tedious.)

Just add an option to undo moves. :)

change the colors, black and blue look the same to me (using flux here, it's 23:09...)

And then a multiplayer, followed by a browser benchmark!

...i feel really stupid. I understand the objective of the game and the basic mechanics, but how do I know what the Q and E button do? I seems like some type of jumping occurs on the row.