Architecture

Every piece of static game data flows through TableDataManager, a MonoBehaviour singleton accessed via get_Instance(). It holds 60+ dictionary and list fields spanning every game system — ships, skills, admirals, equipment, stages, bosses, waves, buildings, gemstones, and more.

On startup the game decrypts .bytes files (AES-128-CBC, key derived from "tempbreadplugin"), deserializes the contents, and populates these dictionaries. Our extraction reads them directly from memory, bypassing encryption entirely.

Identity

Singleton Pattern

The singleton is a standard Unity MonoBehaviour pattern. The class exposes a static get_Instance() property that returns the single live instance. All game systems reference this instance to look up data by ID at runtime.

// Pseudo-C# from IL2CPP dump
public class TableDataManager : MonoBehaviour
{
    public static TableDataManager get_Instance();

    // 60+ dictionaries, e.g.:
    public Dictionary<int, GeneralShipTable> ship_dict;
    public Dictionary<int, GeneralSkillTable> skill_dict;
    public Dictionary<int, Dictionary<int, GeneralAdmiralTable>> admiral_dict;
    public Dictionary<int, GeneralItemTable> item_dict;
    public Dictionary<int, GeneralStageTable> stage_dict;
    public Dictionary<StageType, Dictionary<int, GeneralContentsBossTable>> boss_dict;
    public Dictionary<int, List<GeneralWaveTable>> wave_dict;
    public Dictionary<int, GeneralBuildingTable> building_map;
    public Dictionary<int, GeneralGemstoneTable> gemstone_dict;
    // ... and many more
}

Data Loading Pipeline

The extraction tool (extract_game_data.ts) reads 12 data tables plus 28 enum types from the running game process. A Python launcher (extract_game_data.py) orchestrates the Frida session and splits the result into per-table JSON files under data/game_reference/v1.1.79/.

Extraction Method

We use Frida with the frida-il2cpp-bridge library to attach to the running game process. The bridge resolves IL2CPP class metadata at runtime, giving us access to every field on every object instance without needing to reverse-engineer memory offsets manually.

// Simplified extraction flow (TypeScript / frida-il2cpp-bridge)
const Il2Cpp = await import("frida-il2cpp-bridge");
const domain = Il2Cpp.Domain.reference;
const assembly = domain.assembly("Assembly-CSharp");
const TDM = assembly.image.class("TableDataManager");
const instance = TDM.method("get_Instance").invoke();

// Read a dictionary field
const shipDict = instance.field("ship_dict").value;
// Iterate entries and extract struct fields...

The following are the primary dictionary fields on TableDataManager that we extract. Each dictionary maps an integer ID (or composite key) to a game data struct.

Extracted Tables

Additional High-Value Tables (Not Yet Extracted)

TableDataManager has 60+ dictionary fields. We currently extract 12. These are the highest-priority candidates for future extraction passes:

The game's static data files use AES-128-CBC encryption. The key is derived from the string "tempbreadplugin". This encryption protects the data at rest (on disk and in the APK), but once the game loads and initializes, the decrypted data lives in plain memory as native C# objects.

// Data loading sequence (conceptual)
byte[] encrypted = LoadAssetBundle("table_data.bytes");
byte[] key = DeriveKey("tempbreadplugin");       // AES key derivation
byte[] decrypted = AES_CBC_Decrypt(encrypted, key);
TableData parsed = Deserialize(decrypted);       // Custom binary format
TableDataManager.Instance.ship_dict = BuildDict(parsed.ships);

The game is built with Unity 2022.3.21f1 using the IL2CPP scripting backend. This means all C# game code is compiled to C++ and then to native ARM64 machine code. The resulting binary is libil2cpp.so at 79.6 MB.

IL2CPP Structure

IL2CPP preserves full type metadata in global-metadata.dat. This is what enables tools like Il2CppDumper to produce a complete C# class dump, and what frida-il2cpp-bridge uses at runtime to resolve classes, fields, and methods by name rather than by raw offset.

These are the most important classes for data extraction and game analysis.

In IL2CPP, there is a critical distinction between value types (structs) and reference types (classes). This affects how we read data from memory.