

JS1k demo details: 2048 - mxfh
http://js1k.com/2014-dragons/details/1813

======
EmielMols
Detection of the game-over state seems buggy: I had moves left on a full board
then got the 'GG' modal.

------
sphericalgames
I got 4 x 16s first row, 4 x 8s second row, 4 x 4s 3rd row and 4 x 2s on last
row just by pressing up.

Then it says game over.

This is wrong because I should be able to shift left / right and merge those
same numbers that are matching in a row.

It seems it is game over if all 16 cells are filled in regardless if a move is
still possible.

~~~
TobbenTM
No, the problem is the it think it's over when you do a move and no numbers
can merge. The board may be full, and you may have possibilities but you did a
move where no numbers could merge.

Also; this version does not implement the random spawn (10% chance to spawn a
4 instead of a 2)

Still impressive for it's size though.

------
rwinn
My original submission is here:
[https://news.ycombinator.com/item?id=7406605](https://news.ycombinator.com/item?id=7406605)

Got nuked for some reason by HN's algorithm dropping it from nr 4 to the
second page :(

~~~
agf
More comments than votes?

~~~
rwinn
Something like that. I think it had more comments than votes all the way up,
it was when it hit 40 comments it got dropped.

Crappy algo, I would think that lots of comments indicates that people find it
interesting... Next time I won't reply to peoples comments :/

------
brandonhsiao
Wow, compressing the code further by doing find-replaces _on the code_. That
is hardcore.

~~~
userbinator
I still see a lot of redundancy there (e.g. "class", "Math", "font"). Maybe a
real LZ packer could shrink it even more...

------
evan_
I wrote a <1k version of Threes, a similar game, for js1k:

[http://js1k.com/2014-dragons/demo/1667](http://js1k.com/2014-dragons/demo/1667)

~~~
necubi
Nice work, but unfortunately it doesn't seem to implement the card draw
algorithm correctly, which leads to unplayable games pretty quickly (the card
draw algorithm must pick the same number of 1s and 2s over a short time
horizon for the game to be playable).

The actual algorithm used by Threes is as follows:

1\. At start, shuffle a deck containing 4 each of ones, twos, and threes.

2\. For each round, roll a 21-sided die. If it's a one and the largest value
on the board V is >= 48, choose a tile that is randomly chosen from the range
3 to V/8 inclusive. Otherwise, take the next tile off the stack.

3\. If the stack is empty, refill it as above.

Here's a Scala implementation of this logic:
[https://github.com/mwylde/Threes.scala/blob/master/src/main/...](https://github.com/mwylde/Threes.scala/blob/master/src/main/scala/com/micahw/threes/Game.scala#L176).

~~~
evan_
Yeah, I know- it's just drawing a random number. I didn't have space to
improve on that.

------
shocks
Good, but it's not the same game. Any move places a two. The original places a
two or a four, and only if you can make a combo during that move.

Good code though! :)

------
jasonlotito
So, it places another block even if you don't move blocks, which vastly
simplifies the game.

~~~
nullc
I noticed this too... it means you don't have to risk getting pieces on the
wrong side of your pile just to keep moving things along.

