Game Card System (GCS)

Create Content Visually and Build Complete Card Roguelike Battles with FlowGraph-Based Mechanics

Official Website | Chinese Documentation | Video Tutorials | Discord | Unity Forum

Game Card System (GCS) is a visual card roguelike battle framework built for production-ready Unity projects. It brings card, deck, player, enemy, status, and encounter data authoring, FlowGraph gameplay orchestration, a complete battle runtime, real-time Play Mode diagnostics, and C# extension APIs into one unified workflow. You can immediately start creating cards, designing builds, balancing values, and validating gameplay without building foundational systems such as turns, piles, target selection, status resolution, enemy intents, and post-battle rewards from scratch.

💡 Why I Developed GCS

• I developed GCS because I am creating my own indie card roguelike game. During the early stages of the project, everything went smoothly. A few cards, several statuses, and some simple enemy actions could all be implemented with a handful of straightforward scripts. As the project entered mid-to-late development, however, cost changes, target selection, card drawing and discarding, status stacking, Hooks, enemy intents, dynamic summoning, rewards, UI, animations, and waiting flows began affecting one another.
• A special condition added to one card today would require the status system to support it tomorrow, while the enemy behavior and presentation layers would need to understand the same rule the day after that. What began as scattered scripts gradually became a web of dependencies that was difficult to inspect or modify. Many problems could only be discovered through repeated battle testing, yet it remained difficult to determine exactly which rule, phase, or waiting flow had failed.
• Modern AI Agents may generate code quickly during the prototyping stage, but as a project grows and system dependencies continue to accumulate, generating more scripts does not solve the underlying structural complexity. Developers who regularly work with AI will recognize that AI needs a clear data model, fixed operational boundaries, and verifiable runtime results before it can genuinely participate in long-term content production and creation.
• GCS was carefully designed to solve these problems because I understand that developers should be spending their time deciding whether cards are fun, whether values are balanced, whether builds create meaningful new choices, and whether different mechanics can form combinations worth replaying. GCS is both the development framework used by my current game and a reusable production foundation for the card roguelike games I plan to create in the future.

🚀 Core Features

• Visual Content Authoring Across Six Categories Game Card Editor provides six editing modes: Card, Deck, Player, Enemy, Status, and Encounter. Within a single window, you can create, search, filter, sort, preview, and validate content, inspect asset references, and use complete Undo/Redo support without repeatedly switching between numerous standalone Inspectors and scripts.
• FlowGraph Gameplay Orchestration Card, Status, and Enemy each have their own FlowGraph Behavior. A complete Demo installation provides 147 available nodes covering damage, healing, Armor, Energy, card movement, target selection, numerical calculations, flow control, branches, loops, Hooks, enemy intents, events, VFX, SFX, animations, and waiting flows. Common card mechanics can be created directly by combining nodes without defining a new C# type for every card.
• 103 Complete Mechanic Recipes The online documentation provides 52 card recipes, 30 status recipes, and 21 enemy behavior recipes. Each recipe includes complete node connections, parameter configurations, and runtime boundaries. You can continue iterating from validated FlowGraph structures and spend your development time on values, combination effects, and the player experience.
• Complete Card-Battle Runtime GCS provides a complete battle lifecycle from Battle Start through the player phase and enemy phase to Battle End. The runtime manages Energy, target selection, Draw, Hand, Discard, Exhaust, Master Deck, status stacking and decay, Hook-based rule modification, delayed effects, dynamic summoning, player selections, post-battle rewards, permanent upgrades, cost changes, animation Gates, and victory or defeat resolution. The Behavior you connect in the editor is the same Behavior that executes at runtime.
• Status and Hook System Statuses can simultaneously contain stacking rules, decay rules, passive numerical modifiers, Hook interception, and independent FlowGraph Behaviors. Statuses can participate in the resolution of damage, healing, Armor, Energy, card drawing, card play, status application, and maximum hand size, making them suitable for building persistent Buffs, Debuffs, and battle-rule modifications.
• Previewable Enemy Intents Patterns such as Sequence, Weighted Random, HP Threshold, Once Per Battle, and Every N Turns are used to orchestrate enemy behavior. The HUD can display an enemy’s next Intent in advance, while the runtime preserves Pattern state across turns and executes the corresponding behavior during the enemy phase. The system also supports dynamically summoning and removing enemies during battle.
• Real-Time Diagnostics with Game Card Monitor Game Card Monitor provides seven views: Battle, Piles, Units, Phase, Gate, Flows, and Events. When a status fails to trigger, a card enters the wrong pile, or a battle phase stops progressing, you can directly inspect FlowGraph execution records, waiting sources, pile changes, unit states, and event history without temporarily filling the entire project with Debug.Log calls.
• Open C# Extension APIs GCSApi serves as the unified entry point for battle control, state queries and modification, content discovery, and event subscription. The system provides 43 built-in events, 4 automatic extension registries, and seven custom node base categories: Mutator, Operator, Source, Selector, Control, Pattern, and VFX. The package includes complete source code, node extension templates, and runnable examples. When your project requires specialized gameplay, you can extend FlowGraph nodes or use GCSApi to integrate custom UI, maps, quests, save systems, and other project-specific systems.

🤖 Enable AI Agents to Genuinely Participate in Content Production

GCS does not bundle any AI model or require projects to use AI. It provides a working framework with clear boundaries, a stable structure, complete documentation, and verifiable results. You can use AI Agents to create content around GCS’s six predefined content databases, FlowGraph nodes, 103 mechanic recipes, Validation, GCSApi, and Monitor records, for example:

• Create and configure cards, decks, statuses, enemies, and encounters
• Combine or modify FlowGraph Behaviors
• Adjust values and build configurations
• Inspect database references and configuration errors
• Assist with issue diagnosis based on runtime records

With GCS, AI-generated results are stored as production assets that developers can open, inspect, run, and continue modifying, rather than becoming another collection of temporary scripts scattered throughout the project. This ensures that gameplay design, content decisions, and final results always remain under the developer’s control.

📦 Included Content

• 12 playable battles
• 80 cards
• 16 decks
• 12 player units
• 16 enemies
• 30 statuses
• 12 encounters
• 8 enemy Intent icons
• Four class lines: Warrior, Mage, Hunter, and Priest
• Normal, Elite, and Boss battle tiers
• Complete battle UI, hand, target-selection, reward, and result flows
• Complete English and Chinese online documentation
• 103 FlowGraph mechanic recipes
• 7 custom node template categories
• 7 complete extension examples
• A complete tutorial for creating your first battle from an empty scene

Every included Demo is built with the packaged databases, Game Card Editor, FlowGraph, and production runtime. There is no separate battle implementation used only for presentation. You can directly open, inspect, copy, and modify the Demo content and use it as an implementation reference for production projects.

💪 Who Is GCS For

• Independent Developers: Start with a complete card-battle foundation and invest more development time and budget in art, content, balance, and gameplay design.
• Game Designers and Technical Artists: Create battle content with visual tools, combine common gameplay rules, and directly inspect real runtime results.
• Programmers: Use the complete source code, GCSApi, strongly typed events, custom nodes, and content registries to integrate project-specific systems.
• Development Teams: Keep content data, gameplay rules, runtime state, and debugging evidence within the same workflow, reducing scattered scripts and implicit dependencies.
• Developers Using AI Agents: Allow AI to participate in content production within clearly defined data structures and operational boundaries instead of repeatedly generating framework code that is difficult to maintain over the long term.

🛠 Technical Specifications

• Unity Version: Unity 2021.3 LTS and later, including Unity 6
• Render Pipelines: Built-in Render Pipeline and URP
• Third-Party Runtime Dependencies: None
• Source Code: Complete C# source code included
• Data Architecture: Six ScriptableObject database categories with GUID identification
• FlowGraph: 145 core nodes, with 2 additional FX extension nodes included in the Demo
• API: 147 public member names across 148 public signatures
• Events: 43 built-in events
• Monitor: 7 real-time diagnostic views
• Extension Registries: FlowNode, CardType, CardTag, and DescriptionToken
• Custom Nodes: 7 public extension base categories
• Animation Utility: TinyGiants TGTween included
• GES Integration: Optional; GCS and GES can both be used independently

📌 Product Scope

• GCS focuses on content authoring, rule orchestration, runtime execution, and diagnostics for card roguelike battles.
• World maps, quest flows, account backends, online multiplayer, matchmaking systems, and project-specific save formats are outside the core scope of GCS. These systems must be implemented by the project and connected to battles through GCSApi or the event interfaces.
• As planned, GMS will provide the world map functionality.
• The included Demo is a runnable production implementation and source-code reference, but it does not restrict the UI, artwork, VFX, audio, or scene presentation style used by your final project.

I use GCS in my own game every day because it solves the problems I have encountered in real development. I am now sharing this framework with more developers to help creators around the world realize their dreams with the lowest possible time cost. With GCS, you can minimize the cost of maintaining foundational architecture and redirect your energy toward the content and decisions that truly determine the quality of your game. Tino | TinyGiants