Overview

SSoT.me (Single Source of Truth) transforms how gaming companies like EA Games, Scopely, and others manage game logic, in-game events, live operations, and updates. By eliminating "syntax-locked" files like JSON, YAML, or hardcoded scripts, SSoT.me introduces a syntax-free rulebook that serves as the master blueprint for all game logic.

This approach accelerates game updates, prevents "drift" in rule implementations, and allows developers, designers, and QA teams to work from a single, always-accurate source.

Key Benefits

• Faster LiveOps: Launch new events and features instantly.

• Accurate Rule Changes: Avoid miscommunications and "game of telephone" errors.

• Eliminate Drift: Keep rules, logic, and configurations aligned.

• Multi-Engine Support: Port game logic across Unity, Unreal, Godot, and more.

Problems SSoT.me Solves

Traditional Approach (Syntax-Locked) vs. SSoT.me Approach (Syntax-Free)

1. Change Requests

   • Traditional: Manual updates to JSON, YAML, scripts, etc.

   • SSoT.me: Update the source rulebook; all downstream files update automatically.

2. Rule Drift

   • Traditional: Rules differ across design docs, game scripts, and test plans.

   • SSoT.me: One rulebook syncs across all targets.

3. Human Error

   • Traditional: Manual updates lead to missed details and inconsistencies.

   • SSoT.me: Automated transformations ensure consistent updates.

4. Update Speed

   • Traditional: Requires developer intervention and multiple approvals.

   • SSoT.me: Designers edit a rulebook (e.g., Airtable), and changes go live instantly.

5. Version Control

   • Traditional: Git tracks files but lacks fine-grained versioning.

   • SSoT.me: Tracks every rule change and allows precise rollbacks.

6. Engine Portability

   • Traditional: Hardcoded logic ties rules to one engine.

   • SSoT.me: Export game logic to Unity, Unreal, or other engines with ease.

How It Works

1. Central Rulebook (Airtable or Baserow Base)

   • Stores all game rules, logic, and event parameters in a single table.

   • Rows define features (e.g., "Power-Up"), and columns specify rules (e.g., name, cost, cooldown).

2. Automatic Sync to Game Files

   • Rulebook changes propagate automatically to game engine files (JSON, YAML, or scripts).

   • No manual copy-pasting.

3. Consistent Downstream Artifacts

   • Game engine files, configuration scripts, and documentation are updated automatically.

4. Version Control & Rollbacks

   • Changes to the rulebook are tracked like "Git for data."

   • Instantly revert to previous rule versions without rolling back the entire project.

Example Use Cases

Rebalancing Power-Ups

• Old Way: Designers request a "damage boost." Developers manually update JSON. QA checks and releases.

• SSoT.me Way: Designers update the "damage" field in the rulebook. Changes propagate to all files instantly.

Seasonal Events & LiveOps

• Old Way: Developers manually create and sync config files.

• SSoT.me Way: Designers add an "Event" row with parameters (start time, rewards, etc.). The system generates all necessary files.

Cross-Engine Portability

• Old Way: Logic must be rewritten for each engine.

• SSoT.me Way: Rules in the rulebook are exported to Unity, Unreal, or Godot formats.

SSoT.me Features

1. Centralized Rulebook

   • Single Source of Truth: Accessible to Design, QA, and Development teams.

   • Syntax-Free: Free from JSON, YAML, or code file constraints.

   • Auto-Export: Outputs rules as JSON, YAML, or C# files.

2. Change Once, Propagate Everywhere

   • Faster Updates: Modify once, reflect everywhere.

   • No Cascade of Errors: Avoid misinterpretation and cascading issues.

3. Automation

   • Full Stack Generation: Automatically generate JSON, YAML, API docs, and UI elements.

   • Rule Syncing: Connect Airtable to Unity, Unreal, or other engines seamlessly.

4. Version Control

   • Data-Level Git: Track every rule change.

   • Instant Rollback: Revert rule changes without affecting the whole project.

SSoT.me vs Traditional Methods

Feature Traditional Method SSoT.me Rule Changes Manual JSON/YAML updates. Changes auto-propagate via rulebook. Version Control Tracks whole files in Git. Tracks every individual rule change. Portability Logic rewritten for each engine. Export logic from one rulebook. LiveOps Requires manual updates and delays. Instant updates to live configurations. Drift Risk High (manual edits prone to errors). Zero (automatic syncing). Tools & Integrations

• Airtable / Baserow: Centralized rulebook storage.

• SSoT.me CLI: Automates rulebook syncs.

• Engine Exporters: Outputs rules for Unity, Unreal, and Godot.

• Git Integration: Tracks every rule change with precision.

Benefits for Gaming Companies

1. Faster Game Updates

   • LiveOps updates in minutes.

   • Designers update one field, and changes reflect immediately.

2. Drift-Free Rule Synchronization

   • Eliminate inconsistencies across design docs, scripts, and QA plans.

   • Unified workflow from one source.

3. Portability Across Engines

   • Export logic for Unity, Unreal, or custom platforms without rewrites.

4. Eliminate Human Error

   • Automation prevents manual update errors.

5. Version Control for Rules

   • Precise rollbacks perfect for A/B testing or rapid iterations.

Closing Thoughts

SSoT.me (pronounced “so Tee me”) is the most effective solution for managing game logic, rule updates, and LiveOps. By centralizing all rules into a syntax-free rulebook, SSoT.me enables faster updates, ensures consistency, and supports future-proof game logic for multiple engines and platforms.