Ghetto Warzones

Ghetto Warzones is the playable client for the Warzones platform — a blockchain-integrated multiplayer FPS shipped to the Google Play Store and PC. My role was the layer that turns a commercial FPS base into a shipped, on-chain, networked product: the blockchain + auth + backend integration, the multiplayer wiring, and the entire build-and-publish pipeline. It's the visible, playable front of a product whose backend I also built.

Honest scope: the game is built on MFPS 2.0, a commercial Unity FPS framework — I did not author an FPS engine from scratch. My work is the integration layer (Firebase auth, on-chain NFT verification, live-backend sync), the networking, and the release engineering that got it onto app stores and kept it shippable.

The problem

Warzones already had a production backend — but a backend isn't a game. The platform needed an actual playable client: a multiplayer FPS that authenticates real users, verifies their on-chain NFT ownership, talks to the live backend, and ships to Google Play and PC. That's a different discipline from API work — Unity, real-time netcode, mobile build constraints, app-store compliance, and multi-gigabyte binary asset management. Owning it is what makes me a full-vertical contributor on this product rather than only the backend.

Architecture

The client's custom scripts bridge three external systems — Firebase for auth/session, Algorand for NFT verification, and the production backend I wrote — so a player's on-chain assets and progression stay consistent between the game and the platform. Multiplayer runs over Photon PUN2 (rooms, matchmaking, relay).

The hardest part: actually shipping it

Anyone can run a Unity project in the editor. The real work — the bulk of my commits — was getting it out the door and keeping it shippable:

• Mobile build pipeline. Produced signed Android .aab bundles for Google Play (managing the signing keystore as a guarded artifact) and a Windows Standalone PC build.
• Size optimization. App-bundle size is a hard Play-Store constraint; I cut the build down (~261 MB → ~195 MB) through texture/asset optimization, with a build report to verify what shrank.
• Security patching under a deadline. Shipped patched build variants to remediate a Unity Android vulnerability (CVE-2025-59489) ahead of a hard Google Play security deadline — the difference between the app staying live or being pulled.
• Reproducibility. Wrote build/setup guides (getting-started, Unity upgrade + publish, Photon setup, auth-UI wiring, version control) and a codebase map, so the build is a documented process, not tribal knowledge.
• Large-binary version control. Managed a ~4.5 GB Git LFS repo so heavy Unity assets stay versioned without wrecking history.

Results

• A blockchain-integrated multiplayer FPS taken from base framework to published Android .aab + PC builds.
• On-chain NFT verification, Firebase auth, and live-backend integration wired into the client.
• Survived a Play-Store security deadline via patched builds (CVE-2025-59489); size-optimized for distribution.
• The playable front of a full vertical I carried on this product: backend → game client → app-store release.

What this demonstrates

The thing a backend portfolio usually can't show: a shipped, visual, playable product. It proves range — Unity + real-time multiplayer netcode + mobile release engineering + security compliance — on top of the on-chain backend depth, and the ownership to carry one product across every layer from backend to app store.