1024++ (the clever 2048) FREE

TIRED OF CLONES just changing textures or making a joke of a really good game? But would like to see something that improves the very essence of it? 1024++ is for you.

A REALLY CONSEQUENT EXTENDED GAMEPLAY based on idea of Gabriele Cirulli's 2048 game and its antecedents. If you enjoyed that ones, you will like 1024++.
THIS IS NOT JUST A SIMPLE REMAKE (unlike the most clones that at most replace textures, make a joke or implement trivial enhancements). Beside the classic gameplay - according to further consequent considerations - 1024++ offers really new interesting ways. Unlike most clones 1024++ uses fast, native OpenGL graphic - working REALLY fine on EVERY 2.2+ Android versions.

Base:
On a board you can shift tiles containing a number. First, and after every move you get a tile with value of 1 at a random position. Colliding tiles with the same value will merge with the sum of values - so tiles will contain powers of 2.

Improvements in 1024++:
Free change of some parameters (and fine outtested presets), improved alternative endgames after getting the maximum level tile, several rules of merging tiles and an alternative control mode result really new interesting gameplay conditions.
Fast, native OpenGL implementation.

1. Maximum level tile and behaviour
In this game you can set the maximum level tile above or even below 1024. It's fine, but what if you reach it? 1024++ provides two logical options: either leave them merged unlimited or lock them - you can choose any.

2. Number of new tiles
1024++ lets you choose to get more than one new tile at every single step. Under appropriate conditions (mostly on >4 board sizes) this setting results an enjoyable, rapid gameplay.

3. Units movement
You can limit units move one step only (neighbour cells) or let them move until they collide with each other or the wall. First one results a slower, second one a faster gameplay, but both alone are interesting (and not speed is the only difference).

4. Merge rules
Consider, that there is not only one way to define merge rules. GC's 2048 rules implicitly assume that units move in the given direction sequentially, but a merged unit cannot merge again inside the same move. This behaviour differs from if you allow 'multimerge' (as a sequence of one-step-only moves). (For example: [1124] shifting left results [224x] with one-level merge (first '2' merged from '11' will not merge again with the original '2' in 3rd position), but results [8xxx] with multimerge (all new units coming from right will merge with the actual result).) Both methods alone are consequent, but they result different gameplays. 1024++ lets you choose any.
In addition, 1024++ provides the option repeating moves in a direction - as if a constant force would appear causing further moves and merges until the whole system stabilizes. (For example: [1111] shifting left results [22xx] - with classic rules and even with multimerge. But if you enable 'move again' from [1111] through [22xx] you will get finally [4xxx].)
Through combining these options 1024++ has the most sophisticated merge method among the clones. And this is not a self-serving thing, but results real enjoyable different gameplays.
Maybe this sounds difficult at first, but it's easy if you try: fine (simple, fast, but consequent) animations help understand the essence.

5. Control by rotation
Imagine that board can be rotated and move direction is controlled by 'gravity'. This is not just a spectacular graphical solution, but a really new game condition - your moves are limited: directions of two consecutive moves can be only perpendicular (like you would be forced to alternate horizontal and vertical moves in the classic control). (This gravity-driven method generated the idea of 'move again' merge.)

6. Block tiles
Placing unmoveable [0] tiles on board can dramatically change game conditions. 1024++ has several pre-defined boards (several sizes and patterns) causing new different gameplays.