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

ソシャゲのサーバーを作る。ガチャを回す(12)

    前回はホーム画面まで繋ぎました。

    中央は「まだ仲間がいません」のままでしたね。
    今回はそこを埋めます。ガチャです。

    抽選はサーバでやる

    プロトのガチャは、画面側で抽選していました。

    ボタンを押したらその場で乱数を振って、
    出たキャラを手持ちに足す。
    オフライン版なので、それで何も困りません。

    サーバがあるなら、ここは真っ先にサーバへ移すところです。

    クライアントの中身は、書き換えられる前提で考えます。
    抽選をクライアントに置いたままだと、
    「出た結果」をサーバが信じるしかなくなるんですよね。

    なのでクライアントが送るのは、これだけにしました。

    { "pool_id": 1, "count": 10 }

    どのガチャを何回引くか。
    値段も、何が出たかも、決めるのは全部サーバです。

    確率はマスタに書いてある

    ガチャのマスタは7本目で作ってあります。

    使うのは3つです。

    gacha_pool        ガチャそのもの。単発と10連の値段
    gacha_pool_rate   レアリティごとの確率
    gacha_pool_entry  そのガチャから出るヒーロー

    確率はこうなっています。

    | レアリティ | 確率 |
    | SSR | 2%  |
    | SR  | 5%  |
    | R   | 25% |
    | N   | 68% |

    マスタには `20` / `50` / `250` / `680` と、千分率の整数で入れてあります。
    小数で持たないのは、クライアントと計算がずれないようにするためですね。

    抽選は2段階です。

    1. 0〜999 の乱数で、レアリティを決める
    2. そのレアリティのヒーローの中から、1体決める

    いきなりヒーロー12体から1体を引く形にもできます。
    ただそうすると、表示している確率とマスタの数字が一致しなくなるんですよね。

    ガチャの画面には「SSR 2%」と出します。
    レアリティから引く形なら、その2%がマスタにそのまま書いてある。
    ヒーローを1体増やしても、SSRの確率は2%のまま変わりません。

    2段目の抽選には `weight` という重みを使っています。
    いまは全員1なので、SSR 2体なら1体あたり1%ですね。
    ピックアップを作るときに、ここを触ることになります。

    マスタが壊れていたら起動しない

    確率の合計が1000になっていない。
    確率はあるのに、そのレアリティのヒーローが1体もいない。

    こういうマスタで動かすと、抽選の途中でおかしなことになります。

    なので起動時に検証して、駄目なら起動そのものを止めることにしました。
    8本目でマスタの読み込みに失敗したら起動しない、としたのと同じ考え方です。

    ついでに、レアリティごとのヒーロー一覧もここで作っておきます。
    リクエストのたびにマスタを絞り込まなくて済むので。

    乱数

    乱数は `node:crypto` の `randomInt` を使いました。

    `Math.random` でも、画面上の見た目は変わらないと思います。
    ただこっちは、予測されにくいことを前提に作られた乱数なので。
    ガチャのように結果に価値がつくものは、こちらにしておきます。

    もう1つ、抽選はDBに一切触らない関数に切り出してあります。
    乱数も外から渡せる形で、プロトもそうなっていました。
    あとで10万回まわすときに、これが効いてきます。

    お金を減らす

    ゴールドの減らし方は、少し気をつけました。

    素直に書くとこうなります。

    1. 残高を読む
    2. 足りるか確かめる
    3. 減らす

    1と3の間に、同じユーザーのリクエストがもう1つ来ると、
    両方とも「足りる」と判断して、両方減らします。
    残高10で単発が2回通って、マイナスになる。

    なので確かめるのと減らすのを、SQL1文にまとめました。

    UPDATE `user_currency` SET `amount` = `amount` - ?
      WHERE `user_id` = ? AND `currency_id` = ? AND `amount` >= ?

    足りなければ1行も更新されません。
    更新された行数が0なら「足りない」、で判定できます。

    全部を1つのトランザクションで

    ガチャ1回で書き換えるものを並べるとこうなります。

    ゴールドを減らす
    ヒーローを付与する
    ガチャ履歴を残す
    デッキの空き枠に入れる
    チュートリアルを進める

    これを1つのトランザクションに入れています。

    途中で落ちたら、全部なかったことにする。
    お金だけ減ってキャラが来ない、というのが一番避けたい状態なので。
    問い合わせが来ても、ログを見るまで何が起きたか分からないやつですね。

    逆に、抽選そのものはトランザクションの外でやっています。
    DBを触らない処理なので、ロックを持ったまま時間を使う理由がない。
    先に結果を決めてから、まとめて書く順番です。

    履歴は出たぶんだけ

    `user_gacha_log` は10本目で作ったテーブルです。
    ようやく1行目が入ります。

    出たもの1体につき1行。10連なら10行。
    レアリティも一緒に記録しています。

    ヒーローのマスタを引けばレアリティは分かるのですが、
    マスタは総入れ替えなので、
    あとで調整が入ると過去の履歴の見え方まで変わってしまうんですよね。
    「あのとき出たのはSRだった」を残しておくための列です。

    引いたらデッキに入れる

    プロトは、ガチャで引いたキャラを自動でデッキに詰めていました。
    空き枠があれば、そこに入れる。

    これはそのままサーバに持ってきています。

    編成画面はまだ作っていないので、
    これが無いと引いてもホームに誰も立たないんですよね。

    • 使っているデッキの空き枠に、今回引いた順に詰める

    • 枠が埋まったらそこで止める

    • 溢れたヒーローも所持には入っている

    あわせて、チュートリアルの進捗が3なら4に上げます。
    前回、段の定義に「初回ガチャ済み」を置いておいたのはここで使うためでした。

    2回押されたら

    10連のボタンを連打されたら、どうなるか。

    これはクライアントで止めています。
    押した瞬間から応答が返るまで、ボタンを押せなくするだけ。

    止められないのは、通信が途中で切れた場合です。
    サーバでは引き終わっているのに、応答が届かない。
    アプリがもう一度送ると、もう1回引かれてしまいます。

    本番ではリクエストに番号を振って、
    同じ番号は2度処理しない、という仕組みを入れることが多いです。

    今回は入れません。

    その代わり、失敗したときは引けたかどうか分からないものとして扱います。

    結果はサーバでもう決まっているかもしれない。
    なので失敗したら、ホームのAPIを叩き直してゴールドを正しい値に戻します。
    メッセージは「引けている場合は、ホームや編成で確認できます」。

    演出は見られませんが、辻褄は合います。
    ゴールドが減った値で表示されるので、
    残っていなければもう1回押すこともできない。

    サーバ側で気をつけたのは1点だけです。
    コミットの後には、失敗しうる処理を置かない。
    返す値は全部トランザクションの中で揃えておいて、
    コミットしたら返すだけにしています。
    コミット済みなのにエラーが返る、というのが一番ややこしいので。

    実際のタイトルでも、ここはこのくらいで済ませることが多いと思います。

    演出は結果が決まってから

    卵を切る演出は、プロトから移植しました。

    画像
    ガチャ演出

    順番としては、サーバから結果が返ってから演出が始まります。
    演出はもう決まった結果を見せているだけなんですよね。

    なので演出の途中で閉じられても、引いた分はちゃんと残っています。
    次に開いたらホームに立っている。

    走っているキャラは、ホームに立っているヒーローです。
    まだ誰もいないときは、今回引いた1体目が走ります。

    SSRの3Dモデルはまだ作っていないので、SRの見た目で出ています。
    バッジだけはSSRになっていますね。

    10万回まわしてみる

    確率どおりに出ているか、確かめておきます。

    抽選の関数はDBを触らないので、
    抽選だけを10万回まわすスクリプトを置きました。
    呼んでいるのは本番と同じ関数です。
    シミュレーション用に別の抽選を書くと、それを確かめても意味がないので。

    docker compose exec app node scripts/gacha_simulate.ts 100000
    rarity  count   actual  master
    SSR      2008    2.01%    2.0%
    SR       5028    5.03%    5.0%
    R       24778   24.78%   25.0%
    N       68186   68.19%   68.0%

    ほぼマスタどおりですね。

    ぴったりにならないのは、確率なので当然です。
    実装したときに一度流したら、SSRは1.97%でした。
    10万回だと、SSRで±0.1%くらいはぶれるのが普通です。

    ヒーローごとにも見てみます。

    hero_id  name              rarity  count   actual
    11       雷刃の剣聖アルド  SSR      1011    1.01%
    12       蒼海の魔女ネリア  SSR       997    1.00%
    6        焔帝ヴァルカ      SR       1674    1.67%
    8        聖光の大巫女      SR       1663    1.66%
    10       氷嵐の歌姫リーゼ  SR       1691    1.69%
    2        疾風の剣士        R        6211    6.21%
    4        蒼弓の狙撃手      R        6116    6.12%
    5        紅蓮の魔道士      R        6184    6.18%
    9        旅の吟遊詩人      R        6267    6.27%
    1        見習い剣士        N       22684   22.68%
    3        村の弓手          N       22474   22.47%
    7        新米僧侶          N       23028   23.03%

    SSRは2体で2%なので、1体あたり1%。
    SRは3体で5%を分けるので、1体あたり1.67%。

    レアリティの確率を、そのレアリティの人数で割った値になっています。
    2段階で引いているので、こうなるんですよね。

    逆に言うと、SSRを1体足すと、1体あたりは0.67%に下がります。
    SSR全体の2%は変わらないけれど、狙いの1体は出にくくなる。
    ピックアップは、このとき狙いの1体の重みを上げて、出やすくする仕組みです。

    ちなみに今回、最初の1回で出たのは新米僧侶でした。
    23%を引いたので、順当ですね。

    動かす

    新規アカウントで始めて、ホームからガチャに行きます。

    画像
    ガチャ画面

    所持ゴールドは10。単発1回分だけですね。
    10本目で、初期データを「ガチャ1回分」にしたとおりです。

    画像
    獲得演出
    画像
    ゲットしたヒーロー一覧

    ガチャ画面に戻ると、ゴールドは0。
    単発も10連も押せなくなって、引いた結果が下に並んでいます。

    画像
    ガチャ画面

    ホームに戻ると、引いたヒーローが立っています。

    画像
    ホーム画面

    前回「まだ仲間がいません」だったところですね。

    今回はここまで

    • 抽選はサーバ。クライアントは「どれを何回」だけ送る

    • レアリティ → ヒーローの2段階で引く

    • マスタが壊れていたら起動しない

    • 残高の確認と減算はSQL1文で

    • 減算・付与・履歴・編成・進捗を1つのトランザクションで

    • 演出はサーバの結果が返ってから

    • 失敗したら、引けたかどうか分からないものとして状態を取り直す

    次回はヒーロー一覧とデッキ編成です。

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

    コード

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

    routes/gacha.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { PoolConnection, ResultSetHeader, RowDataPacket } from "mysql2/promise";
    import { withUserTransaction } from "../db.ts";
    import { selectStatusForUpdate } from "../user/status.ts";
    import { drawMany } from "../gacha/draw.ts";
    import type { DrawnHero } from "../gacha/draw.ts";
    import { gachaTable } from "../gacha/table.ts";
    import type { GachaTable } from "../gacha/table.ts";
    import { configNumber } from "../master/config.ts";
    import {
      CURRENCY_ID,
      GACHA_DRAW_COUNT,
      GAME_CONFIG_KEY,
      TUTORIAL_STEP,
    } from "../constants.ts";
    import { readIntegerField, readJsonBody, sendError, sendJson } from "../http.ts";
    
    // ガチャを引く。抽選はトランザクションの外で済ませ、中では決まった結果を書くだけにする。
    //
    // 返すのはサーバしか知らないことだけ。名前もレアリティもレベルも返さない
    // (レアリティはクライアントがマスタの hero から引く。レベルは付与時点で必ず 1)。
    
    type DrawResponse = {
      /** 抽選した順。10連なら10件 */
      results: { user_hero_id: number; hero_id: number }[];
      /** 減算後の残高 */
      currency: { currency_id: number; amount: number };
      tutorial_step: number;
    };
    
    /**
     * トランザクションの結果。
     *
     * ゴールド不足は例外ではなく「起きうる結果」なので、種類として返してハンドラ側で振り分ける。
     * 例外で抜けるとロールバックの意図が読みにくくなるうえ、400 と 500 の区別も付かない
     */
    type DrawOutcome =
      | { kind: "ok"; response: DrawResponse }
      | { kind: "notEnoughCurrency" }
      | { kind: "userNotFound" };
    
    /** POST /gacha/draw — ガチャを引く */
    export async function handleGachaDraw(
      req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const body = await readJsonBody(req);
    
      const poolId = readIntegerField(body, "pool_id");
      const table = poolId === null ? undefined : gachaTable(poolId);
      if (table === undefined) {
        sendError(res, 400, "INVALID_POOL", "pool_id が不正");
        return;
      }
    
      const count = readIntegerField(body, "count");
      if (count !== GACHA_DRAW_COUNT.SINGLE && count !== GACHA_DRAW_COUNT.TEN) {
        sendError(
          res,
          400,
          "INVALID_COUNT",
          `count は ${GACHA_DRAW_COUNT.SINGLE} か ${GACHA_DRAW_COUNT.TEN} のみ`,
        );
        return;
      }
    
      // 値段はサーバが決める。クライアントから金額は受け取らない
      const cost = count === GACHA_DRAW_COUNT.TEN ? table.costTen : table.costSingle;
    
      // 抽選はここで終わらせる。DBを触る前に結果を確定させておく
      const drawn = drawMany(table, count);
    
      const outcome = await withUserTransaction((conn) =>
        applyDraw(conn, userId, table, cost, drawn),
      );
    
      // ここから先は例外を投げうる処理を置かない。
      // コミット済みなのに 500 を返す(引けているのにクライアントには失敗に見える)状態を作らないため
      if (outcome.kind === "userNotFound") {
        sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
        return;
      }
      if (outcome.kind === "notEnoughCurrency") {
        sendError(res, 400, "NOT_ENOUGH_CURRENCY", "ゴールドが足りない");
        return;
      }
    
      sendJson(res, 200, outcome.response);
    }
    
    /**
     * 抽選済みの結果をユーザーデータに反映する。
     *
     * 行ロックの順番は user_status → user_currency → user_deck で固定する。
     * 他のAPIでもこの順を守る(別の順で待ち合うとデッドロックになる)
     */
    async function applyDraw(
      conn: PoolConnection,
      userId: number,
      table: GachaTable,
      cost: number,
      drawn: readonly DrawnHero[],
    ): Promise<DrawOutcome> {
      const status = await selectStatusForUpdate(conn, userId);
      if (status === null) return { kind: "userNotFound" };
    
      if (!(await spendCurrency(conn, userId, cost))) {
        // 何も書いていないので、ロールバックされてもコミットされても同じ
        return { kind: "notEnoughCurrency" };
      }
    
      const userHeroIds = await insertUserHeroes(conn, userId, drawn);
      await insertGachaLog(conn, userId, table.poolId, drawn, userHeroIds);
      await autoFillDeck(conn, userId, status.activeDeckId, userHeroIds);
    
      // 初回ガチャでチュートリアルが1段進む。2回目以降は据え置く
      const tutorialStep =
        status.tutorialStep === TUTORIAL_STEP.HOME ? TUTORIAL_STEP.FIRST_GACHA : status.tutorialStep;
      if (tutorialStep !== status.tutorialStep) {
        await conn.execute("UPDATE `user_status` SET `tutorial_step` = ? WHERE `user_id` = ?", [
          tutorialStep,
          userId,
        ]);
      }
    
      return {
        kind: "ok",
        response: {
          results: drawn.map((hero, index) => ({
            user_hero_id: userHeroIds[index],
            hero_id: hero.heroId,
          })),
          currency: {
            currency_id: CURRENCY_ID.GOLD,
            amount: await selectCurrencyAmount(conn, userId, CURRENCY_ID.GOLD),
          },
          tutorial_step: tutorialStep,
        },
      };
    }
    
    /**
     * ゴールドを引く。足りたら true。
     *
     * 「読んでから足りるか見て、書く」ではなく、条件付きの UPDATE 1本で減らす。
     * 行が無いユーザーは所持0なので、同じく0行になって「足りない」に倒れる
     */
    async function spendCurrency(
      conn: PoolConnection,
      userId: number,
      cost: number,
    ): Promise<boolean> {
      const [result] = await conn.execute<ResultSetHeader>(
        "UPDATE `user_currency` SET `amount` = `amount` - ?" +
          " WHERE `user_id` = ? AND `currency_id` = ? AND `amount` >= ?",
        [cost, userId, CURRENCY_ID.GOLD, cost],
      );
      return result.affectedRows > 0;
    }
    
    /** 引いた分だけ user_hero を作る。採番された user_hero_id を引いた順で返す */
    async function insertUserHeroes(
      conn: PoolConnection,
      userId: number,
      drawn: readonly DrawnHero[],
    ): Promise<number[]> {
      const userHeroIds: number[] = [];
    
      for (const hero of drawn) {
        // level と exp はDDLの既定値(1 / 0)に任せる
        const [result] = await conn.execute<ResultSetHeader>(
          "INSERT INTO `user_hero` (`user_id`, `hero_id`) VALUES (?, ?)",
          [userId, hero.heroId],
        );
        userHeroIds.push(result.insertId);
      }
    
      return userHeroIds;
    }
    
    /**
     * 排出履歴を1体1行で残す。
     * rarity_id は抽選した時点のもの。マスタを入れ替えても当時の記録が変わらないようにする
     */
    async function insertGachaLog(
      conn: PoolConnection,
      userId: number,
      poolId: number,
      drawn: readonly DrawnHero[],
      userHeroIds: readonly number[],
    ): Promise<void> {
      for (const [index, hero] of drawn.entries()) {
        await conn.execute(
          "INSERT INTO `user_gacha_log`" +
            " (`user_id`, `pool_id`, `hero_id`, `rarity_id`, `user_hero_id`) VALUES (?, ?, ?, ?, ?)",
          [userId, poolId, hero.heroId, hero.rarityId, userHeroIds[index]],
        );
      }
    }
    
    /**
     * 使用中デッキの空き枠に、今回引いた個体を引いた順に詰める。
     *
     * 編成画面がまだ無いので、これが無いと引いてもホームに立たない。
     * 対象は今回引いた個体だけ。既に所持していた個体は入れない
     */
    async function autoFillDeck(
      conn: PoolConnection,
      userId: number,
      deckId: number,
      userHeroIds: readonly number[],
    ): Promise<void> {
      // 空き枠を見てから入れるので、見た時点で行を押さえる
      const [rows] = await conn.execute<RowDataPacket[]>(
        "SELECT `slot_no` FROM `user_deck` WHERE `user_id` = ? AND `deck_id` = ? FOR UPDATE",
        [userId, deckId],
      );
      const used = new Set(rows.map((row) => Number(row.slot_no)));
    
      const deckSize = configNumber(GAME_CONFIG_KEY.DECK_SIZE);
    
      let slotNo = 0;
      for (const userHeroId of userHeroIds) {
        while (slotNo < deckSize && used.has(slotNo)) slotNo += 1;
        // 枠が埋まったらそこで止める。溢れた個体はデッキに入れない(所持には入っている)
        if (slotNo >= deckSize) return;
    
        await conn.execute(
          "INSERT INTO `user_deck` (`user_id`, `deck_id`, `slot_no`, `user_hero_id`)" +
            " VALUES (?, ?, ?, ?)",
          [userId, deckId, slotNo, userHeroId],
        );
        slotNo += 1;
      }
    }
    
    /** 減算後の残高。UPDATE が通っている以上、行は必ずある */
    async function selectCurrencyAmount(
      conn: PoolConnection,
      userId: number,
      currencyId: number,
    ): Promise<number> {
      const [rows] = await conn.execute<RowDataPacket[]>(
        "SELECT `amount` FROM `user_currency` WHERE `user_id` = ? AND `currency_id` = ?",
        [userId, currencyId],
      );
      const row = rows[0];
      return row === undefined ? 0 : Number(row.amount);
    }

    gacha/draw.ts

    import { randomInt } from "node:crypto";
    import type { GachaTable } from "./table.ts";
    import { GACHA_RATE_PERMILLE_TOTAL } from "../constants.ts";
    
    // 抽選そのもの。DBには一切触らない。
    // トランザクションを開ける前にここで結果を確定させ、書き込みはその結果をなぞるだけにする。
    
    /**
     * 乱数の供給元。node:crypto の randomInt と同じ形(min 以上 max 未満の整数)。
     * 既定は randomInt。シミュレーションで差し替えられるよう引数で受け取る
     */
    export type Rng = (min: number, max: number) => number;
    
    /** 抽選の結果1体分。rarity_id は引いた時点のもので、履歴にそのまま残す */
    export type DrawnHero = {
      heroId: number;
      rarityId: number;
    };
    
    /**
     * 1体引く。2段階で、まずレアリティ、次にそのレアリティの中のヒーロー。
     *
     * どちらも「乱数を1つ引き、並べた重みに足し込んで収まった所を採る」だけ。
     * 足し込む順(rarity_id 降順 / hero_id 昇順)は抽選表の並びで固定されている
     */
    export function drawOne(table: GachaTable, rng: Rng = randomInt): DrawnHero {
      const step = rollRarity(table, rng);
      return { heroId: rollHeroId(table, step, rng), rarityId: step.rarityId };
    }
    
    /** count 体まとめて引く。1体ずつ独立に引くだけで、10連だからといって保証はしない */
    export function drawMany(table: GachaTable, count: number, rng: Rng = randomInt): DrawnHero[] {
      const results: DrawnHero[] = [];
      for (let i = 0; i < count; i++) {
        results.push(drawOne(table, rng));
      }
      return results;
    }
    
    /** レアリティを決める。合計が 1000 であることは起動時に検証済み */
    function rollRarity(table: GachaTable, rng: Rng): GachaTable["steps"][number] {
      const r = rng(0, GACHA_RATE_PERMILLE_TOTAL);
    
      let accumulated = 0;
      for (const step of table.steps) {
        accumulated += step.ratePermille;
        if (r < accumulated) return step;
      }
    
      // 合計が 1000 なら r < 1000 は必ずどこかに収まる。ここに来たら抽選表が壊れている
      throw new Error(`[gacha] pool_id=${table.poolId}: レアリティが決まらなかった (r=${r})`);
    }
    
    /** そのレアリティのヒーローを決める。weight の比で選ぶ */
    function rollHeroId(
      table: GachaTable,
      step: GachaTable["steps"][number],
      rng: Rng,
    ): number {
      const w = rng(0, step.totalWeight);
    
      let accumulated = 0;
      for (const entry of step.entries) {
        accumulated += entry.weight;
        if (w < accumulated) return entry.heroId;
      }
    
      throw new Error(
        `[gacha] pool_id=${table.poolId}: rarity_id=${step.rarityId} のヒーローが決まらなかった (w=${w})`,
      );
    }

    gacha/table.ts

    import { master } from "../master/store.ts";
    import { GACHA_RATE_PERMILLE_TOTAL } from "../constants.ts";
    
    // ガチャの抽選表。マスタの3テーブルを「引くときの形」に組み替えて持つ。
    //
    // リクエストのたびに gacha_pool_entry をレアリティで絞り込むと、
    // 引くたびに全件走査することになる。起動時に1度だけ組み立てて使い回す。
    
    /** プール内の1エントリ。hero_id の昇順で並べる */
    export type GachaEntry = {
      heroId: number;
      weight: number;
    };
    
    /** レアリティ1段分。抽選はこの段を rarity_id の降順にたどる */
    export type GachaRarityStep = {
      rarityId: number;
      ratePermille: number;
      entries: readonly GachaEntry[];
      /** entries の weight 合計。引くたびに足し直さない */
      totalWeight: number;
    };
    
    export type GachaTable = {
      poolId: number;
      costSingle: number;
      costTen: number;
      /**
       * rarity_id の降順(SSR → N)。
       * 足し込む順が変わると同じ乱数でも結果が変わるので、Map ではなく配列で順番ごと持つ
       */
      steps: readonly GachaRarityStep[];
    };
    
    // 組み立て済みの抽選表。起動時に1度入れたら、以後は引くだけ
    let tables = new Map<number, GachaTable>();
    let built = false;
    
    /** 検証に落ちたときの例外。どのプールのどの行が駄目かをメッセージに入れる */
    function invalid(poolId: number, detail: string): Error {
      return new Error(`[gacha] pool_id=${poolId}: ${detail}`);
    }
    
    /**
     * プールのエントリを hero_id 昇順のまま rarity_id ごとに束ねる。
     * ついでにエントリ自体の妥当性(ヒーローが居るか、引ける個体か、weight が正か)も見る
     */
    function groupEntriesByRarity(poolId: number): Map<number, GachaEntry[]> {
      const byRarity = new Map<number, GachaEntry[]>();
    
      // マスタの取り出し順が hero_id 昇順なので、そのまま詰めれば各配列も昇順になる
      for (const entry of master.get_gacha_pool_entries(poolId)) {
        const heroId = Number(entry.hero_id);
        const weight = Number(entry.weight);
    
        const hero = master.get_hero(heroId);
        if (hero === undefined) {
          throw invalid(poolId, `gacha_pool_entry.hero_id=${heroId} が hero に無い`);
        }
        if (hero.is_playable !== 1) {
          throw invalid(poolId, `gacha_pool_entry.hero_id=${heroId} は is_playable=0`);
        }
        if (weight < 1) {
          throw invalid(poolId, `gacha_pool_entry.hero_id=${heroId} の weight=${weight} が1未満`);
        }
    
        const bucket = byRarity.get(hero.rarity_id);
        if (bucket === undefined) {
          byRarity.set(hero.rarity_id, [{ heroId, weight }]);
        } else {
          bucket.push({ heroId, weight });
        }
      }
    
      return byRarity;
    }
    
    /** プール1つ分の抽選表を組み立てる。駄目なら例外を投げる */
    function buildTable(poolId: number, costSingle: number, costTen: number): GachaTable {
      if (costSingle < 1) {
        throw invalid(poolId, `gacha_pool.cost_single=${costSingle} が1未満`);
      }
      if (costTen < 1) {
        throw invalid(poolId, `gacha_pool.cost_ten=${costTen} が1未満`);
      }
    
      const byRarity = groupEntriesByRarity(poolId);
      const rates = master.get_gacha_pool_rates(poolId);
    
      let totalPermille = 0;
      const steps: GachaRarityStep[] = [];
    
      for (const rate of rates) {
        const rarityId = Number(rate.rarity_id);
        const ratePermille = Number(rate.rate_permille);
        totalPermille += ratePermille;
    
        const entries = byRarity.get(rarityId) ?? [];
        if (ratePermille > 0 && entries.length === 0) {
          throw invalid(
            poolId,
            `rarity_id=${rarityId} は rate_permille=${ratePermille} なのにエントリが0件`,
          );
        }
    
        let totalWeight = 0;
        for (const entry of entries) totalWeight += entry.weight;
    
        steps.push({ rarityId, ratePermille, entries, totalWeight });
      }
    
      if (totalPermille !== GACHA_RATE_PERMILLE_TOTAL) {
        throw invalid(
          poolId,
          `gacha_pool_rate.rate_permille の合計が ${totalPermille}。` +
            `${GACHA_RATE_PERMILLE_TOTAL} でなければならない`,
        );
      }
    
      // 足し込む順は rarity_id の降順(SSR → N)で固定する
      steps.sort((a, b) => b.rarityId - a.rarityId);
    
      return { poolId, costSingle, costTen, steps };
    }
    
    /**
     * 全プールの抽選表を組み立てる。master.load() の後、リッスン開始前に1度だけ呼ぶ。
     * 1つでも検証に落ちたら例外を投げる。おかしなマスタのまま起動させない
     */
    export function buildGachaTables(): void {
      const next = new Map<number, GachaTable>();
    
      for (const pool of master.get_table("gacha_pool")) {
        const poolId = Number(pool.id);
        next.set(poolId, buildTable(poolId, Number(pool.cost_single), Number(pool.cost_ten)));
      }
    
      tables = next;
      built = true;
      console.log(`[gacha] ${next.size} pools`);
    }
    
    /** 組み立て済みの抽選表。存在しない pool_id なら undefined(入力の検証で使う) */
    export function gachaTable(poolId: number): GachaTable | undefined {
      if (!built) {
        throw new Error("ガチャの抽選表がまだ組み立てられていない");
      }
      return tables.get(poolId);
    }

    scripts/gacha_simulate.ts

    import { closePools } from "../src/db.ts";
    import { master } from "../src/master/store.ts";
    import { buildGachaTables, gachaTable } from "../src/gacha/table.ts";
    import type { GachaTable } from "../src/gacha/table.ts";
    import { drawOne } from "../src/gacha/draw.ts";
    import { GACHA_RATE_PERMILLE_TOTAL, INITIAL_GACHA_POOL_ID } from "../src/constants.ts";
    
    // 排出率の確認用。APIにはしないし、DBにも書かない。
    //
    //   docker compose exec app node scripts/gacha_simulate.ts 100000
    //
    // 抽選そのものは本番と同じ src/gacha/draw.ts を呼ぶ。
    // ここで見た割合と実際の排出がずれないよう、シミュレーション用の抽選は書かない。
    
    /** 回数を指定しなかったときの既定 */
    const DEFAULT_TRIALS = 100000;
    
    function parseTrials(raw: string | undefined): number {
      if (raw === undefined) return DEFAULT_TRIALS;
    
      const trials = Number(raw);
      if (!Number.isInteger(trials) || trials < 1) {
        throw new Error(`回数は1以上の整数で指定する: ${raw}`);
      }
      return trials;
    }
    
    /** 実測の割合。小数第2位まで */
    function formatActual(count: number, trials: number): string {
      return `${((count / trials) * 100).toFixed(2)}%`;
    }
    
    /** マスタの割合。千分率を百分率に直す */
    function formatMaster(ratePermille: number): string {
      return `${(ratePermille / 10).toFixed(1)}%`;
    }
    
    /** レアリティごとの回数と割合 */
    function printRarityTable(
      table: GachaTable,
      trials: number,
      countByRarityId: Map<number, number>,
    ): void {
      console.log("rarity\tcount\tactual\tmaster");
      for (const step of table.steps) {
        const code = master.get_rarity(step.rarityId)?.code ?? `rarity_id=${step.rarityId}`;
        const count = countByRarityId.get(step.rarityId) ?? 0;
        console.log(
          `${code}\t${count}\t${formatActual(count, trials)}\t${formatMaster(step.ratePermille)}`,
        );
      }
    }
    
    /** ヒーローごとの回数。並びは抽選表と同じ(rarity_id 降順 → hero_id 昇順) */
    function printHeroTable(
      table: GachaTable,
      trials: number,
      countByHeroId: Map<number, number>,
    ): void {
      console.log("hero_id\tname\trarity\tcount\tactual");
      for (const step of table.steps) {
        const code = master.get_rarity(step.rarityId)?.code ?? `rarity_id=${step.rarityId}`;
        for (const entry of step.entries) {
          const name = master.get_hero(entry.heroId)?.name ?? "?";
          const count = countByHeroId.get(entry.heroId) ?? 0;
          console.log(
            `${entry.heroId}\t${name}\t${code}\t${count}\t${formatActual(count, trials)}`,
          );
        }
      }
    }
    
    async function main(): Promise<void> {
      const trials = parseTrials(process.argv[2]);
    
      await master.load();
      buildGachaTables();
    
      const table = gachaTable(INITIAL_GACHA_POOL_ID);
      if (table === undefined) {
        throw new Error(`gacha_pool に id=${INITIAL_GACHA_POOL_ID} が無い`);
      }
    
      const countByRarityId = new Map<number, number>();
      const countByHeroId = new Map<number, number>();
    
      for (let i = 0; i < trials; i++) {
        // 単発で引く。10連もこれを count 回繰り返しているだけなので、割合は変わらない
        const drawn = drawOne(table);
        countByRarityId.set(drawn.rarityId, (countByRarityId.get(drawn.rarityId) ?? 0) + 1);
        countByHeroId.set(drawn.heroId, (countByHeroId.get(drawn.heroId) ?? 0) + 1);
      }
    
      console.log(`pool_id=${table.poolId} / ${trials} 回 / 分母 ${GACHA_RATE_PERMILLE_TOTAL}permille`);
      console.log("");
      printRarityTable(table, trials, countByRarityId);
      console.log("");
      printHeroTable(table, trials, countByHeroId);
    }
    
    // プールを閉じないとコネクションが開いたままでプロセスが終わらない。
    // 成功しても失敗しても必ず閉じる
    try {
      await main();
    } catch (error) {
      console.error(error);
      process.exitCode = 1;
    } finally {
      await closePools();
    }

    api/gacha.ts

    // ガチャを引く。抽選はサーバで行うので、クライアントは結果を受け取るだけ。
    import { apiPost } from './client';
    
    /** 引いた個体1体分。名前もレアリティも来ないので、hero_id でマスタを引く */
    export interface DrawnHero {
      user_hero_id: number;
      hero_id: number;
    }
    
    export interface DrawResponse {
      /** 抽選した順。10連なら10件 */
      results: DrawnHero[];
      /** 減算後の残高 */
      currency: { currency_id: number; amount: number };
      tutorial_step: number;
    }
    
    /**
     * POST /gacha/draw。
     * 値段はサーバが count から決めるので、金額は送らない
     */
    export function postGachaDraw(
      token: string,
      poolId: number,
      count: number,
    ): Promise<DrawResponse> {
      return apiPost<DrawResponse>('/gacha/draw', { pool_id: poolId, count }, token);
    }

    ui/screens/GachaScreen.tsx

    // ガチャ画面:単発/10連。抽選はサーバで確定 → 結果を受け取ってから演出(GachaAnimScreen)へ。
    // 直近の排出結果もこの画面に一覧表示する。プロトから移植。
    //
    // プロトはその場で抽選していたが、ここではサーバに引いてもらう。
    // そのため「押してから結果が返るまで」という待ちがあり、その間は押せないようにする。
    import { useState } from 'react';
    import { currencyAmount, type HomeResponse } from '../../api/home';
    import { postGachaDraw, type DrawnHero, type DrawResponse } from '../../api/gacha';
    import { CURRENCY_ID, GACHA_DRAW_COUNT } from '../../constants';
    import { roleIcon } from '../../master/codes';
    import type { MasterStore } from '../../master/store';
    
    /** 通信に失敗したときの文言。引けているかどうかはクライアントには分からない */
    const DRAW_FAILED_MESSAGE = '通信に失敗しました。引けている場合は、ホームや編成で確認できます';
    
    /**
     * 排出結果1件のセル。
     * 出るのは user_hero_id と hero_id だけなので、見た目はマスタから引く
     */
    export function ResultCell({
      drawn,
      master,
      delay,
    }: {
      drawn: DrawnHero;
      master: MasterStore;
      delay: number;
    }) {
      const hero = master.heroById.get(drawn.hero_id);
      const rarityCode = hero === undefined ? '' : master.rarityById.get(hero.rarity_id)?.code ?? '';
    
      return (
        <div className={`pcell ${rarityCode}`} style={{ animationDelay: `${delay}ms` }}>
          <span style={{ fontSize: 22 }}>{hero === undefined ? '' : roleIcon(hero.role)}</span>
          <span className="prar">{rarityCode}</span>
          <span style={{ fontSize: 10, color: 'var(--sub)' }}>{hero?.name ?? ''}</span>
        </div>
      );
    }
    
    /** 千分率を表示用の % にする。小数が要らなければ付けない(2% / 2.5%) */
    function formatPermille(ratePermille: number): string {
      const percent = ratePermille / 10;
      return `${Number.isInteger(percent) ? percent : percent.toFixed(1)}%`;
    }
    
    export function GachaScreen({
      poolId,
      home,
      master,
      token,
      last,
      onDrawn,
      onReloadHome,
    }: {
      poolId: number;
      home: HomeResponse;
      master: MasterStore;
      token: string;
      /** 直近の結果。演出から戻ってきたときに一覧で出す */
      last: DrawnHero[];
      /** 引けたとき。演出へ進むのは親の担当 */
      onDrawn: (response: DrawResponse) => void;
      /** 引けたかどうか分からないとき。ホームを取り直して差し替えてもらう */
      onReloadHome: () => Promise<void>;
    }) {
      // 通信中は押せない。押した瞬間から応答が返るまで単発も10連も止める
      const [busy, setBusy] = useState(false);
      const [message, setMessage] = useState<string | null>(null);
    
      const pool = master.gachaPoolById.get(poolId);
      const gold = currencyAmount(home, CURRENCY_ID.GOLD);
    
      // 排出率は sort_no の降順(SSR → N)で並べる。マスタの並びは当てにしない
      const rates = (master.gachaPoolRatesByPoolId.get(poolId) ?? [])
        .map((rate) => ({ rate, rarity: master.rarityById.get(rate.rarity_id) }))
        .sort((a, b) => (b.rarity?.sort_no ?? 0) - (a.rarity?.sort_no ?? 0));
    
      const draw = async (count: number) => {
        setBusy(true);
        setMessage(null);
        try {
          onDrawn(await postGachaDraw(token, poolId, count));
        } catch {
          // 引けたかどうかは分からないものとして扱う。
          // サーバでは確定していて、応答だけ届かなかった可能性がある。
          // 所持ゴールドを正しい値に戻すため、エラーの種類にかかわらずホームを取り直す
          setMessage(DRAW_FAILED_MESSAGE);
          try {
            await onReloadHome();
          } catch {
            // 取り直しにも失敗したら、押せないままにしてメッセージだけ出す。
            // 下部ナビでホームに戻れば取り直される
            return;
          }
          setBusy(false);
        }
      };
    
      const costSingle = pool?.cost_single ?? 0;
      const costTen = pool?.cost_ten ?? 0;
    
      return (
        <div className="screenBody gachaBody">
          <div className="gachaPanel panel">
            <div className="secTitle">ガチャ(天井なし・確率型)</div>
            <div className="rateRow">
              <span>排出率</span>
              <span>
                {rates.map(({ rate, rarity }, i) => (
                  <span key={rate.rarity_id}>
                    {i > 0 && ' / '}
                    <span className={(rarity?.code ?? '').toLowerCase()}>
                      {rarity?.code ?? ''} {formatPermille(rate.rate_permille)}
                    </span>
                  </span>
                ))}
              </span>
            </div>
            <div className="gachaBtns">
              <button
                className="btnP"
                disabled={busy || gold < costSingle}
                onClick={() => draw(GACHA_DRAW_COUNT.SINGLE)}
              >
                単発<br />
                <small>{costSingle} G</small>
              </button>
              <button
                className="btnP"
                disabled={busy || gold < costTen}
                onClick={() => draw(GACHA_DRAW_COUNT.TEN)}
              >
                10連<br />
                <small>{costTen} G</small>
              </button>
            </div>
            {message !== null && <div className="gachaError">{message}</div>}
            {last.length > 0 && (
              <div className="pull">
                {last.map((drawn, i) => (
                  <ResultCell key={drawn.user_hero_id} drawn={drawn} master={master} delay={i * 40} />
                ))}
              </div>
            )}
            <div className="gachaNote">
              {/* 注記の文言はプロトのまま。最高レアの名前と確率だけマスタから差し込む */}
              天井なしなので、{rates[0]?.rarity?.code ?? ''}の体感は{' '}
              {formatPermille(rates[0]?.rate.rate_permille ?? 0)} という数字だけで決まります。
              ゴールドはガチャと育成で同じ財布です。
            </div>
          </div>
        </div>
      );
    }

    App.tsx

    // 起動シーケンス:タイトル →(タップ)→ サインアップ/マスタ取得 → GET /user/home。
    // タップ前は一切通信しない。実際のソシャゲではこの間にメンテナンスチェックと
    // マスタのバージョンチェックが入るが、今回は実装しない。
    //
    // 名前入力を出すかホームへ直行するかは、サーバが返す tutorial_step だけで決める。
    // クライアントは「どこまで進んだか」を自分では覚えない。
    import { useCallback, useState, type ReactNode } from 'react';
    import { fetchToken } from './api/auth';
    import { errorMessage, isUnauthorized } from './api/client';
    import { fetchHome, postPrologueDone, postUserName, type HomeResponse } from './api/home';
    import type { DrawnHero, DrawResponse } from './api/gacha';
    import { GACHA_POOL_ID, TUTORIAL_STEP } from './constants';
    import { buildMasterStore, fetchMaster, type MasterStore } from './master/store';
    import { clearToken, loadOrCreateDeviceKey, loadToken, saveToken } from './storage/token';
    import { TopBar, BottomNav, type NavScreen } from './ui/Hud';
    import { TitleScreen } from './ui/screens/TitleScreen';
    import { LoadingScreen } from './ui/screens/LoadingScreen';
    import { NameInputScreen } from './ui/screens/NameInputScreen';
    import { IntroScreen } from './ui/screens/IntroScreen';
    import { HomeScreen } from './ui/screens/HomeScreen';
    import { GachaScreen } from './ui/screens/GachaScreen';
    import { GachaAnimScreen } from './ui/screens/GachaAnimScreen';
    
    /** 起動時に取れたもの一式。以後のAPIはこのトークンで叩く */
    interface Session {
      token: string;
      master: MasterStore;
      home: HomeResponse;
    }
    
    type Phase =
      | { kind: 'title' }
      | { kind: 'loading' }
      | { kind: 'name'; session: Session }
      | { kind: 'intro'; session: Session; name: string }
      | { kind: 'home'; session: Session }
      // last は直近の排出結果。演出から戻ってきたときに一覧で出す
      | { kind: 'gacha'; session: Session; last: DrawnHero[] }
      | { kind: 'gachaAnim'; session: Session; results: DrawnHero[] }
      | { kind: 'error'; message: string };
    
    /** 保存済みトークンがあればそれを使う。無ければサインアップして保存する */
    async function prepareToken(deviceKey: string): Promise<string> {
      const saved = loadToken();
      if (saved !== null) return saved;
    
      const token = await fetchToken(deviceKey);
      saveToken(token);
      return token;
    }
    
    /** マスタと起動時の状態を取る */
    async function openSession(token: string): Promise<Session> {
      const master = buildMasterStore(await fetchMaster(token));
      return { token, master, home: await fetchHome(token) };
    }
    
    /**
     * タップしてから行き先が決まるまでの通信一式。
     *
     * 401 が返るのは、保存していたトークンが期限切れか無効になったとき。
     * その1回だけトークンを捨てて取り直す。2度目も駄目なら諦めてエラーにする
     */
    async function boot(): Promise<Session> {
      const deviceKey = loadOrCreateDeviceKey();
      const token = await prepareToken(deviceKey);
    
      try {
        return await openSession(token);
      } catch (error) {
        if (!isUnauthorized(error)) throw error;
    
        clearToken();
        return openSession(await prepareToken(deviceKey));
      }
    }
    
    /**
     * ガチャの結果で session.home を差し替える。HUD のゴールドをすぐ減らすため。
     * lead_hero はここでは触らない(ホームに戻るときに取り直す)
     */
    function applyDrawToHome(home: HomeResponse, response: DrawResponse): HomeResponse {
      const currency = response.currency;
      const known = home.currencies.some((row) => row.currency_id === currency.currency_id);
    
      return {
        ...home,
        status: { ...home.status, tutorial_step: response.tutorial_step },
        currencies: known
          ? home.currencies.map((row) => (row.currency_id === currency.currency_id ? currency : row))
          : [...home.currencies, currency],
      };
    }
    
    export function App() {
      const [phase, setPhase] = useState<Phase>({ kind: 'title' });
    
      const fail = useCallback((error: unknown) => {
        setPhase({ kind: 'error', message: errorMessage(error) });
      }, []);
    
      // 行き先を決めるのは tutorial_step だけ。ここに条件を増やさない
      const enter = useCallback((session: Session) => {
        const step = session.home.status.tutorial_step;
        if (step === TUTORIAL_STEP.NONE) {
          setPhase({ kind: 'name', session });
        } else if (step === TUTORIAL_STEP.NAME) {
          setPhase({ kind: 'intro', session, name: session.home.status.name });
        } else {
          setPhase({ kind: 'home', session });
        }
      }, []);
    
      // タイトルのタップと、エラー画面の再試行ボタンの両方から呼ぶ
      const start = useCallback(() => {
        setPhase({ kind: 'loading' });
        boot().then(enter, fail);
      }, [enter, fail]);
    
      /** 名前を保存してプロローグへ。失敗は入力画面側で拾わせるので、ここでは投げ直す */
      const decideName = useCallback(async (session: Session, name: string) => {
        const saved = await postUserName(session.token, name);
        setPhase({ kind: 'intro', session, name: saved.name });
      }, []);
    
      /** プロローグ済みを記録してホームへ。進捗と名前が反映された状態で出すため取り直す */
      const finishPrologue = useCallback(
        (session: Session) => {
          setPhase({ kind: 'loading' });
          postPrologueDone(session.token)
            .then(() => fetchHome(session.token))
            .then((home) => setPhase({ kind: 'home', session: { ...session, home } }), fail);
        },
        [fail],
      );
    
      /** ホームへ。lead_hero が変わっているので取り直す */
      const goHome = useCallback(
        (session: Session) => {
          setPhase({ kind: 'loading' });
          fetchHome(session.token).then(
            (home) => setPhase({ kind: 'home', session: { ...session, home } }),
            fail,
          );
        },
        [fail],
      );
    
      /**
       * 下部ナビ。行き先の画面がまだ無い項目は、呼ばれても何もしない。
       * last を持ち回すのは、ガチャ画面でガチャを押し直しても直近の結果が消えないようにするため
       */
      const navigate = useCallback(
        (session: Session, screen: NavScreen, last: DrawnHero[]) => {
          if (screen === 'home') goHome(session);
          else if (screen === 'gacha') setPhase({ kind: 'gacha', session, last });
        },
        [goHome],
      );
    
      /** 引けた。HUDを減算後の値にしてから演出へ */
      const startGachaAnim = useCallback((session: Session, response: DrawResponse) => {
        setPhase({
          kind: 'gachaAnim',
          session: { ...session, home: applyDrawToHome(session.home, response) },
          results: response.results,
        });
      }, []);
    
      /**
       * 引けたかどうか分からないとき用の取り直し。
       * 失敗はそのまま投げ返し、ガチャ画面側でボタンを押せないままにさせる
       */
      const reloadGachaHome = useCallback(async (session: Session, last: DrawnHero[]) => {
        const home = await fetchHome(session.token);
        setPhase({ kind: 'gacha', session: { ...session, home }, last });
      }, []);
    
      let body: ReactNode = null;
      if (phase.kind === 'title') {
        body = <TitleScreen onStart={start} />;
      } else if (phase.kind === 'loading') {
        body = <LoadingScreen message="接続中…" />;
      } else if (phase.kind === 'name') {
        const session = phase.session;
        body = <NameInputScreen onDecide={(name) => decideName(session, name)} />;
      } else if (phase.kind === 'intro') {
        const session = phase.session;
        body = <IntroScreen name={phase.name} onDone={() => finishPrologue(session)} />;
      } else if (phase.kind === 'home') {
        const session = phase.session;
        body = (
          <>
            <TopBar home={session.home} master={session.master} />
            <HomeScreen
              home={session.home}
              master={session.master}
              onGacha={() => setPhase({ kind: 'gacha', session, last: [] })}
            />
            <BottomNav current="home" onNavigate={(screen) => navigate(session, screen, [])} />
          </>
        );
      } else if (phase.kind === 'gacha') {
        const session = phase.session;
        const last = phase.last;
        body = (
          <>
            <TopBar home={session.home} master={session.master} />
            <GachaScreen
              poolId={GACHA_POOL_ID.NORMAL}
              home={session.home}
              master={session.master}
              token={session.token}
              last={last}
              onDrawn={(response) => startGachaAnim(session, response)}
              onReloadHome={() => reloadGachaHome(session, last)}
            />
            <BottomNav current="gacha" onNavigate={(screen) => navigate(session, screen, last)} />
          </>
        );
      } else if (phase.kind === 'gachaAnim') {
        // 演出中は TopBar と BottomNav を出さない(全画面)
        const session = phase.session;
        const results = phase.results;
        body = (
          <GachaAnimScreen
            home={session.home}
            master={session.master}
            results={results}
            onDone={() => setPhase({ kind: 'gacha', session, last: results })}
          />
        );
      } else {
        body = (
          <div className="screenBody">
            <div className="centerWrap">
              <div className="panel bootError">
                <div className="bootText">つうしんに失敗しました</div>
                <div className="bootDetail">{phase.message}</div>
                <button type="button" className="btnP" onClick={start}>
                  再試行
                </button>
              </div>
            </div>
          </div>
        );
      }
    
      return (
        <div className="app">
          <div className="lightshaft" />
          {body}
          <div className="rotateOverlay">
            <div>📱↻<br />横向きにしてあそんでね</div>
          </div>
        </div>
      );
    }
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ