PromptFighter

Your limitless creativity is your weapon! Fight villains or other players as your words become the moveset, each character brings a distinct style, and combat has no fixed rules.

Comment

Inspiration

PromptFighter came from a simple frustration with how most combat games work. Even when they are fun, they usually limit the player to a fixed set of skills, classes, buttons, and move combinations. We wanted to build a game where creativity itself becomes the combat system.

A big part of that idea came from childhood imagination. Growing up, we loved inventing original heroes, villains, and battles in our heads, where there were no preset rules and no limit on what a character could try. PromptFighter is our attempt to turn that feeling into an actual playable game. Instead of selecting attacks from a menu, players write what they want to do and let imagination drive the fight.

We also wanted to explore a broader question: can language itself become a game mechanic? In PromptFighter, the answer is yes. The player’s prompt is not flavor text layered on top of gameplay. It is the gameplay.

What it does

PromptFighter is an AI-powered game where players battle by writing prompts instead of choosing from predefined actions.

The project currently has two main modes:

Single-player mode

Single-player mode is a story-driven fantasy campaign set in the ruined kingdom of Veyrune. The player travels through five chapters to rescue Princess Carolyn from the dragon tyrant known as the End-Bringer. Each chapter includes environmental trials, puzzles, survival scenarios, and boss encounters. The player progresses by solving each stage through creative prompt-writing rather than through fixed attacks.

The campaign is structured around meaningful artifacts and escalating challenges. Players cross broken bridges, outwit cursed relics, survive labyrinths, infiltrate ghost markets, relight ancient forges, and ultimately storm Blackwake Keep. Each chapter reward matters both mechanically and narratively, including the Ember Sigil, Moonlit Compass, Name-Flame Lantern, and a sword tempered in Dragon-Piercing Fire.

Multiplayer mode

Multiplayer mode turns prompt-writing into a real-time PvP experience. Two players enter a battle and write actions against each other, and the system judges the clash based on creativity, relevance, role consistency, and effectiveness.

One feature we were especially excited about was adding multiple character roles for multiplayer. Instead of making every player feel the same, we introduced roles such as Professor, Boomer, and Otaku, each with a distinct personality and way of approaching combat. This made battles much more creative because they were fighting through a role.

For example, the Otaku role can be framed as someone who binge-watches anime, absorbs countless techniques, and then applies those dramatic, over-the-top skills in battle to knock down the opponent. That kind of role-based prompting gives players a stronger identity and makes the fight feel more expressive, funny, and strategic.

At a high level, PromptFighter tries to make combat feel less like selecting from a menu and more like improvising inside a fantasy world.

How we built it

We built PromptFighter as a web-based AI game using a modern full-stack architecture.

Frontend

We used Next.js with the App Router and React to build the interface, and we used Tailwind CSS to create a polished game-like UI. We focused heavily on making the experience feel like an actual game rather than a raw LLM demo. That meant designing battle screens, chapter maps, intro slides, result screens, and multiplayer flows that feel coherent and thematic.

Backend and game logic

We used server routes to handle battle requests and send them to an AI judge. The key design choice was treating the language model as a referee rather than just a chatbot. For single-player, the backend builds stage-aware judging prompts based on the current chapter, objective, and failure conditions. For multiplayer, it compares two submitted prompts and decides which action wins the clash.

To keep results more stable, we used structured JSON-style outputs so the AI would return predictable information such as success or failure, winner, explanation, and narrative result. That helped us reduce ambiguity and made the system easier to integrate with the UI.

Database, auth, realtime, and storage

We used Supabase for several critical systems:

  • authentication
  • persistent player progress
  • multiplayer match data
  • realtime synchronization
  • asset storage

Supabase Realtime was especially important for multiplayer, where both players need to stay synchronized across queueing, prompt submission, round resolution, and match progression.

Deployment

We deployed the project using Vercel for fast iteration and easy integration with our Next.js app. For a hackathon setting, this stack gave us a practical balance between speed, flexibility, and reliability.

In a simplified sense, the project flow looks like this:

Challenges we ran into

One of the hardest problems was using an LLM as a game judge without letting it become too inconsistent. Players can type almost anything, which makes PromptFighter exciting, but it also creates a systems problem: the game still needs to feel fair, understandable, and grounded in the current scenario.

We ran into several concrete challenges:

1. Keeping AI judgment consistent

If the model is too permissive, every prompt wins and the game loses tension. If it is too strict, players feel punished for being creative. We had to find a middle ground where the AI rewards imagination but still respects the stage rules, character role, and narrative stakes.

2. Handling open-ended inputs

Because there are no preset skills, every encounter needed to be designed with enough structure to guide the AI while still giving the player freedom. That required much tighter prompt engineering than we initially expected.

3. Multiplayer synchronization

Realtime multiplayer introduced a different class of challenges. Timers, prompt submissions, match state, and round results all needed to stay aligned across two players. In practice, latency and synchronization were harder than they looked, especially when testing under hackathon constraints.

4. Scope management

We were ambitious from the start. We wanted strong visuals, story depth, multiplayer, character roles, map progression, and polished battle flows. One challenge was resisting the urge to perfect every UI detail before locking down the core gameplay loop.

Accomplishments that we’re proud of

One accomplishment we are proud of is that PromptFighter is not just a concept. We built a playable system where natural language actually drives game progression and battle outcomes.

We are especially proud of:

  • building a working single-player fantasy campaign with structured chapter progression
  • creating a multiplayer PvP system where prompts directly compete against each other
  • giving the game personality through role-based characters like Professor, Boomer, and Otaku
  • designing a world with distinct chapters, bosses, artifacts, and narrative stakes
  • making the UI feel like a game product rather than a barebones AI demo

The role system is one of our favorite features because it adds identity to creativity. Instead of just asking, “What do you do?”, the game also asks, “Who are you when you do it?” That changes how people write, strategize, and roleplay during battle.

What we learned

We learned that building with AI is not just about calling a model API. The real work is in designing the surrounding system: the constraints, the context, the state management, the structured outputs, and the player-facing feedback.

We also learned several practical lessons as a team:

Product clarity matters

When a project is highly open-ended, clear product decisions matter even more. We had to define what makes a prompt good in gameplay terms and make that standard visible across both the backend and the user experience.

AI-generated systems still need strict design

Freedom does not mean lack of rules. In fact, a creativity-based game needs very careful scaffolding. In a rough sense, the challenge was balancing expressive freedom with system control:

$$ \text{Fun} \approx \text{Creativity} + \text{Fairness} + \text{Clarity} $$

If any one of those terms drops too low, the experience breaks.

Team coordination matters a lot

Because the project mixed frontend design, backend logic, AI prompting, realtime features, and story design, communication was critical. We learned how important it is to define interfaces clearly so that different parts of the system can move in parallel.

What’s next for PromptFighter

We think the current project proves the core idea: prompt-based combat can be turned into an actual game. The next step is making that experience deeper, fairer, and more scalable.

Our next priorities would be:

1. Better judging consistency

We want to improve how the AI evaluates prompts so battles feel even more fair, transparent, and strategically interesting.

2. More roles and character identities

The multiplayer role system opened a lot of creative space. We want to expand it further with more distinctive characters, stronger role mechanics, and richer interactions between different playstyles.

3. More content in single-player

We want to add more chapters, more branching scenarios, and more replayability so the world feels larger and more reactive.

4. Better multiplayer polish

We want tighter synchronization, cleaner timers, stronger match feedback, and more refined competitive flow.

5. Long-term progression

A future version of PromptFighter could include unlockable roles, ranked multiplayer, saved character paths, and persistent player progression across repeated sessions.

Ultimately, PromptFighter is our attempt to turn imagination into a game system. Instead of giving players a limited moveset, we want to give them a world where their words become the moveset.

Built With

Share this project:

Updates