Inspiration

After participating in intense, rapid-prototyping game jams, I wanted to tackle something elegantly simple but highly polished. The core mechanic of 2048 has always fascinated me because it relies on pure, exponential math disguised as an accessible, casual puzzle. I created Merge Double Up! to focus deeply on "game feel"—snappy tile animations, satisfying tactile feedback, and a frictionless mobile Ib experience.

What it does

Merge Double Up! is a tile-matching puzzle game where the objective is to slide numbered tiles on a grid to combine them and create tiles with higher values.

Players swipe (or use arrow keys) to move all tiles in a specific direction.
When two tiles with the same number touch, they merge into one tile carrying double the value.
The game ends when the board fills up and no more legal moves (or merges) are possible.
The ultimate goal is to strategize moves, keep the board from locking up, and chase the highest score possible.

How I built it

I developed the game using the Phaser HTML5 framework, focusing on a clean architecture that strictly separates the visual UI from the underlying mathematical state. The core grid is represented as a 4 x 4 grids. When a player inputs a swipe, the board undergoes a directional transformation

Challenges I ran into

The Recursive Merge Bug: The biggest logic hurdle was ensuring tiles only merged once per turn. In early builds, sliding a row like [2, 2, 4, 0] to the right would evaluate recursively and instantly merge into [0, 0, 0, 8] instead of the correct state of [0, 0, 4, 4]. I solved this by decoupling the "movement phase" from the "merge phase" and implementing an canUpgrade boolean flag to lock a tile after its first combination.
Animation Synchronization: The underlying matrix $M$ updates instantaneously, but the visual tiles need to physically travel across the screen. Managing these animations using Phaser's TIen system while ensuring the player couldn't trigger another move mid-animation required a tightly controlled state machine and careful handling of onComplete callbacks.

Accomplishments that I're proud of

Responsive Game Feel: The input buffering and tIen timings make the game feel incredibly snappy and satisfying, turning a simple math puzzle into an addictive experience.

What I learned

Building Merge Double Up! was a masterclass in architectural discipline. It taught me the absolute necessity of keeping logical state entirely independent from rendering logic. I also gained a much deeper understanding of the Phaser event lifecycle, tIen management, and how to effectively manage memory in HTML5 canvas environments.

What's next for Double Up!

I have several features planned to expand the game's replayability:

Global Leaderboards: Implementing a backend database to track high scores globally.
PoIr-Ups: Adding limited-use abilities like an "Undo Move" or a "Hammer" to smash an unwanted tile.
New Grid Modes: Experimenting with 5 x 5 grids, hexagonal layouts, or time-attack modes to challenge veteran players.