Inspiration
Traditional mobile tower defense games suffer from a fundamental design flaw: once a player establishes an optimal layout, the game plays itself, and the player becomes a passive spectator. We wanted to completely break this passive pattern.
Our inspiration came from asking a single question: What if the map itself was the player’s primary active weapon? We set out to create a high-agency tactical experience where safety is entirely temporary. By combining dynamic grid manipulation with a market-first physics mechanic—where sliding land masses physically pushes, splits, and smashes enemy pathfinding—we transformed a static puzzle genre into a high-speed, high-skill spatial battleground. We paired this with a premium, flat-tactile art direction inspired by high-end modern physical board games to ensure perfect visual clarity during intense gameplay.
How We Built It
The project was engineered from the ground up as a high-performance, lightweight mobile application built in the Unity Engine.
- The Architecture: The entire game space is managed by a multi-dimensional $8 \times 8$ grid array database that tracks coordinate states (Empty vs. Occupied).
- Dynamic Pathfinding: We integrated a custom, hyper-optimized variation of the $A^*$ pathfinding algorithm. Whenever a player drops, rotates, or slides a terrain tile, the engine immediately recalculates the shortest pathing mesh across all active enemy agents simultaneously. To eliminate input lag on mobile touchscreens, we enforced a strict processing constraint:
$$T_{recalc} \le 5\text{ms}$$
- Graphics Pipeline: Deployed via Unity's Universal Render Pipeline (URP), we wrote custom Unlit Flat Material Shaders for all assets. By completely removing real-time shadow rendering passes, lighting calculation draw calls, and ambient occlusion overhead, we achieved an incredibly small compiled file size and a locked 60fps frame rate on low-spec target mobile processors.
Challenges We Faced
Our greatest technical hurdle was engineering our proprietary Active Displacement Engine without crashing the pathfinding loops. In early builds, sliding a solid tile directly over a coordinate coordinate occupied by multiple enemy units caused collision conflicts, clipping bugs, and fatal null pointer exceptions. We resolved this by implementing a deterministic displacement algorithm: when a tile slides into an occupied grid index, it casts a directional velocity vector and forcefully moves the enemy entities to the nearest valid, open adjacent coordinate cell.
Our secondary challenge was balancing the Material Decay Rate to keep players engaged without causing immediate frustration. We modeled the structural degradation mathematically:
$$I_{tile}(t) = I_{initial} - (\delta_{env} \cdot t) - \sum D_{enemy}$$
Where $I_{tile}(t)$ represents current structural integrity, $\delta_{env}$ is the baseline environmental corrosion rate over time, and $D_{enemy}$ is active enemy attack damage. Through extensive greybox prototyping, we tuned these variables to establish a highly balanced loop that demands a consistent player input target of $\ge 15$ Actions Per Minute (APM).
What We Learned
This project was a masterclass in strict Minimum Viable Product (MVP) Scoping. Operating under a rigid development timeline, we learned to ruthlessly cut non-essential feature bloat—such as complex audio mixing channels and heavy screen-shake particle effects—to ensure our core displacement loop was completely polished and bug-free.
We also discovered an accidental benefit of our artistic constraints: stripping away real-time ambient shadows didn't just optimize processor performance; it vastly improved game legibility. On small mobile screens under distracting, real-world lighting conditions, high material contrast allows players to calculate paths and read tile health states infinitely faster than complex 3D rendering layouts.
Log in or sign up for Devpost to join the conversation.