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

ソシャゲのサーバーを作る。クライアントを繋ぐ(9)

    前回でマスターデータの配信APIができました。

    今回からクライアントを作っていきます。
    サインアップして、マスタを受け取って、
    タイトル画面が出るところまでやります。

    クライアントは前に作ってある

    以前、AIにソシャゲを一式作らせた回がありました。

    ヒーローコレクション型のプロトタイプで、
    タイトルからガチャ、編成、バトル、ショップまで入ってます。

    今回作ろうとしているアプリの原型です。
    これをそのまま使います。

    技術スタックはこんな感じ。

    Vite + React + TypeScript
    Three.js + React Three Fiber
    状態管理は useReducer(ライブラリなし)

    選んだのは私ではなくAIですが、
    2026年の今調べても標準的な組み合わせなので、
    そのままこれで行きます。

    Reactが要るかというと、ゲーム部分にはあまり効きません。
    バトルもガチャ演出もThree.js側の仕事なので。
    効くのはホームやショップのUIです。

    プロトには結構今の実装とは合わない部分があったので、結構削除しました(笑)

    やることは3つです。
    サインアップしてトークンをもらう。
    そのトークンでマスタを取る。
    受け取ったマスタを画面に出す。
    まずは通信から。

    ブラウザから叩くと弾かれる

    さて通信です。

    いきなり躓きました。
    Viteの開発サーバは5173番、APIサーバは3000番。
    オリジンが違うので、ブラウザがリクエストを止めます。
    CORSエラーというやつです。

    サーバ側で許可を出す手もありますが、
    今回はViteのプロキシで回避しました。

    server: {
      proxy: {
        "/api": {
          target: "http://localhost:3000",
          changeOrigin: true,
          rewrite: (path) => path.replace(/^\/api/, ""),
        },
      },
    }

    クライアントからは `/api/master` と叩きます。
    ブラウザから見ると同じオリジンなので、止められません。

    これは開発中だけの話です。
    ビルドするとAPIサーバ自身がクライアントを配るので、
    同じオリジンから出ることになって、プロキシも要らなくなります。

    const API_BASE = import.meta.env.DEV ? '/api' : '';

    開発時は `/api` 経由、ビルド後はそのままルートを叩く。
    1行で切り替えています。

    本番でクライアントを別のドメインに置くなら、
    そのときはサーバ側でちゃんと許可を出すことになります。

    サインアップする

    流れは3本目から5本目でやったとおりです。

    prepare でワンタイムキーをもらって、
    signup で device_key と一緒に送ると、トークンが返ります。

    ここで、自分で仕掛けた罠に引っかかりました。

    prepare の直後に signup を投げると、弾かれるんです。
    ワンタイムキーの発行から一定時間が経っていないと通らないようにしてあったので。

    人間が画面を操作していれば1秒くらいは経ちます。

    でもプログラムから続けて叩くと、必ず引っかかる。
    最初に止めたのが自分のクライアントだったわけですね。

    const SIGNUP_MIN_WAIT_MS = 1200;

    いまは間隔を空けて投げています。
    本来はここに名前入力なりプロローグなりが挟まるので、
    実際の流れでは問題にならないはずです。
    待つのではなく、演出で埋めるのが本来の姿ですね。

    device_key はブラウザなので、
    初回に `crypto.randomUUID()` で作って保存しています。

    const DEVICE_KEY = 'hc_device_key';
    const TOKEN_KEY = 'hc_token';
    
    export function loadOrCreateDeviceKey(): string {
      const saved = localStorage.getItem(DEVICE_KEY);
      if (saved !== null) return saved;
    
      const created = crypto.randomUUID();
      localStorage.setItem(DEVICE_KEY, created);
      return created;
    }

    トークンは localStorage に平文です。

    複合するコードがクライアントの中にあるので、
    開発者ツールを開ける人には見えてしまうので、暗号化はしてません。
    ブラウザゲームは中身が全部見えている、という前提です。

    そのぶん、やり直しは簡単です。
    localStorage のこのキーを消せば、次の起動で新しいアカウントになります。
    テスト中は重宝します。

    トークンには期限があるので、
    保存しておいたもので401が返ってきたら、
    捨てて取り直して、もう一度だけ試すようにしました。

    異常系は本来ここが一番手間のかかるところです。
    通信エラー、期限切れ、多重ログイン、サーバ側の障害。
    それぞれで見せる画面も復帰の仕方も変わります。
    今回は素通りします(笑)

    マスタを受け取る

    型が要ります。

    サーバ側に `types.ts` があるので、
    本来はそれを共有したいところです。
    ただクライアントとサーバは別プロジェクトなので、
    importで繋ぐとビルドが絡み合います。

    今回はコピーしました。
    ズレたら壊れます。

    ただし、サーバの型をそのまま持たせません。

    前回、敵のステータスは配信しないと決めました。
    なのでクライアントに届く敵には、HPも攻撃力もありません。

    // サーバ側の Enemy
    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;
    };
    
    // クライアント側の Enemy
    export type Enemy = {
      id: number; name: string; element: number; role: number;
      is_boss: number;
    };

    同じ型を使い回すと、
    存在しないプロパティが型の上では見えることになります。
    これが一番厄介ですね。コンパイルは通るのに undefined が返る。

    前回「何を渡して何を渡さないか」を決めましたが、
    それがそのまま型に現れる、という話です。

    数値と文字列が噛み合わない

    もう1つ、思わぬところで引っかかりました。

    プロトの3Dは文字列を受け取ります。

    { kind: 'hero', role: 'mage', element: '火', rarity: 'SR' }

    サーバのマスタは数値です。

    { "role": 3, "element": 1, "rarity_id": 2 }

    どちらが正しいという話ではないですが、
    DBに入れるなら数値のほうが素直ですし、
    コードを書くなら文字列のほうが読めます。

    7本目でレアリティを数値IDに変えたときの判断が、
    ここで跳ね返ってきた形です。

    3D側を数値対応に直すこともできますが、
    今回の主題ではないので、変換を1枚挟みました。

    const ROLE_LOOK: Record<number, Role> = {
      1: 'melee',
      2: 'ranged',
      3: 'mage',
      4: 'healer',
      5: 'support',
    };
    
    const ELEMENT_LOOK: Record<number, Element> = {
      1: '火',
      2: '水',
      3: '風',
    };

    知らない値が来ても描画は止めず、既定値に倒すようにしました。
    マスタが増えたときに画面が真っ白になるより、
    とりあえず何か描いてくれたほうが原因を追いやすいので。

    変換をどこか1箇所にまとめておけば、
    あとで気が変わっても直す場所は決まっています。

    ちなみにプロトは N / R / SR の3段階でした。
    7本目でSSRを足したので、3Dの見た目が追いついていません。

    const RARITY_LOOK: Record<number, RarityLook> = {
      0: 'N',
      1: 'R',
      2: 'SR',
      3: 'SR',   // SSR は当面 SR の見た目で描く
    };

    ここは次回以降にでも。

    マスタをどう持つか

    受け取ったJSONをそのまま持つと、
    引くのが面倒です。

    master.hero.find(h => h.id === id)

    毎回これを書くことになります。

    かといってクラスを作るのも面倒です。
    サーバ側は起動時に読んで長時間使い回すのでクラスにしましたが、
    クライアントは1回の起動ぶんの寿命なので、そこまでの構えは要りません。

    Mapに変換するだけにしました。

    function indexById<T extends { id: number }>(rows: readonly T[]): Map<number, T> {
      return new Map(rows.map((row) => [row.id, row]));
    }
    
    export function buildMasterStore(payload: MasterPayload): MasterStore {
      return {
        version: payload.version,
        heroes: payload.hero,
        heroById: indexById(payload.hero),
        rarityById: indexById(payload.rarity),
      };
    }

    これで `heroById.get(3)` と引けます。
    やっていることは前回サーバ側でやったのと同じですね。

    全部のテーブルをやる必要もありません。
    引く形が決まったものから足していけばいい。

    タイトル画面

    移植と言っても、ファイルを持ってくるだけです。

    export function TitleScreen({ onStart }: { onStart: () => void }) {
      return (
        <div className="screenBody" onPointerDown={onStart} style={{ cursor: 'pointer' }}>
          <div className="titleGround" />
          <div className="titleSpot" />
          <div className="groundglow" />
          <div className="titleChar">
            <Stage camera={{ position: [0, 1.4, 4.6], fov: 40 }}>
              <CameraRig position={[0, 1.4, 4.6]} target={[0, 1.2, 0]} />
              <CharacterModel
                look={{ kind: 'hero', role: 'mage', element: '火', rarity: 'SR' }}
                rotationY={-0.35}
                bob
              />
            </Stage>
          </div>
          <div className="titleLogo">
            <div className="l1">ぱぱぱの</div>
            <div className="l2">ヒーローコレクション</div>
            <div className="l3">HERO COLLECTION</div>
          </div>
          <div className="tapStart">▶ タップしてスタート</div>
        </div>
      );
    }

    これで動きます。無改変です。

    画像
    タイトル画面

    デザインが先にあると楽ですね。
    ここを今から作っていたら、今回の記事は全部それで埋まっていたはずです。

    タップするまでは通信しません。
    勝手に繋ぎに行かないほうが、後で困らないので。

    横向きにしてあそんでね

    移植して1つ面白かったのが、これです。

    画像
    横向き警告画面

    プロトは横画面固定で作ってあって、
    縦長のときは「横向きにしてあそんでね」を出す作りでした。
    スマホを想定した処理ですね。

    これ、PCのブラウザでも動きます。
    開発者ツールを開いて画面が狭くなった瞬間に出ました。

    判定としては正しいんです。
    表示領域が縦長になったので。
    ただ想定していた場面とは違いましたが。

    そのうち直そうかと思いますが、今回はこのままにしておきます。

    ここに入るもの

    タップしてから実際に遊べるまで、
    本当はもう少し段があります。

    タイトル(タップ待ち)
      ↓
    メンテナンスチェック
      ↓
    サインアップ / セッション復帰
      ↓
    マスタのバージョンチェック
      ↓
    マスタ取得(バージョンが変わっていれば)
      ↓
    ユーザーデータの取得
      ↓
    ホーム

    メンテナンスチェックとバージョンチェックは今回入れていません。
    ただどちらもとても重要な機能です。

    メンテ中に入れてしまうと、
    データが壊れたり、直したいものが直せなかったりします。
    バージョンチェックが無いと、毎回マスタを丸ごと落とすことになりますし、
    差し替えたのに古いまま遊んでいる人が出ます。

    いまは毎回取っています。

    動かす

    タップすると、通信して一覧が出ます。

    画像
    ヒーロー一覧

    12体並んでいます。
    7本目で足したSSRの2体も来ていますね。

    リロードすると、今度はサインアップを飛ばして
    マスタ取得だけで進みます。
    トークンが残っているので。

    画像
    ローカルストレージ

    ついでにビルドしてみました。

    index.html                0.50 kB │ gzip:   0.34 kB
    assets/index-....css     19.49 kB │ gzip:   4.70 kB
    assets/index-....js   1,084.07 kB │ gzip: 298.25 kB

    前回、マスタが20KB・gzipで3.9KBで「意外と小さい」と書きました。
    そのマスタを表示するためのJSが、gzipで298KBです。

    ほとんどThree.jsですね(汗)
    通信量を気にするなら、まずこちらだろうという話になります。

    今回はここまで

    • プロトから3D・CSS・タイトル画面を持ってきた

    • 古いDBスキーマは捨てた

    • CORSはViteのプロキシで回避した

    • 自分で入れた間隔チェックに、自分のクライアントが引っかかった

    • トークンは平文でlocalStorage。消せばやり直せる

    • 型はコピー。ただし配信される列だけ

    • 数値と文字列の変換を1枚挟んだ

    ここまでで、ユーザーのデータ以外はひととおり揃いました。

    次回は残り、ユーザー系のテーブルを一式作ります。
    所持ヒーロー、デッキ、アイテム、進捗、その他もろもろ。

    これができれば、あとは各機能を実装していく流れになります。

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

    コード

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

    vite.config.ts

    import { defineConfig } from 'vite';
    import react from '@vitejs/plugin-react';
    
    // base: './' … 成果物を任意のサブパスに置いても動くようにする(プロトから引き継ぎ)
    export default defineConfig({
      plugins: [react()],
      base: './',
      build: {
        // ビルド成果物はAPIサーバの静的配信先に直接吐く。api-server/public は gitignore 済み
        outDir: '../api-server/public',
        emptyOutDir: true,
      },
      server: {
        // 開発サーバ(5173)からAPIサーバ(3000)を直接叩くとCORSで弾かれる。
        // サーバ側にCORS設定を入れる代わりに、Viteのプロキシで同一オリジンに見せる。
        // クライアントからは /api/master のように叩き、ここで /api を落として転送する
        proxy: {
          '/api': {
            target: 'http://localhost:3000',
            changeOrigin: true,
            rewrite: (path) => path.replace(/^\/api/, ''),
          },
        },
      },
    });

    src/App.tsx

    // 起動シーケンス:タイトル →(タップ)→ サインアップ/マスタ取得 → ヒーロー一覧。
    // タップ前は一切通信しない。実際のソシャゲではこの間にメンテナンスチェックと
    // マスタのバージョンチェックが入るが、今回は実装しない。
    import { useCallback, useState, type ReactNode } from 'react';
    import { fetchToken } from './api/auth';
    import { isUnauthorized } from './api/client';
    import { buildMasterStore, fetchMaster, type MasterStore } from './master/store';
    import { clearToken, loadOrCreateDeviceKey, loadToken, saveToken } from './storage/token';
    import { TitleScreen } from './ui/screens/TitleScreen';
    import { LoadingScreen } from './ui/screens/LoadingScreen';
    import { HeroListScreen } from './ui/screens/HeroListScreen';
    
    type Phase =
      | { kind: 'title' }
      | { kind: 'loading' }
      | { kind: 'heroList'; master: MasterStore }
      | { 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;
    }
    
    /**
     * タップしてからヒーロー一覧を出すまでの通信一式。
     *
     * マスタ取得が 401 を返すのは、保存していたトークンが期限切れか無効になったとき。
     * その1回だけトークンを捨てて取り直す。2度目も駄目なら諦めてエラーにする
     */
    async function boot(): Promise<MasterStore> {
      const deviceKey = loadOrCreateDeviceKey();
      const token = await prepareToken(deviceKey);
    
      try {
        return buildMasterStore(await fetchMaster(token));
      } catch (error) {
        if (!isUnauthorized(error)) throw error;
    
        clearToken();
        const reissued = await prepareToken(deviceKey);
        return buildMasterStore(await fetchMaster(reissued));
      }
    }
    
    function errorMessage(error: unknown): string {
      return error instanceof Error ? error.message : '不明なエラーが発生しました';
    }
    
    export function App() {
      const [phase, setPhase] = useState<Phase>({ kind: 'title' });
    
      // タイトルのタップと、エラー画面の再試行ボタンの両方から呼ぶ
      const start = useCallback(() => {
        setPhase({ kind: 'loading' });
        boot().then(
          (master) => setPhase({ kind: 'heroList', master }),
          (error: unknown) => setPhase({ kind: 'error', message: errorMessage(error) }),
        );
      }, []);
    
      let body: ReactNode = null;
      if (phase.kind === 'title') {
        body = <TitleScreen onStart={start} />;
      } else if (phase.kind === 'loading') {
        body = <LoadingScreen message="接続中…" />;
      } else if (phase.kind === 'heroList') {
        body = <HeroListScreen master={phase.master} />;
      } 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>
      );
    }

    src/api/client.ts

    // サーバとの通信の入口。fetch を直接呼ぶのはこのファイルだけにする。
    
    /**
     * APIのベースURL。
     *
     *  - 開発時(vite dev)… /api を Vite のプロキシが 3000 番へ転送する
     *  - ビルド後         … APIサーバ自身が配信するので、同一オリジンのルートをそのまま叩く
     */
    const API_BASE = import.meta.env.DEV ? '/api' : '';
    
    /**
     * 通信の失敗。status は HTTP のステータスコード。
     * サーバまで届かなかった場合(オフライン・サーバ停止)は 0 を入れる。
     */
    export interface ApiError extends Error {
      status: number;
    }
    
    function apiError(status: number, message: string): ApiError {
      const error = new Error(message) as ApiError;
      error.status = status;
      return error;
    }
    
    /** サーバに届かなかったことを表す status。HTTPのコードと衝突しない 0 を使う */
    export const STATUS_NETWORK_ERROR = 0;
    
    export function isUnauthorized(error: unknown): boolean {
      return error instanceof Error && (error as ApiError).status === 401;
    }
    
    interface RequestOptions {
      method: 'GET' | 'POST';
      /** JSONとして送るボディ。GET では使わない */
      body?: unknown;
      /** Authorization: Bearer に載せるトークン */
      token?: string;
    }
    
    async function request<T>(path: string, options: RequestOptions): Promise<T> {
      const headers: Record<string, string> = {};
      if (options.body !== undefined) headers['Content-Type'] = 'application/json';
      if (options.token !== undefined) headers.Authorization = `Bearer ${options.token}`;
    
      let response: Response;
      try {
        response = await fetch(`${API_BASE}${path}`, {
          method: options.method,
          headers,
          body: options.body === undefined ? undefined : JSON.stringify(options.body),
        });
      } catch {
        // fetch が投げるのは通信そのものが失敗したときだけ。HTTPのエラー応答はここに来ない
        throw apiError(STATUS_NETWORK_ERROR, 'サーバに接続できませんでした');
      }
    
      if (!response.ok) {
        throw apiError(response.status, `サーバがエラーを返しました (${response.status})`);
      }
    
      return (await response.json()) as T;
    }
    
    export function apiGet<T>(path: string, token: string): Promise<T> {
      return request<T>(path, { method: 'GET', token });
    }
    
    export function apiPost<T>(path: string, body: unknown): Promise<T> {
      return request<T>(path, { method: 'POST', body });
    }

    src/api/auth.ts

    // サインアップ(prepare → signup)。トークンの保存は storage/token.ts の担当。
    import { apiPost } from './client';
    
    interface PrepareResponse {
      onetime_key: string;
      expires_in: number;
    }
    
    interface SignupResponse {
      user_id: number;
      token: string;
      is_new: boolean;
    }
    
    /**
     * prepare から signup までの最小待ち時間(ミリ秒)。
     *
     * サーバは発行から 1 秒経たずに使われたワンタイムキーを機械的なアクセスとみなして弾く
     * (api-server の ONETIME_KEY_MIN_ELAPSED_MS)。連続で叩くと必ず失敗するので、ここで待つ。
     * 実機ではこの間にローディング演出が入る想定
     */
    const SIGNUP_MIN_WAIT_MS = 1200;
    
    function wait(ms: number): Promise<void> {
      return new Promise((resolve) => setTimeout(resolve, ms));
    }
    
    /** ワンタイムキーを取り、端末キーと合わせてトークンを得る */
    export async function fetchToken(deviceKey: string): Promise<string> {
      const prepared = await apiPost<PrepareResponse>('/auth/prepare', {});
      await wait(SIGNUP_MIN_WAIT_MS);
    
      const signedUp = await apiPost<SignupResponse>('/auth/signup', {
        onetime_key: prepared.onetime_key,
        device_key: deviceKey,
      });
      return signedUp.token;
    }

    src/master/types.ts

    // サーバから配信されるマスタの型。
    //
    // api-server/src/master/types.ts の写しだが、**配信される列だけ**を書いてある。
    // 除外されている列(敵のステータスなど)はサーバしか知らない。型にも書かない。
    //
    // DECIMAL は文字列で来る(stat_multiplier: "1.80")。数値に直すと桁が落ちるので string のまま持つ。
    // TINYINT(1) は真偽値ではなく 0 / 1 の数値で来る。
    
    export interface Rarity {
      id: number;
      code: string;
      name: string;
      stat_multiplier: string;
      sort_no: number;
    }
    
    export interface 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 interface Skill {
      id: number;
      name: string;
      kind: number;
      target: number;
      power: string;
      damage_type: number;
      is_ultimate: number;
    }
    
    export interface SkillEffect {
      skill_id: number;
      seq: number;
      effect_code: string;
      value: string;
      duration: number;
    }
    
    export interface StatusEffect {
      code: string;
      name: string;
      value_kind: number;
      is_debuff: number;
      icon_key: string;
    }
    
    export interface HeroLevelCurve {
      level: number;
      need_materials: number;
      need_gold: number;
      stat_multiplier: string;
    }
    
    export interface PlayerLevelCurve {
      player_lv: number;
      need_exp: number;
      stamina_max: number;
    }
    
    export interface ElementAffinity {
      attacker_element: number;
      defender_element: number;
      multiplier: string;
    }
    
    /** 配信される enemy にはステータス(base_* / skill_id)が無い */
    export interface Enemy {
      id: number;
      name: string;
      element: number;
      role: number;
      is_boss: number;
    }
    
    export interface 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;
    }
    
    /** 配信される stage_enemy には enemy_level が無い */
    export interface StageEnemy {
      stage_id: number;
      sort_no: number;
      enemy_id: number;
    }
    
    export interface GachaPool {
      id: number;
      name: string;
      cost_single: number;
      cost_ten: number;
      ceiling_count: number;
    }
    
    export interface GachaPoolEntry {
      pool_id: number;
      hero_id: number;
      weight: number;
      is_pickup: number;
    }
    
    export interface GachaPoolRate {
      pool_id: number;
      rarity_id: number;
      rate_permille: number;
    }
    
    export interface Item {
      id: number;
      name: string;
      kind: number;
      value: number;
      price: number;
      sort_no: number;
    }
    
    export interface Shop {
      id: number;
      item_id: number;
      amount: number;
      price: number;
      daily_limit: number;
      sort_no: number;
    }
    
    /** 配信されるのは許可されたキーの行だけ。全件は来ない */
    export interface GameConfig {
      config_key: string;
      value_num: string;
      description: string;
    }
    
    /** GET /master が返すJSONそのもの */
    export interface MasterPayload {
      version: string;
      rarity: Rarity[];
      hero: Hero[];
      skill: Skill[];
      skill_effect: SkillEffect[];
      status_effect: StatusEffect[];
      hero_level_curve: HeroLevelCurve[];
      player_level_curve: PlayerLevelCurve[];
      element_affinity: ElementAffinity[];
      enemy: Enemy[];
      stage: Stage[];
      stage_enemy: StageEnemy[];
      gacha_pool: GachaPool[];
      gacha_pool_entry: GachaPoolEntry[];
      gacha_pool_rate: GachaPoolRate[];
      item: Item[];
      shop: Shop[];
      game_config: GameConfig[];
    }

    src/master/store.ts

    // 受け取ったマスタをメモリに載せる。クラスは作らず、引く形に合わせた Map を持つだけ。
    import { apiGet } from '../api/client';
    import type { Hero, MasterPayload, Rarity } from './types';
    
    export interface MasterStore {
      version: string;
      /** hero の配信順(sort_no 昇順)そのまま。一覧表示はこれを回す */
      heroes: Hero[];
      heroById: Map<number, Hero>;
      rarityById: Map<number, Rarity>;
      // 必要になったものから足す。最初から全部やらない
    }
    
    /** GET /master。トークンが無効なら 401 が返る */
    export function fetchMaster(token: string): Promise<MasterPayload> {
      return apiGet<MasterPayload>('/master', token);
    }
    
    function indexById<T extends { id: number }>(rows: readonly T[]): Map<number, T> {
      return new Map(rows.map((row) => [row.id, row]));
    }
    
    export function buildMasterStore(payload: MasterPayload): MasterStore {
      return {
        version: payload.version,
        heroes: payload.hero,
        heroById: indexById(payload.hero),
        rarityById: indexById(payload.rarity),
      };
    }

    src/master/codes.ts

    // サーバは数値コード、プロトから移植した3Dは文字列を受け取る。その変換をここにまとめる。
    // ui/three/ 側は改変しない。合わせるのはこちらの役目。
    import type { HeroLook } from '../ui/three/models/buildHero';
    import type { Hero } from './types';
    
    type Role = HeroLook['role'];
    type Element = HeroLook['element'];
    type RarityLook = HeroLook['rarity'];
    
    /**
     * rarity_id → 3Dの見た目。
     * buildHero は SR までしか想定していないので、SSR は SR の見た目で描く(本対応は次回以降)
     */
    const RARITY_LOOK: Record<number, RarityLook> = {
      0: 'N',
      1: 'R',
      2: 'SR',
      3: 'SR',
    };
    
    const ROLE_LOOK: Record<number, Role> = {
      1: 'melee',
      2: 'ranged',
      3: 'mage',
      4: 'healer',
      5: 'support',
    };
    
    const ELEMENT_LOOK: Record<number, Element> = {
      1: '火',
      2: '水',
      3: '風',
    };
    
    // 知らない値が来ても描画は止めない。既定値に倒して描く
    const DEFAULT_RARITY: RarityLook = 'N';
    const DEFAULT_ROLE: Role = 'melee';
    const DEFAULT_ELEMENT: Element = '火';
    
    /** 属性の表示名。3Dが受け取る文字列と同じものを画面にも出す */
    export function elementLabel(element: number): Element {
      return ELEMENT_LOOK[element] ?? DEFAULT_ELEMENT;
    }
    
    /** ヒーロー1体を3Dの見た目に変換する */
    export function toHeroLook(hero: Hero): HeroLook {
      return {
        role: ROLE_LOOK[hero.role] ?? DEFAULT_ROLE,
        element: ELEMENT_LOOK[hero.element] ?? DEFAULT_ELEMENT,
        rarity: RARITY_LOOK[hero.rarity_id] ?? DEFAULT_RARITY,
      };
    }

    src/storage/token.ts

    // 端末キーとトークンの localStorage 読み書き。
    //
    // 暗号化も難読化もしない。ブラウザで動く以上、隠しても意味がないため。
    // 盗まれて困らないよう、サーバ側でトークンに期限を付けてある。
    
    const DEVICE_KEY = 'hc_device_key';
    const TOKEN_KEY = 'hc_token';
    
    /** 端末キーを読む。無ければ作って保存する。同じ端末なら同じユーザーに繋がる */
    export function loadOrCreateDeviceKey(): string {
      const saved = localStorage.getItem(DEVICE_KEY);
      if (saved !== null) return saved;
    
      const created = crypto.randomUUID();
      localStorage.setItem(DEVICE_KEY, created);
      return created;
    }
    
    export function loadToken(): string | null {
      return localStorage.getItem(TOKEN_KEY);
    }
    
    export function saveToken(token: string): void {
      localStorage.setItem(TOKEN_KEY, token);
    }
    
    /** トークンを捨てる。401 が返って取り直すときに使う */
    export function clearToken(): void {
      localStorage.removeItem(TOKEN_KEY);
    }

    src/ui/screens/LoadingScreen.tsx

    // 通信中の表示。演出は付けない。待たせていることが分かればよい。
    export function LoadingScreen({ message }: { message: string }) {
      return (
        <div className="screenBody">
          <div className="centerWrap">
            <div className="bootText">{message}</div>
          </div>
        </div>
      );
    }

    src/ui/screens/HeroListScreen.tsx

    // 受け取ったマスタの確認用。暫定の画面なのでデザインは作り込まない。
    // マスタが届いていること(版・件数・中身)が分かればよい。
    import { elementLabel } from '../../master/codes';
    import type { MasterStore } from '../../master/store';
    
    export function HeroListScreen({ master }: { master: MasterStore }) {
      return (
        <div className="screenBody bootScreen">
          <div className="heroListWrap">
            <div className="secTitle">
              ヒーロー一覧(マスタ確認用) master {master.version} / {master.heroes.length}体
            </div>
            <div className="heroList">
              {master.heroes.map((hero) => {
                const rarityCode = master.rarityById.get(hero.rarity_id)?.code ?? '?';
                return (
                  <div className="heroRow panel" key={hero.id}>
                    <span className={`rarBadge ${rarityCode}`}>{rarityCode}</span>
                    <span className="charName">{hero.name}</span>
                    <span className="heroElement">{elementLabel(hero.element)}</span>
                  </div>
                );
              })}
            </div>
          </div>
        </div>
      );
    }
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ