TCGONBuild the rules.
Run the game.
Cards, boards, phases, rules, effects.
Different TCGs on a single game engine.
TCGON is not a simulator for one specific title. It aims to define and run different rule systems on one common game engine.
Think about TCGs from the engine.
Most card game simulators are built per title. TCGON separates the game definition from a common engine, so swapping the definition is enough to run a different TCG. Rules and cards are treated as data, not code, and a shared engine reads and runs them — that is TCGON's starting point.
Definitions as data
Boards, zones, phases, rules and effects are written as data, not code.
A common engine
The same engine interprets the definition and runs the game — no rebuild per title.
A reusable foundation
The goal is to extend one mechanism across TCGs with different rule systems.
One Engine. Different Games.
Games with different boards, phases, rules, cards and zones — interpreted by the same TCGON engine and run as one simulator.
TCGON Simulator
A simulation environment for actually running the TCGs you build in the Builder, in the browser. It lives at tcgon.net; this page is an overview.
The engine manages game state in one place, and a player's actions are validated as commands before being applied. The aim is to let human vs human, human vs AI, and AI vs AI all play out on the same mechanism.
TCGON Simulator is under active development. Features and specifications may change.
- Browser basedRuns in the browser — no install required.
- State managementThe engine manages game state in one place.
- Command validationActions are validated as commands before being applied.
- Multiple TCG definitionsLoads multiple TCG definitions on the same engine.
- Human / AI playHumans and AI act through the same mechanism.
- Network playDesigned with networked matches in mind.
TCGON Builder
TCGON Builder is not an admin panel for tweaking settings. It is a development environment where you define a TCG's rules, board, phases, cards and card effects one by one, as data, and build them up into something the engine can actually run.
It isn't only for reproducing existing TCGs. In time, the aim is to grow it into an environment where you can build a TCG of your own and run it on TCGON. The game data assembled here is designed to run directly in the Simulator.
Human or AI.
Same Game.
There is no separate rule set for AI. The engine decides which actions are available, and both humans and AI go through the same command pipeline to update the game state. Because of this design, the very same mechanism can also have AI play against AI.
The engine offers the actions available right now
Humans and AI pick from the same candidates
The same command pipeline updates the game state
The same mechanism can drive AI vs AI
AI Simulation → Match Report → Analysis
Going forward, TCGON envisions using AI not only as an opponent, but as a player that simulates a TCG at scale to generate data. By running many AI matches and aggregating the results, the aim is to produce material for checking game balance.
- Number of matches
- Win rate
- First / second player win rate
- Average number of turns
- Win rate by deck
- Card usage
- Win rate of games where a card was used
- Rarely used cards
- Game-ending patterns
- AI behaviour tendencies
AI does not automatically decide the right balance. Its role is to play games and generate data; the final game design and balance decisions are made by people.
From definition to state, in one flow.
In TCGON, the common engine interprets a game definition, computes the available commands, validates a Player / AI choice and updates the state. There is more on the development log.
Want more detail? Head to Development.
- GAME DEFINITIONdata for board, rules, cards and effects
- TCGON ENGINEthe common runtime that interprets it
- AVAILABLE COMMANDSthe actions available right now
- PLAYER / AIpick an action from the candidates
- COMMAND EXECUTIONvalidate and apply the choice
- GAME STATEthe updated game state
- SIMULATORrender and run in the browser
For TCG Creators
TCGON isn't aiming to be a simulator that merely reproduces existing TCGs. In time, the goal is an environment for making TCGs themselves: define your own TCG's rules, board, cards and effects in the Builder, run it for real in the Simulator, and check its balance through many AI-vs-AI matches.
Not build once and stop — build, run, simulate, look at the results, and adjust again. TCGON is envisioned as a foundation where that whole TCG-development cycle can be turned in one place.
The TCG-development flow TCGON envisions is a cycle that repeats these five steps.
- 1BUILDTCGON Builder
Define rules, board, phases, cards and effects, and build the game.
- 2PLAYTCGON Simulator
Run the game you made in the browser and see it in action.
- 3SIMULATETCGON AI
Have AI play against AI, running many matches.
- 4ANALYZEMatch Report / Analysis
Aggregate the results and check win rates and game trends.
- 5IMPROVEGame Design
Adjust rules and cards based on the analysis, and return to the Builder.
IMPROVE → BUILD From IMPROVE back to BUILD — adjust based on the analysis, and turn the cycle again.
What's running today, and where things are headed next. Features that already exist and directions still to be built are shown separately.
- Generic TCG Engine
- TCGON Builder
- TCGON Simulator
- Human / AI Command Pipeline
- AI vs AI
- AI Match Reports
- Simulation Statistics
- Balance Analysis Support
- Custom TCG Testing Environment
- Creator-oriented Game Development Workflow
There is not yet a finished service where anyone can freely register and publish a TCG of their own. What's described here is the direction TCGON is heading toward.
Testing the engine against different rule systems.
TCGON is not a simulator for one specific title. To check whether different TCG rule systems can be handled on one common engine, the developer also runs tests using real TCGs as test cases, on a personal basis.
Detective Conan Card Game
testingLoading a rule system with different zone and phase structures
Development testONE PIECE Card Game
testingFitting the engine to a board model with a leader and life
Development testTCGON is a personally developed, generic TCG simulation project. It is not an official service for any specific TCG title. Tests using real TCGs are carried out by the developer, on a personal basis, to verify support for different game rules.
TCGON is not an official service of any TCG title, and does not indicate approval, operation or partnership by any rights holder.
Built in public.
TCGON is a personal project. From a single-title simulator to a data-driven, generic engine — the process is shared on note and elsewhere.
- Card Game Simulatordone
Started out as a card game simulator for a specific title.
- Generic Game Enginedone
Stripped out the title-specific code and redesigned it as a common engine.
- Data-driven Rulesdone
Moved to defining boards, zones, phases and rules as data.
- TCGON Builderin progress
Building out the environment for authoring game data.
- AI Playerin progress
Verifying an AI that selects from the actions the engine offers.
- AI vs AIin progress
Developing AI-vs-AI self-play through the same command pipeline.
- Multi-TCG Experimentsin progress
Testing compatibility of TCGs with different rule systems on one engine.
Run the Engine.
TCGON is under active development. The running simulator lives at tcgon.net.