メインコンテンツへスキップ
見出し画像

ソシャゲのサーバーを作る。マスターデータをメモリに載せて配信する(8)

    前回でマスターデータが一式そろいました。

    次回からゲームの実装、と書きましたが、
    その前に下ごしらえを1つやります。

    データベースに入れたマスタを、 サーバーのメモリに載せる話です。

    毎回データベースを引かない

    ゲームのAPIは、とにかくマスタを引きます。

    ステージに挑戦すればステージと敵編成と敵のパラメータ。
    ガチャを回せば排出テーブルとキャラ。
    キャラを強化すればレベルカーブとレアリティ倍率。

    これを毎回SELECTしていると、 1回のAPIで何度もデータベースを往復することになります。

    そこで起動時に全部メモリに載せてしまいます。
    マスタは条件がそろっているので、これができます。

    • 変わらない(運用中に書き換わらない)

    • 全員共通(プレイヤーごとに違わない)

    • 量が知れている(今回は17テーブル、296行)

    基本、マスターデータは運用中は書き換わらないので。
    書き換わる時はメンテで更新とかそういったときです。

    全部読む

    遅延ロードのような作りもありますが、全読み込みにします。
    結局リレーションしまくるので、部分的に読んでおく方が逆に面倒です(笑)

    起動時に全部読みます。

    async function selectAll(table: MasterTableName): Promise<MasterRow[]> {
      const [rows] = await masterPool.query<RowDataPacket[]>(
        `SELECT * FROM \`${table}\` ORDER BY ${TABLE_ORDER[table]}`,
      );
      return rows as MasterRow[];
    }

    テーブル名も並び順もソースの中の定数なので、
    外から渡ってくる値がクエリに混ざることはありません。

    読んだ行を主キーで引けるようにします。

    function indexBy<T>(
      rows: readonly MasterRow[],
      keyOf: (row: T) => number,
    ): Map<number, T> {
      const index = new Map<number, T>();
      for (const row of rows) {
        const typed = row as T;
        index.set(keyOf(typed), typed);
      }
      return index;
    }

    17テーブルぶん、これを回すだけです。

    主キーは数値で統一……したかったのですが、
    2つだけ文字列のものがありました。
    状態異常(code)とゲーム設定(config_key)です。
    ここは Map<string, T> を別に用意しています。

    JOINの代わり

    主キーで引くMapだけだと足りないものがあります。

    ステージの敵編成です。

    |stage_id|sort_no|enemy_id|enemy_level|
    |--------|-------|--------|-----------|
    |1       |0      |1       |1          |
    |1       |1      |2       |1          |
    |2       |0      |1       |1          |

    「ステージ1の敵を全部」という引き方しかしません。
    主キーは(stage_id, sort_no)の複合なので、
    これをMapのキーにしても使い道がない。

    なので親IDで束ねておきます。

    function groupBy<T>(
      rows: readonly MasterRow[],
      keyOf: (row: T) => number,
    ): Map<number, T[]> {
      const groups = new Map<number, T[]>();
      for (const row of rows) {
        const typed = row as T;
        const key = keyOf(typed);
        const bucket = groups.get(key);
        if (bucket === undefined) {
          groups.set(key, [typed]);
        } else {
          bucket.push(typed);
        }
      }
      return groups;
    }

    Map<stage_id, StageEnemy[]> の形になります。

    これ、データベースでやるならJOINです。
    外部キーを張らない方針でやってきましたが、 JOINしない方針でもある。

    プロジェクトや会社のポリシーだと思いますが、
    ゲームでDB設計やっていて外部キーを使ったことはないです(笑)
    SQLの教科書で、そんなんあるんだ、くらいで。

    あと、JOINのコストを取りたくないので基本ゲーム内でのクエリでテーブル結合することはあまりしません。
    分割なんて話が出たらそれはそれは大変ですから(汗)

    ゲーム外のツールや分析するときはリードレプリカからJOINしまくって統計取ったりします(過剰には使わないですよ)

    さて、
    代わりに起動時に1回だけ、メモリの上で束ねておく。
    実行時はキーを引くだけになります。

    SELECTの時点で並べてあるので、 束ねた配列の並びもそのまま正しい順になります。

    スキルの効果、ガチャの排出対象、排出率も同じ形ですね。

    インデックスを作らないもの

    属性相性だけ、どちらにも当てはまりませんでした。

    主キーが(攻撃属性, 防御属性)の2列で、 親IDで束ねる形でもない。

    get_element_affinities(): readonly ElementAffinity[] {
      this.#requireLoaded();
      return this.#rows("element_affinity") as readonly ElementAffinity[];
    }

    9行しかないので、配列のまま返して全走査で引きます。

    インデックスは必要になったら作ればいい、と思っています。
    9行の配列を舐めるコストより、 インデックスが増えることで読みにくくなるコストのほうが高いですね。

    1つだけ置く

    メモリに載せたものは、プロセスの間ずっと生きています。

    Node.jsは起動したプロセスがそのままリクエストを捌くので、
    モジュールに置いた変数は次のリクエストにも残る。

    PHPだとリクエストごとに消えるので、 APCuのような場所に載せる必要があります。
    そのあたりの感覚が違うところですね。

    なので特別な仕組みは要りません。
    クラスを1つ書いて、インスタンスを1つだけ置きます。

    class MasterStore {
      #loaded = false;
      #hero: Map<number, Hero> = new Map();
      #stageEnemy: Map<number, StageEnemy[]> = new Map();
      // ...
    
      async load(): Promise<void> { /* ... */ }
    
      get_hero(id: number): Hero | undefined {
        this.#requireLoaded();
        return this.#hero.get(id);
      }
    
      get_stage_enemies(stageId: number): StageEnemy[] {
        this.#requireLoaded();
        return this.#stageEnemy.get(stageId) ?? [];
      }
    }
    
    export const master = new MasterStore();

    importした先はどこでも同じインスタンスを見ます。

    Mapはプライベートフィールド(#)に入れて、 外からはメソッド経由でしか触れないようにしています。
    読み込み前に呼ばれたら例外を投げる、というのも入れました。

    起動時に読めなかったら

    起動時にデータベースが落ちていたらどうするか。

    サーバーを起動させません(当然ですが)

    マスタが無い状態で立ち上がっても、
    どのAPIも動かないので意味がないですね。
    本来は、例えばGitなどに収める際にコミット時かプッシュ時にバリデーションするのがいいかと思います。
    結構エラーがある状態でマージされてサーバ起動して気付くというパターンが多いです(マジで)

    止めた状態で起動するとこうなります。

    [master] loading...
    [master] 読み込みに失敗した。起動を中止する
    Error: getaddrinfo ENOTFOUND db
    exit=1

    リッスンまで進んでいません。

    正常時はこうです。

    [master] loading...
    [master] rarity 4 / hero 12 / skill 28 / skill_effect 10 / status_effect 9 /
    hero_level_curve 60 / player_level_curve 99 / element_affinity 9 / enemy 10 /
    stage 5 / stage_enemy 14 / gacha_pool 1 / gacha_pool_entry 12 /
    gacha_pool_rate 4 / item 2 / shop 2 / game_config 15
    [master] 17 tables, 296 rows, 212ms
    

    読み込んだ件数を出しておくと、 流し忘れたテーブルがあったときにすぐ分かります。
    0件のテーブルが混じっていたら何かおかしい、と。

    クライアントにも渡す

    ここからが今回の本題です。

    このマスタ、サーバーだけで持っていても足りません。
    クライアントもキャラの名前やステータスを表示するので。

    やり方は2つあります。

    • APIのレスポンスに毎回マスタの中身を詰めて返す

    • クライアントにもマスタを丸ごと渡して、ローカルで引かせる

    2つあるとはいえ、実質毎回送るのはあり得ないので、タイトル画面表示時などに1回通信でもらってキャッシングですね。

    今回ブラウザベースなのでどうしようかと思ったところでした。
    ネイティブアプリなら、マスターもアセットもCDNに置いて、
    クライアントはそこから取ってくるだけでいいところがブラウザベースとなるとどこでさせようかなどなど。

    今回のゲームではゲーム開発にスポットを当てているので
    ゲームサーバから返すという形にしています。
    一口にCDNといっても、選定やアカウント作成、費用、仕組みの理解などそれだけで一冊の本になるくらいなので(なるはず)

    ついでに、CDNに置くと認証が効かせにくいというのがあります。
    URLが分かれば誰でも取れてしまう。
    署名付きURLで期限を設けたり、URLを推測しにくいやつに変えるとか、いろいろありますがやることが増えます(笑)

    公開するものを選ぶ

    丸ごと渡す、と書きましたが、 渡したくないものが混ざっています。

    除外は3段階にしました。

    type DeliveryRule = {
      /** テーブルごと除外。true なら配信JSONにキーごと現れない */
      skip?: boolean;
      /** 列ごと除外。ここに挙げた列は行から落とす */
      hiddenColumns?: readonly string[];
      /** 行ごと除外。true を返した行だけ配信する */
      allowRow?: (row: MasterRow) => boolean;
    };

    列を落とす

    敵は名前と見た目は要るけれど、 HPや攻撃力を渡す必要はありません。
    使ってくる技も伏せておきます。

    enemy: {
      hiddenColumns: ["base_hp", "base_atk", "base_def", "base_spd", "skill_id"],
    },
    stage_enemy: { hiddenColumns: ["enemy_level"] },

    戦闘の計算はサーバーがやるので、 クライアントが敵のステータスを知る理由がない。

    結果はこうなります。

    { "id": 1, "name": "スライム", "element": 2, "role": 1, "is_boss": 0 }

    行を落とす

    game_configは1つのテーブルの中に、 出していいものと悪いものが混ざっています。

    deck_size            4     -> 出す(編成画面で使う)
    elite_chance         0.25  -> 出さない(強敵の出現率)
    healer_ai_threshold  0.6   -> 出さない(AIの内部しきい値)
    def_reduction        0.5   -> 出さない(ダメージ計算の係数)

    デッキが4人なのはUIの都合で必要ですが、 強敵の出現率をクライアントが知る必要はありません。

    15キーのうち、いま出しているのは1つだけです。

    全部渡すと、ゲームの中身が入ったファイルを URLひとつで公開しているのと同じになります。
    ブラウザゲームなら、開発者ツールで中身は丸見えですし。

    逆に、隠しても意味がないものは素直に出します。
    属性相性は画面に出す情報ですし、 ガチャの排出率は表示する義務があります。
    というより、見せるために渡します。

    テーブルまるごと出さない枠も作りましたが、
    今回は該当がありませんでした。
    内部計算専用のマスタが増えたら使うことになるはずです。

    判断が1ファイルに集まっているのが大事だと思っています。
    「これはクライアントに出ているんだっけ」を、
    このファイルだけ見れば答えられる状態にしておく。

    ログイン前には渡さない

    配信APIには認証を通します。

    以前やったトークンを、 ここで初めて使うことになりますね。

    誰でも叩ける状態だと、 アカウントすら作らずにマスタを持っていけます。
    アカウントを作らせたところで大した壁ではありませんが、 素通りできる状態とは意味が違います。

    圧縮も先にやっておく

    配信するJSONは、起動時に組み立てて持っておきます。
    リクエストのたびに作り直す理由がないので。

    同じ理由で、gzipで固めたものも起動時に1回だけ作ります。

    const json = Buffer.from(JSON.stringify(body), "utf8");
    const gzip = gzipSync(json, { level: MASTER_GZIP_LEVEL });
    cached = { json, gzip };

    ハンドラ側は、持っているバッファをそのまま返すだけです。

    const payload = deliveryPayload();
    const useGzip = acceptsGzip(req);
    const body = useGzip ? payload.gzip : payload.json;

    マスタが変わらないので、 組み立ても圧縮も1回だけ。

    動かす

    トークンなしで叩きます。

    $ curl -i http://localhost:3000/master
    HTTP/1.1 401 Unauthorized
    
    {"error":{"code":"UNAUTHORIZED","message":"トークンが無効か、期限切れ"}}

    弾かれました。

    サインアップしてトークンをもらって、 付けて叩き直します。

    $ curl -i -H "Authorization: Bearer $TOKEN" http://localhost:3000/master
    HTTP/1.1 200 OK
    Content-Type: application/json; charset=utf-8
    Content-Length: 20669
    Vary: Accept-Encoding

    返りました。

    圧縮ありも見てみます。

    $ curl -i -H "Authorization: Bearer $TOKEN" --compressed http://localhost:3000/master
    HTTP/1.1 200 OK
    Content-Length: 3990
    Content-Encoding: gzip
    Vary: Accept-Encoding

    20.2KBが3.9KBになりました。

    中身も見ておきます。

    $ curl -s -H "Authorization: Bearer $TOKEN" \
      http://localhost:3000/master | jq '.enemy[0], .game_config'
    {
      "id": 1,
      "name": "スライム",
      "element": 2,
      "role": 1,
      "is_boss": 0
    }
    [
      {
        "config_key": "deck_size",
        "value_num": "4.0000",
        "description": "デッキ人数"
      }
    ]

    敵からステータスが落ちていて、 設定は15キーのうち1つだけになっています。

    意外と小さくなりました。
    キャラ12体、ステージ5個の規模なので当然ではありますが、
    画像1枚のほうがずっと重いですね。

    キャラが増えればサイズも増えますが、 そのときは一度受け取ったものをクライアントに保存させる形になります。

    今回はここまで

    • マスタ17テーブル296行を、起動時にメモリへ載せた

    • 親IDで束ねて、JOINの代わりにした

    • クライアントへの配信APIを作った。ただし全部は出さない

    • 認証を通した。ログイン前には渡さない

    • 20.2KB、gzipで3.9KB

    次回からクライアントに入ります。

    以前プロトタイプとして作ったヒーローコレクションが
    Vite + React + TypeScript なので、それをそのまま使います。
    選んだのは私ではなくAIですが、 2026年時点でも標準的な組み合わせなのでこれでいきます。

    タイトル画面を出して、 サインアップして、 このマスタを受け取るところまでやろうと思います。

    【最後まで読んでいただきありがとうございます!】 面白かったと感じた方は、ぜひ「スキ」と「フォロー」をお願いします!

    コード

    今回の記事で作ったコードです、興味のある方はどうぞ。

    index.ts

    import { createServer } from "node:http";
    import type { IncomingMessage, ServerResponse } from "node:http";
    import { handlePrepare, handleSignup } from "./routes/auth.ts";
    import { handleProfile } from "./routes/user.ts";
    import { handleMaster } from "./routes/master.ts";
    import { master } from "./master/store.ts";
    import { buildDeliveryPayload } from "./master/delivery.ts";
    import { sendError } from "./http.ts";
    
    type Handler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
    
    // ルーティングは「メソッド + パス」の完全一致で引く。
    // パスにパラメータが必要になるまでは、これで足りる。
    const routes: Record<string, Handler> = {
      "POST /auth/prepare": handlePrepare,
      "POST /auth/signup": handleSignup,
      "GET /user/profile": handleProfile,
      "GET /master": handleMaster,
    };
    
    const port = Number(process.env.PORT ?? 3000);
    
    const server = createServer((req, res) => {
      const path = (req.url ?? "/").split("?")[0];
      const handler = routes[`${req.method} ${path}`];
    
      if (handler === undefined) {
        sendError(res, 404, "NOT_FOUND", `${req.method} ${path} は存在しない`);
        return;
      }
    
      // ハンドラ内で投げられた例外はここで拾う。中身はクライアントに返さない
      handler(req, res).catch((error: unknown) => {
        console.error(error);
        if (res.headersSent) {
          res.end();
          return;
        }
        sendError(res, 500, "INTERNAL_ERROR", "サーバー内部エラー");
      });
    });
    
    // マスタはリッスンを開始する前に読み込む。読み終わるまでリクエストは受けない。
    // ここで失敗したらサーバを起動させない。マスタ無しで動かしても正しい応答は返せない
    try {
      await master.load();
      buildDeliveryPayload();
    } catch (error) {
      console.error("[master] 読み込みに失敗した。起動を中止する");
      console.error(error);
      process.exit(1);
    }
    
    server.listen(port, () => {
      console.log(`listening on http://localhost:${port}`);
    });

    store.ts

    import type { RowDataPacket } from "mysql2/promise";
    import { masterPool } from "../db.ts";
    import { MASTER_TABLES } from "./types.ts";
    import type {
      ElementAffinity,
      Enemy,
      GachaPool,
      GachaPoolEntry,
      GachaPoolRate,
      GameConfig,
      Hero,
      HeroLevelCurve,
      Item,
      MasterRow,
      MasterTableName,
      PlayerLevelCurve,
      Rarity,
      Shop,
      Skill,
      SkillEffect,
      Stage,
      StageEnemy,
      StatusEffect,
    } from "./types.ts";
    
    // マスタは起動時に全件メモリへ載せる。実行中にDBを引きに行くことはない。
    // 遅延ロードにはしない。読み終わるまでリクエストを受けない。
    
    /**
     * テーブルごとの SELECT の並び順。
     * sort_no を持つテーブルはその昇順、それ以外は主キー順で安定させる。
     */
    const TABLE_ORDER: Record<MasterTableName, string> = {
      rarity: "`sort_no`",
      hero: "`sort_no`",
      skill: "`id`",
      skill_effect: "`skill_id`, `seq`",
      status_effect: "`code`",
      hero_level_curve: "`level`",
      player_level_curve: "`player_lv`",
      element_affinity: "`attacker_element`, `defender_element`",
      enemy: "`id`",
      stage: "`sort_no`",
      stage_enemy: "`stage_id`, `sort_no`",
      gacha_pool: "`id`",
      gacha_pool_entry: "`pool_id`, `hero_id`",
      gacha_pool_rate: "`pool_id`, `rarity_id`",
      item: "`sort_no`",
      shop: "`sort_no`",
      game_config: "`config_key`",
    };
    
    /**
     * 1テーブルを全件読む。
     * テーブル名も並び順もこのファイルの定数で、クライアントの入力は混ざらない。
     */
    async function selectAll(table: MasterTableName): Promise<MasterRow[]> {
      const [rows] = await masterPool.query<RowDataPacket[]>(
        `SELECT * FROM \`${table}\` ORDER BY ${TABLE_ORDER[table]}`,
      );
      return rows as MasterRow[];
    }
    
    /** 主キーで引くMapを作る */
    function indexBy<T>(rows: readonly MasterRow[], keyOf: (row: T) => number): Map<number, T> {
      const index = new Map<number, T>();
      for (const row of rows) {
        const typed = row as T;
        index.set(keyOf(typed), typed);
      }
      return index;
    }
    
    /** 文字列の主キーで引くMapを作る。code / config_key のように ID が数値でないテーブル用 */
    function indexByString<T>(
      rows: readonly MasterRow[],
      keyOf: (row: T) => string,
    ): Map<string, T> {
      const index = new Map<string, T>();
      for (const row of rows) {
        const typed = row as T;
        index.set(keyOf(typed), typed);
      }
      return index;
    }
    
    /**
     * 親IDで束ねたMapを作る。
     * 元の配列の並びをそのまま保つので、SELECT の ORDER BY がそのまま各配列の並びになる。
     */
    function groupBy<T>(rows: readonly MasterRow[], keyOf: (row: T) => number): Map<number, T[]> {
      const groups = new Map<number, T[]>();
      for (const row of rows) {
        const typed = row as T;
        const key = keyOf(typed);
        const bucket = groups.get(key);
        if (bucket === undefined) {
          groups.set(key, [typed]);
        } else {
          bucket.push(typed);
        }
      }
      return groups;
    }
    
    /**
     * 読み込んだマスタの置き場。
     * 中身は外から書き換えられないよう private フィールドに持ち、getter 経由でだけ参照させる。
     */
    class MasterStore {
      #loaded = false;
      #tables: Map<MasterTableName, readonly MasterRow[]> = new Map();
    
      // 主キーで引くインデックス
      #rarity: Map<number, Rarity> = new Map();
      #hero: Map<number, Hero> = new Map();
      #skill: Map<number, Skill> = new Map();
      #statusEffect: Map<string, StatusEffect> = new Map();
      #heroLevelCurve: Map<number, HeroLevelCurve> = new Map();
      #playerLevelCurve: Map<number, PlayerLevelCurve> = new Map();
      #enemy: Map<number, Enemy> = new Map();
      #stage: Map<number, Stage> = new Map();
      #gachaPool: Map<number, GachaPool> = new Map();
      #item: Map<number, Item> = new Map();
      #shop: Map<number, Shop> = new Map();
      #gameConfig: Map<string, GameConfig> = new Map();
    
      // 親IDで束ねたインデックス
      #skillEffect: Map<number, SkillEffect[]> = new Map();
      #stageEnemy: Map<number, StageEnemy[]> = new Map();
      #gachaPoolEntry: Map<number, GachaPoolEntry[]> = new Map();
      #gachaPoolRate: Map<number, GachaPoolRate[]> = new Map();
    
      /**
       * 全テーブルを読み込む。リッスンを開始する前に1度だけ呼ぶ。
       * 失敗したら例外を投げる。ここで落ちたらサーバを起動させてはいけない。
       */
      async load(): Promise<void> {
        console.log("[master] loading...");
        const startedAt = Date.now();
    
        for (const table of MASTER_TABLES) {
          this.#tables.set(table, await selectAll(table));
        }
    
        this.#rarity = indexBy<Rarity>(this.#rows("rarity"), (row) => Number(row.id));
        this.#hero = indexBy<Hero>(this.#rows("hero"), (row) => Number(row.id));
        this.#skill = indexBy<Skill>(this.#rows("skill"), (row) => Number(row.id));
        this.#statusEffect = indexByString<StatusEffect>(
          this.#rows("status_effect"),
          (row) => row.code,
        );
        this.#heroLevelCurve = indexBy<HeroLevelCurve>(
          this.#rows("hero_level_curve"),
          (row) => Number(row.level),
        );
        this.#playerLevelCurve = indexBy<PlayerLevelCurve>(
          this.#rows("player_level_curve"),
          (row) => Number(row.player_lv),
        );
        this.#enemy = indexBy<Enemy>(this.#rows("enemy"), (row) => Number(row.id));
        this.#stage = indexBy<Stage>(this.#rows("stage"), (row) => Number(row.id));
        this.#gachaPool = indexBy<GachaPool>(this.#rows("gacha_pool"), (row) => Number(row.id));
        this.#item = indexBy<Item>(this.#rows("item"), (row) => Number(row.id));
        this.#shop = indexBy<Shop>(this.#rows("shop"), (row) => Number(row.id));
        this.#gameConfig = indexByString<GameConfig>(
          this.#rows("game_config"),
          (row) => row.config_key,
        );
    
        this.#skillEffect = groupBy<SkillEffect>(
          this.#rows("skill_effect"),
          (row) => Number(row.skill_id),
        );
        this.#stageEnemy = groupBy<StageEnemy>(
          this.#rows("stage_enemy"),
          (row) => Number(row.stage_id),
        );
        this.#gachaPoolEntry = groupBy<GachaPoolEntry>(
          this.#rows("gacha_pool_entry"),
          (row) => Number(row.pool_id),
        );
        this.#gachaPoolRate = groupBy<GachaPoolRate>(
          this.#rows("gacha_pool_rate"),
          (row) => Number(row.pool_id),
        );
    
        this.#loaded = true;
        this.#logSummary(Date.now() - startedAt);
      }
    
      #logSummary(elapsedMs: number): void {
        let total = 0;
        const counts: string[] = [];
        for (const table of MASTER_TABLES) {
          const count = this.#rows(table).length;
          total += count;
          counts.push(`${table} ${count}`);
        }
        console.log(`[master] ${counts.join(" / ")}`);
        console.log(
          `[master] ${MASTER_TABLES.length} tables, ${total} rows, ${elapsedMs}ms`,
        );
      }
    
      /** 読み込み済みの行をそのまま取る。読み込み処理の内部でだけ使う */
      #rows(table: MasterTableName): readonly MasterRow[] {
        return this.#tables.get(table) ?? [];
      }
    
      #requireLoaded(): void {
        if (!this.#loaded) {
          throw new Error("マスタがまだ読み込まれていない");
        }
      }
    
      /** 1テーブルの全行。配信JSONの組み立てのように、列を決め打ちしない用途で使う */
      get_table(table: MasterTableName): readonly MasterRow[] {
        this.#requireLoaded();
        return this.#rows(table);
      }
    
      get_rarity(id: number): Rarity | undefined {
        this.#requireLoaded();
        return this.#rarity.get(id);
      }
    
      get_hero(id: number): Hero | undefined {
        this.#requireLoaded();
        return this.#hero.get(id);
      }
    
      get_skill(id: number): Skill | undefined {
        this.#requireLoaded();
        return this.#skill.get(id);
      }
    
      get_status_effect(code: string): StatusEffect | undefined {
        this.#requireLoaded();
        return this.#statusEffect.get(code);
      }
    
      get_hero_level_curve(level: number): HeroLevelCurve | undefined {
        this.#requireLoaded();
        return this.#heroLevelCurve.get(level);
      }
    
      get_player_level_curve(playerLv: number): PlayerLevelCurve | undefined {
        this.#requireLoaded();
        return this.#playerLevelCurve.get(playerLv);
      }
    
      get_enemy(id: number): Enemy | undefined {
        this.#requireLoaded();
        return this.#enemy.get(id);
      }
    
      get_stage(id: number): Stage | undefined {
        this.#requireLoaded();
        return this.#stage.get(id);
      }
    
      get_gacha_pool(id: number): GachaPool | undefined {
        this.#requireLoaded();
        return this.#gachaPool.get(id);
      }
    
      get_item(id: number): Item | undefined {
        this.#requireLoaded();
        return this.#item.get(id);
      }
    
      get_shop(id: number): Shop | undefined {
        this.#requireLoaded();
        return this.#shop.get(id);
      }
    
      get_game_config(key: string): GameConfig | undefined {
        this.#requireLoaded();
        return this.#gameConfig.get(key);
      }
    
      get_skill_effects(skillId: number): SkillEffect[] {
        this.#requireLoaded();
        return this.#skillEffect.get(skillId) ?? [];
      }
    
      get_stage_enemies(stageId: number): StageEnemy[] {
        this.#requireLoaded();
        return this.#stageEnemy.get(stageId) ?? [];
      }
    
      get_gacha_pool_entries(poolId: number): GachaPoolEntry[] {
        this.#requireLoaded();
        return this.#gachaPoolEntry.get(poolId) ?? [];
      }
    
      get_gacha_pool_rates(poolId: number): GachaPoolRate[] {
        this.#requireLoaded();
        return this.#gachaPoolRate.get(poolId) ?? [];
      }
    
      /**
       * 属性相性は主キーが2列で、親IDで束ねる形でもない。
       * 件数が少ないので、インデックスは作らず全走査で引く。
       */
      get_element_affinities(): readonly ElementAffinity[] {
        this.#requireLoaded();
        return this.#rows("element_affinity") as readonly ElementAffinity[];
      }
    }
    
    /** マスタはプロセスに1つ。読み込みも参照もこのインスタンス経由で行う */
    export const master = new MasterStore();

    delivery.ts

    import { gzipSync } from "node:zlib";
    import { master } from "./store.ts";
    import { MASTER_TABLES } from "./types.ts";
    import type { MasterRow, MasterTableName } from "./types.ts";
    import { MASTER_GZIP_LEVEL, MASTER_VERSION } from "../constants.ts";
    
    // クライアントに何を配信して何を配信しないかは、このファイルだけを見れば分かるようにする。
    // 増減はこのファイルの DELIVERY_RULES を触るだけで済ませる。
    
    type DeliveryRule = {
      /** テーブルごと除外。true なら配信JSONにキーごと現れない */
      skip?: boolean;
      /** 列ごと除外。ここに挙げた列は行から落とす */
      hiddenColumns?: readonly string[];
      /** 行ごと除外。true を返した行だけ配信する */
      allowRow?: (row: MasterRow) => boolean;
    };
    
    /** game_config のうちクライアントに見せるキー。増やすときはここに足す */
    const DELIVERED_CONFIG_KEYS: readonly string[] = ["deck_size"];
    
    const DELIVERY_RULES: Record<MasterTableName, DeliveryRule> = {
      rarity: {},
      hero: {},
      skill: {},
      skill_effect: {},
      status_effect: {},
      // 強化画面で必要なので配信する
      hero_level_curve: {},
      player_level_curve: {},
      // 相性は画面に出すので配信する
      element_affinity: {},
      // 敵のステータスはサーバだけが持つ。配信するのは id / name / element / role / is_boss だけ
      enemy: {
        hiddenColumns: ["base_hp", "base_atk", "base_def", "base_spd", "skill_id"],
      },
      stage: {},
      // 敵のレベルはバトル判定用。クライアントには渡さない
      stage_enemy: { hiddenColumns: ["enemy_level"] },
      gacha_pool: {},
      gacha_pool_entry: {},
      // 排出率は表示するので配信する
      gacha_pool_rate: {},
      item: {},
      shop: {},
      // 設定値は総取りさせない。挙げたキーだけ配信する
      game_config: {
        allowRow: (row) => DELIVERED_CONFIG_KEYS.includes(String(row.config_key)),
      },
    };
    
    export type DeliveryPayload = {
      /** 非圧縮のJSON */
      json: Buffer;
      /** 上をgzipしたもの */
      gzip: Buffer;
    };
    
    // 組み立て済みの配信データ。起動時に1度入れたら、以後は使い回すだけ
    let cached: DeliveryPayload | null = null;
    
    /** 1行から配信しない列を落とす */
    function omitColumns(row: MasterRow, hiddenColumns: readonly string[]): MasterRow {
      const delivered: MasterRow = {};
      for (const [column, value] of Object.entries(row)) {
        if (hiddenColumns.includes(column)) continue;
        delivered[column] = value;
      }
      return delivered;
    }
    
    function applyRule(rows: readonly MasterRow[], rule: DeliveryRule): MasterRow[] {
      const allowRow = rule.allowRow;
      const hiddenColumns = rule.hiddenColumns;
    
      const filtered = allowRow === undefined ? rows.slice() : rows.filter((row) => allowRow(row));
      if (hiddenColumns === undefined) return filtered;
      return filtered.map((row) => omitColumns(row, hiddenColumns));
    }
    
    /** バイト数を KB 表記にする。起動ログ用 */
    function formatKb(bytes: number): string {
      return `${(bytes / 1024).toFixed(1)}KB`;
    }
    
    /**
     * 配信用のJSONとgzipを組み立てる。マスタの読み込み後、リッスン開始前に1度だけ呼ぶ。
     * リクエストごとには呼ばない。中身は起動中ずっと変わらないため
     */
    export function buildDeliveryPayload(): DeliveryPayload {
      const body: Record<string, unknown> = { version: MASTER_VERSION };
    
      for (const table of MASTER_TABLES) {
        const rule = DELIVERY_RULES[table];
        if (rule.skip === true) continue;
        body[table] = applyRule(master.get_table(table), rule);
      }
    
      const json = Buffer.from(JSON.stringify(body), "utf8");
      const gzip = gzipSync(json, { level: MASTER_GZIP_LEVEL });
    
      console.log(
        `[master] delivery payload ${formatKb(json.length)} -> ${formatKb(gzip.length)} (gzip)`,
      );
    
      cached = { json, gzip };
      return cached;
    }
    
    /** 組み立て済みの配信データを返す。起動時に組み立てていなければ例外 */
    export function deliveryPayload(): DeliveryPayload {
      if (cached === null) {
        throw new Error("配信用データがまだ組み立てられていない");
      }
      return cached;
    }

    types.ts

    // api_game_master の各テーブルの行の型。
    //
    // mysql2 の返り値の型に合わせてある。特に注意するのは次の2つ。
    //   - DECIMAL は文字列で返る。数値に直すと桁が落ちるので string のまま持つ
    //   - TINYINT(1) は真偽値ではなく 0 / 1 の数値で返る
    
    export type Rarity = {
      id: number;
      code: string;
      name: string;
      stat_multiplier: string;
      sort_no: number;
    };
    
    export type Hero = {
      id: number;
      name: string;
      rarity_id: number;
      role: number;
      element: number;
      base_hp: number;
      base_atk: number;
      base_def: number;
      base_spd: number;
      normal_skill_id: number;
      ultimate_skill_id: number;
      max_level: number;
      is_playable: number;
      sort_no: number;
    };
    
    export type Skill = {
      id: number;
      name: string;
      kind: number;
      target: number;
      power: string;
      damage_type: number;
      is_ultimate: number;
    };
    
    export type SkillEffect = {
      skill_id: number;
      seq: number;
      effect_code: string;
      value: string;
      duration: number;
    };
    
    export type StatusEffect = {
      code: string;
      name: string;
      value_kind: number;
      is_debuff: number;
      icon_key: string;
    };
    
    export type HeroLevelCurve = {
      level: number;
      need_materials: number;
      need_gold: number;
      stat_multiplier: string;
    };
    
    export type PlayerLevelCurve = {
      player_lv: number;
      need_exp: number;
      stamina_max: number;
    };
    
    export type ElementAffinity = {
      attacker_element: number;
      defender_element: number;
      multiplier: string;
    };
    
    export type Enemy = {
      id: number;
      name: string;
      element: number;
      role: number;
      base_hp: number;
      base_atk: number;
      base_def: number;
      base_spd: number;
      skill_id: number;
      is_boss: number;
    };
    
    export type Stage = {
      id: number;
      name: string;
      chapter_no: number;
      stage_no: number;
      is_boss: number;
      stamina_cost: number;
      reward_gold: number;
      reward_exp: number;
      reward_materials: number;
      sort_no: number;
    };
    
    export type StageEnemy = {
      stage_id: number;
      sort_no: number;
      enemy_id: number;
      enemy_level: number;
    };
    
    export type GachaPool = {
      id: number;
      name: string;
      cost_single: number;
      cost_ten: number;
      ceiling_count: number;
    };
    
    export type GachaPoolEntry = {
      pool_id: number;
      hero_id: number;
      weight: number;
      is_pickup: number;
    };
    
    export type GachaPoolRate = {
      pool_id: number;
      rarity_id: number;
      rate_permille: number;
    };
    
    export type Item = {
      id: number;
      name: string;
      kind: number;
      value: number;
      price: number;
      sort_no: number;
    };
    
    export type Shop = {
      id: number;
      item_id: number;
      amount: number;
      price: number;
      daily_limit: number;
      sort_no: number;
    };
    
    export type GameConfig = {
      config_key: string;
      value_num: string;
      description: string;
    };
    
    /**
     * 読み込むテーブルの一覧。読み込む順・起動ログに出す順・配信JSONに並ぶ順を兼ねる。
     * テーブルが増えたらここに足す。
     */
    export const MASTER_TABLES = [
      "rarity",
      "hero",
      "skill",
      "skill_effect",
      "status_effect",
      "hero_level_curve",
      "player_level_curve",
      "element_affinity",
      "enemy",
      "stage",
      "stage_enemy",
      "gacha_pool",
      "gacha_pool_entry",
      "gacha_pool_rate",
      "item",
      "shop",
      "game_config",
    ] as const;
    
    export type MasterTableName = (typeof MASTER_TABLES)[number];
    
    /** 列名を決め打ちせずに扱うときの行の型。配信JSONの組み立てで使う */
    export type MasterRow = Record<string, unknown>;

    routes/master.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import { authenticate } from "../auth/session.ts";
    import { deliveryPayload } from "../master/delivery.ts";
    import { sendError } from "../http.ts";
    
    /** Accept-Encoding に gzip が含まれているか */
    function acceptsGzip(req: IncomingMessage): boolean {
      const header = req.headers["accept-encoding"];
      if (typeof header !== "string") return false;
      return header.split(",").some((encoding) => encoding.trim().split(";")[0] === "gzip");
    }
    
    /**
     * GET /master — マスタを配信する。
     *
     * 返すのは起動時に組み立てて持っているバッファそのもの。
     * ここでJSON化も圧縮もしない
     */
    export async function handleMaster(
      req: IncomingMessage,
      res: ServerResponse,
    ): Promise<void> {
      const userId = await authenticate(req);
      if (userId === null) {
        sendError(res, 401, "UNAUTHORIZED", "トークンが無効か、期限切れ");
        return;
      }
    
      const payload = deliveryPayload();
      const useGzip = acceptsGzip(req);
      const body = useGzip ? payload.gzip : payload.json;
    
      res.writeHead(200, {
        "Content-Type": "application/json; charset=utf-8",
        "Content-Length": body.length,
        // 同じURLで中身の符号化が変わるので、キャッシュする側に条件を伝える
        Vary: "Accept-Encoding",
        ...(useGzip ? { "Content-Encoding": "gzip" } : {}),
      });
      res.end(body);
    }


     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ