TCGONBuild the rules.
Run the game.
Cards, boards, phases, rules, effects.
Different TCGs on a single game engine.
TCGON now works to share not only game structure, but the meaning of card effects — through a common engine and runtime.
TCGON Development Log 6 is live
How live play exposed hidden Conan assumptions and led to a deeper generic-engine refactor.
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.
Define structure and effects. Run them on one engine.
TCGON combines a Generic TCG Engine for game structure, TEDL for the meaning of card effects, and a Simulator that runs both.
Generic TCG Engine
defines game structure
TCGON Effect Definition Language (TEDL)
defines card effects
Simulator
loads the definitions and runs the game
Treat card effects as meaning, not just text.
Cards may use different wording while asking the game to do similar things. TCGON breaks effects into triggers, costs, targets, conditions and actions. This developing common representation is the TCGON Effect Definition Language — TEDL.
On Play DON!! -1: K.O. up to 1 of your opponent's Characters with a cost of 5 or less.
- Trigger
- On Play
- Cost
- DON!! -1
- Target
- Opponent / Character
- Condition
- Cost <= 5
- Count
- <= 1
- Action
- K.O.
From one sentence to executable meaning.
- CARD TEXT
- ↓Per-card implementation
- ↓GAME LOGIC
- CARD TEXT
- ↓Parse meaning
- ↓TEDL
- ↓COMMON ENGINE
- ↓GAME LOGIC
Instead of implementing every card one by one, TCGON translates its meaning into a form the engine can use. This Effect Translation is separate from translating text for readers.
Testing the engine against different rule systems.
Generality is tested by running different TCGs, not declared complete in advance. TCGON is separating Conan-specific assumptions so Conan and ONE PIECE can run as equal game definitions, while building a foundation for the next TCG.
Detective Conan Card Game
simulator testLoading a rule system with different zone and phase structures
Development testONE PIECE Card Game
simulator testFitting the engine to a board model with a leader and life
Development testGodzilla Card Game
data collectionCollecting rules, card data and title-specific expressions
Development testUltraman Card Game
data collectionStudying different win conditions and card expressions
Development testDisney Lorcana
data collectionStudying lore-based rules and effect vocabulary
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.
Cards, in your language.
Card titles and effect text can be translated on demand. The original card data stays intact while the card becomes readable in another language.
TEDL translates effect meaning for the engine. On-demand translation converts card text into a language a person wants to read.
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
Want to try building with TCGON?
Personal development, original card-game implementation tests, and experiments with unusual rules or effects — TCGON is looking for partners who want to learn by building together.
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.
TCGON Development Notes
Six articles trace the second-TCG test, effect translation, and the deeper refactor that removes hidden title-specific assumptions.
- 03Building ONE PIECE Cards One by One Ended with ‘Do the Rest’ | TCGON Development Log 3The unit of work shifts from cards to effect patterns, using shared parts and classification at scale.Read on note ↗
- 04Asking for Every ONE PIECE Card Effect Led to a Translation System | TCGON Development Log 4Per-card implementation gives way to a system that translates card text into shared meaning.Read on note ↗
- 05Translating Every Remaining ONE PIECE Card Effect Was Only the End of the Beginning | TCGON Development Log 5The vocab pipeline classifies and translates 3,694 effects, turns missing behavior into shared engine capabilities, and moves 2,823 card types into formal implementation before live-game testing.Read on note ↗
- 06ONE PIECE Revealed That TCGON Was Only Generic in Appearance | TCGON Development Log 6Live play exposes hidden Detective Conan assumptions, prompting a refactor that treats Conan and ONE PIECE as equal game definitions on the same engine.Read on note ↗
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
- Multi-TCG Game Definition
- TEDL
- Card Effect Translation
- On-demand Card Translation
- Human / AI Command Pipeline
- AI vs AI
- TEDL Vocabulary Expansion
- Multi-TCG Effect Analysis
- Additional TCG Experiments
- AI Match Reports
- Simulation Statistics
- Balance Analysis
- Custom TCG Creation
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.
Run the Engine.
TCGON is under active development. The running simulator lives at tcgon.net.