UVULITES - NFC Card Game

Inspiration

The idea for UVULITES started with a simple question: what if placing a real card on the table could instantly turn it into a live unit on screen, and those units could battle each other in real time?

After a lot of spitballing and iteration, that idea evolved into what is now UVULITES: a hybrid tabletop and digital strategy game that combines the tactile feel of physical cards with the responsiveness of a video game.

What It Does

UVULITES is a 1v1 card battler where players use physical cards embedded with NFC chips. When a card is placed on an NFC reader, the game detects it and spawns the corresponding character in-game.

Those units then fight automatically on a shared battlefield. Each player must defend their king while sending troops at the opponent. Defeat the enemy king first, and you win.

How We Built It

We built the game in C using Raylib for rendering and SQLite for card data and NFC tag mappings. On the hardware side, we used Arduino boards with PN532 NFC readers to detect physical cards.

Each scan sends a compact serial packet into the game. From there, the game looks up the card in the database and runs the same gameplay logic as any normal in-game action. This gave us a full pipeline from physical card input to live gameplay on screen.

Challenges We Ran Into

One of the hardest parts was making the hardware feel reliable enough for a real-time game. NFC reads are messy in practice: cards can be scanned repeatedly, removed mid-frame, or read with slight timing differences. We had to design a custom serial protocol, debounce repeated scans, handle card removal cleanly, and still keep gameplay responsive at 60 FPS.

Another major challenge was the multiplayer presentation. Both players are looking at the same battlefield from opposite sides of the table, so the game had to render one shared world from two different perspectives without losing clarity. Getting the split-screen view, lane layout, and battlefield orientation to feel intuitive took a lot of iteration.

We also had strict hardware constraints. The game needed to run on a Raspberry Pi 4 with only 2 GB of memory and limited graphics performance. That forced us to think carefully about optimization, but building the project from scratch in C gave us the control we needed to make it run well.

Accomplishments That We're Proud Of

We are proud that we took this idea from a rough concept to a working prototype that people can actually play. Over the last two months, our team has spent countless hours brainstorming, building, testing, and polishing every part of the experience.

A huge amount of time, effort, and passion went into this project. As the deadline got closer, there were plenty of late nights focused on getting the game into a complete, playable, and polished state. Seeing it all come together has been one of the most rewarding parts of the project.

What We Learned

This project taught us a lot about the difference between a cool prototype idea and a system that actually works under live demo conditions. We learned how to connect embedded hardware to a real-time game loop, how to make serial input reliable, and how much easier iteration becomes when gameplay content is data-driven instead of hardcoded.

More broadly, we learned that mixing physical and digital interaction creates a very different design space than building either one on its own. The biggest lesson was that the technical architecture matters just as much as the game idea. If the hardware, rendering, and gameplay systems are not tightly integrated, the magic disappears.

What's Next for UVULITES

We plan to continue developing UVULITES as a tabletop strategy game and keep expanding both the hardware and gameplay. That includes improving the physical card system, adding more cards and mechanics, refining balance, and continuing to polish the overall player experience.