MonMon (Hackathon)

Overview

MonMon is a Web3 hackathon game prototype built around collecting, battling, fusing, and trading MonMons. Players open packs, build a team, buy and sell MonMons through a marketplace, and combine MonMons to create new ones that can be reused in future battles or merges. The main idea was to build something fun while experimenting with an LLM-assisted fusion system that could potentially support an effectively unlimited number of combinations through a merging mechanic.

We were especially interested in the idea that fused MonMons would not just be one-off outputs, but could become part of the normal gameplay loop and keep expanding the roster in unexpected ways. Alongside that, we wanted the marketplace to act as a meaningful trading layer for the game, allowing players to earn currency and giving them another path for shaping their roster outside of pack opening and fusion.

Because the hackathon happened during a particularly busy period for the team, we realistically only had around two focused days to build. As a result, the project was scoped as a fast concept-validation prototype aimed at getting the collect, combine, trade, and battle loop working end to end rather than as a polished or production-ready game.

Demo

Short walkthrough of the core gameplay loop: open packs → fuse MonMons → manage your collection → trade in the marketplace → battle with the results.

This demo focuses on the main gameplay idea and the AI-assisted fusion system, which is the most distinctive part of the project.

1) Open packs and collect MonMons

The game starts with a pack-opening flow where players spend in-game currency to obtain MonMons with different rarities.

2) Fuse two MonMons

In the fusion lab, players choose two MonMons to combine. The backend uses an Ollama-based model to generate a new merged MonMon, including its metadata and a generated visual asset.

3) Manage collection and team

The merged MonMon is saved back into the game and can be treated like part of the normal roster, making the fusion mechanic part of the broader game loop rather than a one-off effect.

Collected and fused MonMons can be viewed in the collection, then organized into a team for battle.

4) Buy and sell MonMons in the marketplace

The marketplace was intended to be part of the game’s broader trading and economy loop, giving players another way to shape their roster outside of pack opening and fusion. In the hackathon prototype, this appears as a simplified buy and sell flow using in-game currency.

5) Battle using collected and fused MonMons

Once a team is prepared, players can enter a simple turn-based battle flow and continue progressing through the collect, combine, trade, and battle loop.

This demo uses footage captured from the original hackathon submission build.

What I built

• Core battler game loop: Built a Phaser-based game loop with pack opening, collection management, team setup, battle flow, and a fusion lab.
• Frontend gameplay flow: Created a frontend flow that lets players collect MonMons, organize them into a team, and use them in turn-based battles for rewards.
• Marketplace flow: Built a simple marketplace where players can buy and sell MonMons using in-game currency as part of the broader collection and trading loop.
• AI-assisted fusion system: Implemented a fusion flow where two selected MonMons are sent to a backend service to generate a new merged character.
• Persistence and progression: Added a persistence flow that saves player progress, collection state, and generated fused characters so they can continue being used in later gameplay.

Key decisions

• Make fusion the main differentiator: Instead of trying to make the project stand out through battle depth alone, I centered it around character fusion as the core idea.
• Use LLM-assisted character generation: I used an Ollama-based model to generate fused character metadata so merged MonMons could go beyond a small set of predefined combinations.
• Make generated characters reusable game entities: Fused MonMons are inserted back into the game’s character pool and player collection so they can continue participating in gameplay and future merges.
• Treat Web3 as supporting infrastructure: Rather than forcing the entire game loop on-chain, blockchain-related pieces were treated as supporting systems around the app.
• Use the marketplace as an economy layer: We wanted roster-building to come from more than random pack pulls, so the marketplace was designed as another core path for acquiring and trading MonMons, even though the hackathon version only implements a simplified version of that idea.

Constraints & limitations

• Very limited build window: We chose to take part in this hackathon during a busy academic period, which meant the project ended up being built in roughly two focused days. Because of that, the implementation prioritizes getting the core gameplay and fusion idea working end to end over deeper engineering polish or long-term design.
• Fusion quality depends heavily on LLM output: The merge system is one of the most interesting parts of the project, but it also depends on prompt quality and model behavior, which makes results less predictable than a fixed handcrafted fusion system.
• Validation around generated outputs is still lightweight: The backend checks for required fields and basic rarity validity, but there is limited enforcement around deeper consistency, balance, or output quality.
• Core game systems are mostly off-chain: Although the project was built for a Web3 hackathon, most of the gameplay happens through standard web app state and backend persistence rather than on-chain game mechanics.
• Payment and accounting flow is prototype-level: Payment-related flows exist, but some verification and trust assumptions are lightweight, which makes the current implementation more suitable for demo purposes than a real deployment.
• Gameplay depth is intentionally simple: The battler loop works as a prototype, but combat, progression, and balancing remain lightweight because the main focus was validating the fusion idea under strong time pressure.
• The marketplace is a simplified version of a larger intended system: We wanted the marketplace to act as a meaningful trading and economy layer similar to what item-based games use to shape player behavior and value exchange. In the hackathon build, though, pricing and transaction logic remain lightweight, so it works more as an early prototype of that idea than a fully designed trading system.

Future considerations

• Rebuild the current prototype with more time and cleaner architecture, since the existing version was shaped heavily by a very compressed development window.
• Strengthen the fusion pipeline with stricter validation so generated MonMons are more consistent, balanced, and easier to integrate back into the game.
• Improve character identity and persistence so generated fusions can scale more safely without collisions or ambiguity.
• Expand the battle system with deeper combat mechanics, stronger progression, and more meaningful team-building decisions.
• Develop the marketplace into a more robust trading system with clearer pricing logic, stronger validation, and more deliberate economy design.
• Revisit how much of the project should remain off-chain versus which systems would genuinely benefit from stronger Web3 ownership or asset mechanics.
• Harden payment and user-account flows so the surrounding Web3-related features are more trustworthy and complete.
• Develop the fusion mechanic further so it becomes a deeper gameplay system rather than just an interesting prototype feature.