Flick Arena: Building a Real-Time Multiplayer Game

A real-time multiplayer game built with MeDo, without manually setting up backend infrastructure. Matchmaking, synchronization, and ranking are handled automatically, enabling rapid game development.

Comment

Flick Arena: Building a Real-Time Multiplayer Game Without Manual Backend Setup Using MeDo

Inspiration

Flick Arena started as a small experiment.

At first, I simply wanted to see how MeDo would handle an ohajiki-style disk-flicking physics game. I did not begin with a detailed architecture plan or a large multiplayer concept.

MeDo generated a playable core prototype much faster than I expected. Once the basic game worked, the development process became fun, and I naturally kept adding more features: mobile support, local multiplayer, CPU mode, online battles, ratings, and leaderboards.

What started as a simple test gradually became a real-time multiplayer project.

The core question became:

Can a solo creator grow a small game idea into a playable multiplayer experience without manually designing backend infrastructure?

Flick Arena is my answer to that question.

What it does

Flick Arena is a physics-based multiplayer battle game inspired by traditional disk-flicking games.

Players take turns flicking pieces across the arena, using angles and momentum to knock the opponent’s pieces out of bounds. The last player with pieces remaining wins.

The game includes:

  • Online multiplayer
  • Local multiplayer on the same device
  • CPU opponent mode
  • Mobile-ready gameplay
  • Rating display for clearer competitive ranking
  • Global leaderboard using MeDo’s managed database

The rules are simple: flick, collide, and push the opponent out. Ratings and leaderboards make the results easier to understand and give players a reason to keep improving their rank.

At the current stage, ratings are used to visualize player ranking and competitiveness. Rating-based matchmaking is not implemented yet, but it is one of the features I would like to add next.

How we built it

Flick Arena was built with MeDo, an AI-driven development environment.

The development process was highly iterative. I did not start by manually choosing every technology or designing a full-stack architecture from scratch. Instead, I described the game experience, tested what MeDo generated, found issues, and refined the implementation through feedback.

The project grew step by step:

  1. Basic disk-flicking physics gameplay
  2. Local multiplayer
  3. CPU opponent mode
  4. Mobile-friendly layout
  5. Online multiplayer
  6. Ratings and leaderboard

MeDo helped generate and refine:

  • React-based UI
  • Phaser 3 game scene
  • Physics-based movement
  • Realtime multiplayer synchronization
  • Player data management
  • Match data management
  • Rating and leaderboard logic
  • Mobile-responsive layout

For data management, the project uses MeDo’s managed database. The users data is used for player profiles, ratings, and leaderboard information. The matches data is used for matchmaking and match state management.

For configuration management, the project also uses MeDo Secrets. In this project, ADMIN_PASSWORD is stored there instead of being hard-coded into the application.

The online multiplayer system uses a turn-based synchronization model.

The flow is:

  1. Share the flick input
    The direction and force of the player’s move are shared between players.

  2. Update positions during movement
    Piece positions are synchronized while the board is moving.

  3. Confirm the final board state
    After the pieces stop, the final state is synchronized so both players see the same result.

This approach kept the game responsive while avoiding the need for me to manually design complex networking infrastructure.

A key point is that I did not manually build a WebSocket server, a matchmaking server, or a separate ranking backend. MeDo’s managed environment and database features made it possible to focus more on the game experience.

Challenges we ran into

The biggest challenge was synchronization.

In early versions, the board state could become slightly different between players. This is a serious issue for a physics-based game, because even small differences can change the outcome of a match.

To improve this, the synchronization was refined by adding:

  • Input sharing
  • Periodic position updates
  • Final state reconciliation after movement stops

This made the online experience more stable.

Matchmaking also needed refinement. Players can enter matchmaking, cancel, leave, or start at different timings. Handling stale waiting sessions and cancellation states was important for making the online flow reliable.

Another challenge was mobile usability. The game needed to work not only as a desktop demo, but also as something that feels natural on smartphones. Since the core interaction is flicking, the touch experience was important.

Balancing the game was also a challenge. The rules needed to stay simple, while the leaderboard and rating display had to make the game feel more competitive without making it complicated.

Accomplishments that we're proud of

Flick Arena became much more than the small experiment I started with.

It now includes:

  • Real online multiplayer
  • Local multiplayer
  • CPU opponent mode
  • Mobile support
  • Realtime synchronization
  • Matchmaking
  • Rating display
  • Global leaderboard using MeDo’s managed database

The biggest accomplishment is not only that the game works, but how it was built.

I did not manually provision backend servers.
I did not manually build a WebSocket server.
I did not manually create a separate ranking server.

Instead, I described the game experience and used MeDo to generate, connect, and refine the system.

I am also proud of how naturally the project grew. Each time a feature started working, it became easier to imagine the next improvement. MeDo made that iteration fast enough to keep the momentum going.

What we learned

The biggest lesson was that AI-driven development can make experimentation much lighter.

In traditional development, a multiplayer game often starts with architecture decisions: networking, backend APIs, databases, deployment, and synchronization strategy.

With MeDo, I could start from the player experience instead.

The workflow became:

Describe the idea.
Test the result.
Find issues.
Give feedback.
Refine the game.

This loop was especially useful for improving synchronization, matchmaking, mobile layout, and the competitive layer.

I also learned that turn-based multiplayer is a good fit for this kind of development. It reduces synchronization complexity while still giving players a real online multiplayer experience.

Finally, MeDo’s managed database changed the scope of what I could build as a solo creator. Features like player profiles, match data, ratings, and leaderboards usually require backend design and database setup. In this project, those parts were handled through MeDo’s managed database, which made the competitive layer much easier to add.

What's next for Flick Arena

Next steps include:

  • Rating-based matchmaking
  • Spectator mode for watching live matches
  • Emotes during battles
  • Tournament mode
  • Better matchmaking logic
  • Rating balance improvements
  • Anti-cheat mechanisms
  • More polished sound and visual effects
  • Additional visual themes and arenas

Flick Arena started as a quick experiment, but MeDo helped turn it into a playable real-time multiplayer game with mobile support, ratings, and leaderboards.

The next step is to make it feel even more like a competitive mobile game that people can quickly play with friends.

Built With

  • medo
Share this project:

Updates