Skip to content

Shonen Showdown

A networked trading card game played in first person: you hold your cards, declare attacks, and summoned monsters appear as 3D holograms on the board. I was the lead developer on our three-person team, building the rules engine, the networking and the card data everyone else builds on.

Gameplay prototype.
My role
Lead developer: battle rules, turn flow, networking and card-data architecture
Team
Three-person student team: Georgi (lead developer), Ricardo (art), Sam (data and audio)
Built with
Unity 6 (URP), C#, Photon Fusion 2 shared mode, Photon Voice, ScriptableObjects
Challenge
Keep turn phases, card effects, summons, attacks and visible state in sync across the network

The rules engine

I own the core battle logic: turn management, the chain stack, summoning, damage, and keeping it all in sync over Photon Fusion 2.

  • Six-phase turns

    A TurnManager state machine enforces Draw → Standby → Main 1 → Battle → Main 2 → End, with UI feedback at each step.

  • Summoning rules

    Level 1–4 summon free, 5–6 need one tribute, 7+ need two. A successful summon spawns the 3D monster above the flat card.

  • The chain stack

    Last-in, first-out resolution: Attack → Trap → Quick-Spell resolve in reverse. At most three conditional effects per card, enforced in the data.
Turn 11: both fields full, the turn manager running the whole phase flow.
Drag-to-target attack declaration; the dashed line runs from attacker to target.

Card data the team can extend

I designed the CardData ScriptableObject schema: ID, name, frame, rarity, attribute, level, attack and defence, keyword references and effect text. The battle engine reads it directly.

Keywords such as Piercing and SpecialSummon are separate assets, so a balance change reaches every card that uses them, with no script edits or merge conflicts.

The roster lives in a shared spreadsheet kept by our data lead. A custom "anime race" column sits beside the standard one, so a card can be a Spellcaster by the rules and an Arrancar by lore.

The CardData template in the Unity inspector. I designed it; teammates add cards by filling it in.

Who did what

We worked with strict scene ownership and Git discipline: each person owned their own scenes.

  • Georgi: lead developer

    Core battle scene and logic, lobby and menus, Photon Fusion 2 networking, the turn state machine, the card-data schema and keyword architecture, VR interaction handling.

  • Ricardo: art (in production)

    Custom 3D monster models and animation, the environment, card illustration import, UI polish.

  • Sam: data and audio

    Card data entry, keyword assets, balance and stats, sound effects and music.
Game modes and the full systems list

  • Standard Duel (1v1)

    Classic rules, 8,000 life points, players across the table.

  • Tag Team (2v2)

    16,000 shared life points, alternating turns, voice chat for everyone.

  • Raid Boss (2v1)

    One boss player with double life points and bonus cards against two challengers.

  • Battle Royale (FFA)

    Four players; the last with life points wins.

Systems I built

  • Full six-phase turn state machine.
  • Last-in, first-out chain resolution.
  • Level-based tribute summoning.
  • Attack and defence damage with life-point tracking.
  • Drag-to-target attack declaration.
  • A cinematic "Showdown Phase" for boss monster clashes.
  • ScriptableObject card registry with keyword references.

Design documents