-
-
Hosting 4 player room
-
3 player empty board
-
4 player empty board
-
Wallpaper studio
-
empty 2 player game board
-
on going 2 player game
-
emote tray
-
Home Screen
-
Join Room Screen
-
4 player selection menu
-
3 player selection menu
-
2 player selection menu
-
Game Over Screen
-
Game Icon
Inspiration
GRIDLOCK started much earlier than Shipaton.
The idea goes back to 2017, when I began sketching ways to take Tic-Tac-Toe beyond the traditional 3×3 board.
My notebooks gradually filled with:
- Larger board concepts
- Multiplayer layouts
- UI sketches
- Animation ideas
- Game mechanics
- Colour experiments
- Monetisation concepts
- Calculations
- Many, many crossed-out ideas
The question behind all of it was:
How far can Tic-Tac-Toe be pushed before it stops feeling like Tic-Tac-Toe?
Initially, I thought the answer was simply scale.
More players. Bigger boards. More possibilities.
But I eventually realised that bigger does not automatically mean deeper.
A larger board can simply become a larger version of the same problem, and adding more players can create complexity without necessarily creating better decisions.
That changed the direction of GRIDLOCK.
Instead of only asking how to make Tic-Tac-Toe larger, I started asking how players could interfere with the assumptions of the game itself.
What if a position could be protected?
What if a piece could be displaced?
What if an opponent's plan could be overwritten?
What if the state of the board itself was no longer permanent?
Those questions eventually became the foundation of GRIDLOCK's special-move system.
Then the project stopped.
The notebooks stayed, but the game remained an idea for years.
When I eventually came back to GRIDLOCK, I had significantly more experience as a developer and many of the ideas that seemed difficult in 2017 suddenly felt possible.
Shipaton became the deadline that finally made me turn those old sketches into a real game.
GRIDLOCK was not invented for this hackathon.
Shipaton gave me the reason to finally finish something I started thinking about almost nine years ago.
What it does
GRIDLOCK reimagines Tic-Tac-Toe as a multiplayer strategy game for up to four players.
It supports:
- 2-player matches
- 3-player matches
- 4-player matches
- Local multiplayer
- Real-time online multiplayer
- Custom rooms
- Different board configurations
- Strategic special moves
At its core, GRIDLOCK is still about something immediately familiar:
Read the board. Predict your opponents. Build the winning pattern.
The difference is that the board is no longer completely passive.
Players can call on eleven special moves, each bending one assumption of the base game:
- Anchor — makes a piece permanent, immune to being overwritten or shifted
- Push — shifts a whole line of pieces one direction, board and all
- Dictator — forces the next player into a macro-grid you choose
- Overwrite — claims an opponent's cell outright, unless it's anchored
- Sandwich — traps enemy pieces between two of yours and flips them
- Bait — plants a real trap among decoys nobody can tell apart
- Mirror — claims a cell and its exact opposite on the board, at once
- Nuke — wipes an entire macro-grid clean
- EMP — strips Anchor, Bait and decoy status from a macro-grid
- Gravity — tilts the whole board; every unanchored piece resettles
- Placement — hands the opponent's next move to you to dictate
These moves introduce disruption, defence, positioning, deception, manipulation, and comeback opportunities.
A position that looks secure may suddenly become vulnerable.
A player who appears to be losing may still be able to create another path.
The intention is not random chaos.
It is controlled chaos with counterplay.
Every completed match also creates a unique final board.
Instead of discarding that board when the game ends, GRIDLOCK can transform the final match state into a generated wallpaper, turning the decisions made during a match into something the player can keep.
The entire experience is presented through a minimalist paper-and-ink visual language.
How I built it
GRIDLOCK is built primarily with Flutter and Dart.
I am developing the project solo, so the game has required me to work across:
- Gameplay architecture
- Multiplayer networking
- UI design
- Animation
- Rendering
- Accessibility
- Economy design
- Sound direction
- Testing
- Product design
One of the most important architectural decisions was separating the authoritative game state from the visual presentation.
The board can animate.
Ink can spread.
Pieces can move.
Special moves can create dramatic visual effects.
But the game underneath all of that must remain deterministic.
The gameplay layer handles:
- Turn state
- Player state
- Board state
- Move validation
- Win conditions
- Special-move validation
- Special-move effects
- Match progression
- Conflict resolution
The presentation layer then takes that state and turns it into the experience the player sees.
Multiplayer
GRIDLOCK supports real-time multiplayer and custom rooms.
A normal placement is relatively straightforward to synchronize.
A special move is not.
One action can potentially:
- Affect multiple cells
- Move an existing marker
- Replace another marker
- Protect a position
- Change another player's tactical situation
- Modify several parts of the board at once
The multiplayer system therefore synchronizes game actions and state changes, rather than merely trying to play identical animations on every device.
Every player needs to arrive at the same authoritative state.
Supporting more than two players
Traditional Tic-Tac-Toe assumes two players.
GRIDLOCK supports up to four.
That affects:
- Board dimensions
- Turn order
- Winning patterns
- Player identification
- UI layout
- Match pacing
- Tactical balance
- Special-move interactions
A mechanic that works well with two players may behave completely differently when three or four people are interacting with the same board.
Paper and ink
The visual identity came directly from the origin of Tic-Tac-Toe itself.
The game normally requires almost nothing:
a piece of paper and something to draw with.
Instead of hiding that simplicity behind a conventional mobile-game interface, I decided to embrace it.
GRIDLOCK uses:
- Paper-like surfaces
- Ink-inspired marks
- Animated strokes
- Morphing transitions
- Custom board rendering
- Hand-drawn visual language
- Controlled imperfections
The goal is for different screens to feel less like unrelated pages and more like one sheet of paper continuously changing shape.
Challenges I ran into
Making Tic-Tac-Toe deeper without destroying its simplicity
This has been the central design problem.
Adding mechanics is easy.
Adding mechanics that create meaningful decisions is much harder.
Every mechanic has to answer one question:
Does this create strategy, or does it simply create another rule?
If players need to memorize a huge rulebook before understanding GRIDLOCK, the design has failed.
The game needs to remain recognizable almost immediately.
Balancing special moves
Special moves need to feel powerful enough to matter without becoming automatic win buttons.
If they are too weak, players ignore them.
If they are too strong, the underlying strategy disappears.
The goal is to create counterplay.
A powerful move should alter the situation, not simply end it.
Balancing becomes even harder because the same mechanic can behave very differently in 2-player, 3-player, and 4-player matches.
Multiplayer synchronization
Complex board-changing abilities create much more difficult synchronization problems than normal piece placement.
I had to think about questions such as:
- Was the action valid when it was submitted?
- Which game state is authoritative?
- What happens when two events occur close together?
- Can another action happen while an animation is still running?
- How do all players end up with exactly the same board state?
This reinforced one of the most important architectural rules in GRIDLOCK:
Visual state and gameplay state cannot be the same thing.
Making digital ink feel natural
Perfect vector graphics often look too digital.
Too much randomness looks artificial.
Too much texture makes the interface noisy.
Too little texture removes the physical feeling completely.
Finding the right balance required experimentation with:
- Animation timing
- Stroke behaviour
- Shape interpolation
- Blur
- Particle effects
- Imperfection
- Motion
Building everything solo
GRIDLOCK has no separate:
- Game designer
- Backend engineer
- Animator
- UI designer
- QA team
- Sound designer
- Product manager
It is just me.
That means adding one gameplay feature often creates several additional tasks.
A special move may require:
- Designing the mechanic
- Implementing its rules
- Handling edge cases
- Synchronizing it in multiplayer
- Animating it
- Explaining it in the tutorial
- Making it accessible
- Testing it across different game modes
One of the hardest parts of the project has therefore been deciding what not to build.
Accomplishments that I'm proud of
- Turning an idea from 2017 into an actual playable game
- Building the project as a solo developer
- Supporting up to four players
- Creating different board structures for different player counts
- Building both local and real-time multiplayer
- Designing a deterministic game architecture for complex board-changing mechanics
- Creating a special-move system without abandoning the core identity of Tic-Tac-Toe
- Developing a consistent paper-and-ink visual language
- Creating custom transitions and gameplay animations
- Turning finished matches into unique generated wallpapers
- Bringing gameplay, multiplayer, animation, accessibility, UI, economy, and presentation together into one coherent game
What I learned
The biggest lesson GRIDLOCK taught me is:
Complexity and depth are not the same thing.
A game can have dozens of systems and still contain very few interesting decisions.
Some of the strongest mechanics in GRIDLOCK are the ones that are individually simple but interact with several other systems.
I also learned how important deterministic architecture becomes in multiplayer.
The visual layer can be expressive.
Ink can splash.
Animations can overshoot.
Particles can behave differently.
But underneath all of that:
game state has to be boringly precise.
I also learned that animation works best when it communicates something.
Motion should help explain:
- Where something came from
- What changed
- Why it changed
- Where the player is going next
And building the project solo taught me that scope control is not separate from development.
It is development.
Perhaps the biggest lesson, though, was simply finishing something.
GRIDLOCK existed as sketches and ideas for years.
The tools changed.
My experience changed.
The implementation changed.
But the core idea survived.
Shipaton turned "someday" into a deadline.
What's next for GRIDLOCK: THE ULTIMATE TIC TAC TOE
The next phase is focused primarily on refinement.
That includes:
- Improving multiplayer reliability
- Refining special-move balance
- Testing 2P, 3P, and 4P interactions more extensively
- Improving onboarding and tutorials
- Expanding accessibility options
- Improving colour-blind accessibility without relying only on colour
- Refining paper-and-ink animations
- Improving special-move effects
- Improving sound and adaptive audio
- Refining wallpaper generation
- Optimizing performance across devices
- Continuing economy and progression balancing
- Preparing GRIDLOCK for wider mobile release
- Currently Final Board gives Wallpaper. But Entire match sequence from first to last gives something else. I'll make it alive. from first move to last move. The goal remains the same one that started the project years ago:
Make GRIDLOCK understandable in seconds, but difficult to truly solve.
Log in or sign up for Devpost to join the conversation.