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

ソシャゲのサーバーを作る。ヒーロー一覧とデッキ編成(13)

    前回はガチャを作りました。

    引いたヒーローは、デッキの空き枠に自動で入る作りでしたね。
    編成画面が無かったので、そうするしかなかったというのもあります。

    今回はそのデッキを、自分で組めるようにします。

    一覧は全件返す

    編成画面には、持っているヒーローが全部並びます。
    なのでまず、所持ヒーローを返すAPIが要ります。

    11本目で、ホームAPIから所持ヒーローを外しました。
    「それぞれの画面のAPIで返せばいい」と書いたのが、ここですね。

    GET /user/heroes

    ページングはしていません。全件返します。

    1体あたりに返すのはこれだけなので。

    { "user_hero_id": 102, "hero_id": 11, "level": 1, "exp": 0 }

    500体持っていても30KBほどです。
    画面を開くたびに1回なら、分けて取るほうが手間が増えます。

    ただ、所持に上限が無いのは気になっています。

    実際のソシャゲには、たいてい所持枠があります。

    一覧が重くならないようにする意味もあります。
    このゲームは重複入手もそのまま1体として増えるので、
    引き続けると行は増える一方です。

    いまは上限を入れていません。
    困るくらい増えたら、そのときに考えます(汗)

    名前もステータスも返さない

    返しているのは、IDとレベルと経験値だけです。

    名前もレアリティもステータスも、
    `hero_id` が分かればクライアントがマスタから引けます。

    並び順もクライアントで決めています。
    レアリティの高い順、レベルの高い順。
    サーバは入手順に返すだけです。

    並び替えの切り替えを付けるときも、サーバは何も変わりません。

    ステータスはクライアントが計算する

    カードにはHPやATKが出ます。
    これもサーバは返さないので、クライアントが計算します。

    HP = 基礎値 × レアリティ倍率 × レベル倍率

    倍率はどちらもマスタに入っていて、型は `DECIMAL` です。
    7本目でマスタを一式そろえたときに、そう定義しました。

    ここで1つ気をつけることがあります。
    この計算は、バトルの回でサーバにも同じものを置くんですよね。

    画面ではATK 47と出ているのに、戦闘ではATK 46で計算されている。
    こうなると、プレイヤーには確かめようがありません。

    浮動小数で掛けると、こういうことが起きます。

    5 × 2.50 × 1.16 = 14.5         ← 本当の値。四捨五入で 15
    5 × 2.50 × 1.16 = 14.4999...   ← 浮動小数で計算した値。四捨五入で 14

    なので倍率は、文字列のまま受け取って整数に直してから掛けています。
    `"2.50"` なら `25000`、`"1.16"` なら `11600`。
    全部掛けてから最後に割るので、途中で誤差が入りません。

    実際のヒーローで計算するとこうなります。
    SSRの雷刃の剣聖アルドを、Lv10にした場合です。

    HP  = 135 × 2.35 × 1.72 = 545.67  → 546
    ATK =  42 × 2.35 × 1.72 = 169.764 → 170
    SPD =  15 × 2.35        =  35.25  →  35   ← SPDはレベルで伸ばさない

    画面に出ているカードも、同じ式で計算しています。
    たとえばRの蒼弓の狙撃手は、ATKの基礎値が33。
    Lv1なのでレベル倍率は1倍で、33 × 1.35 = 44.55、四捨五入で45です。

    ちなみに、いまのマスタで全ヒーロー・全レベルを浮動小数と比べてみたら、
    ずれは1件もありませんでした。
    上の例は、レアリティ倍率を 2.50 にしたらという仮の数字です。

    いまずれないのは、たまたまですね。
    企画が倍率を1つ変えたら出てくるかもしれない。
    なので最初から、ずれない計算にしておきます。

    編成は丸ごと送る

    デッキを保存するAPIです。

    POST /user/deck
    { "deck_id": 1, "slots": [101, null, 102, null] }

    送り方は2通り考えられます。

    差分  「2枠目に 102 を入れる」
    全体  「デッキはこの4つ」

    全体で送ることにしました。

    差分だと、同じリクエストが2回届いたときに困ります。
    「入れる」と「外す」が混ざると、届いた順番でも結果が変わる。

    全体なら、同じものを何回送っても同じ結果になります。
    前回、通信が切れて同じリクエストがもう1回届く話を書きました。
    編成はこの形にしておけば、そもそも問題になりません。

    保存するときは、そのデッキの行を消してから入れ直しています。
    空き枠は行を作らない、と10本目で決めたので、
    外した枠の行は消す必要があるんですよね。

    送られてきた個体を疑う

    `slots` に入ってくるのは `user_hero_id` です。
    クライアントから来た値なので、そのままは書き込みません。

    • そのユーザーが持っている個体か

    • 同じ個体が2枠に入っていないか

    • 枠の数が合っているか

    持っているかどうかは、1クエリで確かめています。

    SELECT `user_hero_id` FROM `user_hero`
      WHERE `user_id` = ? AND `user_hero_id` IN (?, ?, ...)

    返ってきた件数が、送られてきた数と合わなければ弾く。

    11本目では、ホームに立たせる個体を引くときに `user_id` を条件に入れました。
    あれは読むときの話でしたが、今回は書くときです。
    ここで他人の個体を通すと、他人のヒーローで戦えてしまいます。

    同じ個体が2枠、というのもDBの制約では防いでいません。
    10本目でテーブルを作ったときに「アプリ側で弾く」としていたのが、ここですね。

    1タップで1回送る

    プロトの編成画面は、タップするとその場で出し入れされます。
    この手触りはそのまま残しました。

    なので、タップするたびにデッキ全体を送っています。

    「決定」ボタンを置いて、まとめて送る形もあります。
    ただそれだと、決定を押さずに画面を離れたときの扱いを決めないといけない。
    編成はそう頻繁に触るものでもないので、1回ずつ送ることにしました。

    送っている間はタップを受け付けません。

    失敗したときは、前回のガチャと同じ考え方です。
    保存できたかどうかは分からないので、表示を元に戻すのではなく、
    サーバから編成を取り直して、それを出します。

    戻してしまうと、実は保存できていた場合に画面とサーバがずれるんですよね。
    取り直せば、画面に出ているのが必ずサーバの状態になります。

    ここで全体を送る形が効いてきます。
    取り直した状態からもう一度タップしても、送るのはデッキ全体なので、
    途中の状態が混ざって壊れることがありません。

    画面を先に変えてから送る、という作りもよくあります。
    押した瞬間に反応するので、気持ちいいんですよね。
    ただ失敗したときに「戻る」動きが出るので、今回は応答を待ってから変えています。

    先頭が空いたら

    1枠目のヒーローだけ外したら、どうなるか。

    ホームには「デッキの先頭」を立たせていたので、
    そのままだとホームが「まだ仲間がいません」に戻ります。
    2枠目以降にはちゃんといるのに。

    前に詰めて保存する、という手もあります。
    ただそれだと、置いた位置が勝手に変わってしまう。

    なのでホームのほうを直しました。
    `slot_no` が0の個体、ではなく、一番前にいる個体を立たせます。

    SELECT `user_hero_id` FROM `user_deck`
      WHERE `user_id` = ? AND `deck_id` = ? AND `slot_no` < ?
      ORDER BY `slot_no` LIMIT 1

    全員外したら、そのときは「まだ仲間がいません」です。
    空のデッキでバトルに出られるかどうかは、次回決めます。

    画面は移植

    編成画面はプロトから移植しました。
    左に選んだヒーローの3D、右上にデッキ、右下に所持一覧。

    画像
    デッキ編成

    カード右上の数字は、デッキの何枠目に入っているかです。
    所持一覧はレアリティの高い順に並んでいます。

    強化ボタンも付いていますが、押しても何も起きません。
    素材とゴールドを使うので、ショップと一緒に作る回で繋ぎます。

    動かす

    1枠目の新米僧侶を外してみます。

    画像
    1枠目を外したデッキ編成画面

    枠は詰めずに、1枠目が空いたまま残ります。
    この状態でホームに戻ると、

    画像
    2番目のキャラがホーム画面で表示

    2枠目の見習い剣士が立っています。
    先頭が空いても「まだ仲間がいません」には戻りません。

    リロードしても、組んだデッキはそのまま残っています。

    今回はここまで

    • 所持一覧は全件返す。所持上限はまだ無い

    • 名前・ステータス・並び順はクライアント

    • ステータスの計算は整数で。バトルの回でサーバにも同じ式を置く

    • 編成は差分ではなく全体を送る。何回送っても同じ結果

    • 送られてきた個体は、持ち主と重複を確かめる

    • 失敗したら元に戻さず、サーバから取り直す

    • ホームには一番前の個体を立たせる

    次回はステージ選択とバトルです。

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

    コード

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

    routes/deck.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { Connection, PoolConnection, RowDataPacket } from "mysql2/promise";
    import { userPool, withUserTransaction } from "../db.ts";
    import { selectStatusForUpdate } from "../user/status.ts";
    import { configNumber } from "../master/config.ts";
    import { GAME_CONFIG_KEY } from "../constants.ts";
    import { readArrayField, readIntegerField, readJsonBody, sendError, sendJson } from "../http.ts";
    
    // 使用中デッキの取得と保存。
    //
    // デッキは「スロットごとに1行、空き枠は行が無い」形で持っているが、
    // APIでは長さ deck_size の配列(空き枠は null)にして、位置をそのまま添字で表す。
    // 保存は差分ではなく全体の置き換え。同じ内容を2回送っても結果が変わらない
    
    /** デッキ1つ分。slots の添字が slot_no、空き枠は null */
    type DeckResponse = {
      deck_id: number;
      slots: (number | null)[];
    };
    
    /**
     * 保存の結果。
     *
     * 「持っていない個体が入っていた」は例外ではなく起きうる結果なので、
     * 種類として返してハンドラ側で振り分ける(ガチャの DrawOutcome と同じ形)
     */
    type SaveOutcome =
      | { kind: "ok"; response: DeckResponse }
      | { kind: "invalidDeck" }
      | { kind: "invalidHero" }
      | { kind: "userNotFound" };
    
    /** GET /user/deck — 使用中のデッキを返す */
    export async function handleDeck(
      _req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const deckId = await selectActiveDeckId(userId);
      if (deckId === null) {
        // セッションは生きているのに user_status がいない。通常は起きない
        sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
        return;
      }
    
      sendJson(res, 200, {
        deck_id: deckId,
        slots: await selectSlots(userPool, userId, deckId),
      });
    }
    
    /**
     * POST /user/deck — デッキを丸ごと置き換える。
     *
     * 形の検証(長さ・要素の型・重複)はDBを触る前に済ませる。
     * 所持しているかどうかだけは、他のトランザクションで増減しうるので中で見る
     */
    export async function handleSaveDeck(
      req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const body = await readJsonBody(req);
    
      const deckId = readIntegerField(body, "deck_id");
      if (deckId === null) {
        sendError(res, 400, "INVALID_DECK", "deck_id が不正");
        return;
      }
    
      const slots = readSlots(body);
      if (slots === null) {
        sendError(res, 400, "INVALID_SLOTS", "slots の形が不正");
        return;
      }
    
      // 同じ個体を2枠には入れられない。null は何個あってもよい
      const userHeroIds = slots.filter((slot) => slot !== null);
      if (new Set(userHeroIds).size !== userHeroIds.length) {
        sendError(res, 400, "DUPLICATE_HERO", "同じ個体が2枠以上に入っている");
        return;
      }
    
      const outcome = await withUserTransaction((conn) =>
        saveDeck(conn, userId, deckId, slots, userHeroIds),
      );
    
      // ここから先は例外を投げうる処理を置かない。
      // コミット済みなのに 500 を返す(保存できているのに失敗に見える)状態を作らないため
      if (outcome.kind === "userNotFound") {
        sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
        return;
      }
      if (outcome.kind === "invalidDeck") {
        sendError(res, 400, "INVALID_DECK", "使用中のデッキではない");
        return;
      }
      if (outcome.kind === "invalidHero") {
        sendError(res, 400, "INVALID_HERO", "所持していない個体が入っている");
        return;
      }
    
      sendJson(res, 200, outcome.response);
    }
    
    /**
     * ボディの slots を検証して取り出す。形が違えば null。
     *
     * 長さは deck_size ちょうど。要素は「正の整数」か null だけで、
     * 前詰めもしないし、余った分を捨てたりもしない
     */
    function readSlots(body: unknown): (number | null)[] | null {
      const raw = readArrayField(body, "slots");
      if (raw === null || raw.length !== configNumber(GAME_CONFIG_KEY.DECK_SIZE)) return null;
    
      const slots: (number | null)[] = [];
      for (const value of raw) {
        if (value === null) {
          slots.push(null);
          continue;
        }
        if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
        slots.push(value);
      }
      return slots;
    }
    
    /**
     * デッキを置き換える。
     *
     * 行ロックの順番は user_status → user_deck で固定する(ガチャと同じ順)。
     * user_status を先に押さえているので、同じユーザーの編成とガチャは順番に処理される
     */
    async function saveDeck(
      conn: PoolConnection,
      userId: number,
      deckId: number,
      slots: readonly (number | null)[],
      userHeroIds: readonly number[],
    ): Promise<SaveOutcome> {
      const status = await selectStatusForUpdate(conn, userId);
      if (status === null) return { kind: "userNotFound" };
    
      // 編集できるのは使用中のデッキだけ。デッキの切り替えはまだ無い
      if (deckId !== status.activeDeckId) return { kind: "invalidDeck" };
    
      // 他人の個体を入れられないよう、user_id 込みで引き当てる
      const owned = await selectOwnedUserHeroIds(conn, userId, userHeroIds);
      if (owned.size !== userHeroIds.length) return { kind: "invalidHero" };
    
      await conn.execute("DELETE FROM `user_deck` WHERE `user_id` = ? AND `deck_id` = ?", [
        userId,
        deckId,
      ]);
    
      for (const [slotNo, userHeroId] of slots.entries()) {
        if (userHeroId === null) continue;
        await conn.execute(
          "INSERT INTO `user_deck` (`user_id`, `deck_id`, `slot_no`, `user_hero_id`)" +
            " VALUES (?, ?, ?, ?)",
          [userId, deckId, slotNo, userHeroId],
        );
      }
    
      // 返すのは保存した内容そのもの。コミットの後にDBを引き直さない
      return { kind: "ok", response: { deck_id: deckId, slots: [...slots] } };
    }
    
    /** 使用中のデッキID。user_status が無ければ null */
    async function selectActiveDeckId(userId: number): Promise<number | null> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `active_deck_id` FROM `user_status` WHERE `user_id` = ?",
        [userId],
      );
    
      const row = rows[0];
      return row === undefined ? null : Number(row.active_deck_id);
    }
    
    /**
     * デッキの中身を長さ deck_size の配列にする。
     *
     * 読むだけなので、プール(GET)からもトランザクション中のコネクションからも呼べるよう
     * 引数は Connection で受ける。Pool も PoolConnection もこれを満たす。
     *
     * 枠数を減らしたあとに残っている行(slot_no が deck_size 以上)は返さない。
     * 持っていない個体を指している行も null に倒す
     */
    async function selectSlots(
      conn: Connection,
      userId: number,
      deckId: number,
    ): Promise<(number | null)[]> {
      const deckSize = configNumber(GAME_CONFIG_KEY.DECK_SIZE);
    
      const [rows] = await conn.execute<RowDataPacket[]>(
        "SELECT `slot_no`, `user_hero_id` FROM `user_deck`" +
          " WHERE `user_id` = ? AND `deck_id` = ? AND `slot_no` < ?",
        [userId, deckId, deckSize],
      );
    
      const owned = await selectOwnedUserHeroIds(
        conn,
        userId,
        rows.map((row) => Number(row.user_hero_id)),
      );
    
      const slots: (number | null)[] = new Array(deckSize).fill(null);
      for (const row of rows) {
        const userHeroId = Number(row.user_hero_id);
        if (owned.has(userHeroId)) slots[Number(row.slot_no)] = userHeroId;
      }
      return slots;
    }
    
    /**
     * 渡した user_hero_id のうち、そのユーザーが実際に持っているものだけを返す。
     * 1件ずつ確認せず、IN で1回だけ引く
     */
    async function selectOwnedUserHeroIds(
      conn: Connection,
      userId: number,
      userHeroIds: readonly number[],
    ): Promise<Set<number>> {
      if (userHeroIds.length === 0) return new Set();
    
      // プレースホルダの数だけを件数から組み立てる。値はすべて ? 経由で渡す
      const placeholders = userHeroIds.map(() => "?").join(", ");
      const [rows] = await conn.execute<RowDataPacket[]>(
        "SELECT `user_hero_id` FROM `user_hero`" +
          ` WHERE \`user_id\` = ? AND \`user_hero_id\` IN (${placeholders})`,
        [userId, ...userHeroIds],
      );
    
      return new Set(rows.map((row) => Number(row.user_hero_id)));
    }

    routes/user.ts(追加分のみ)

    /**
     * GET /user/heroes — 所持ヒーローを全件返す。
     *
     * ページングはしない。所持上限を作るまでは全件返しても数が知れている。
     * 返すのはIDとレベルだけ。名前もレアリティもクライアントがマスタから引く
     */
    export async function handleUserHeroes(
      _req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `user_hero_id`, `hero_id`, `level`, `exp` FROM `user_hero`" +
          " WHERE `user_id` = ? ORDER BY `user_hero_id`",
        [userId],
      );
    
      sendJson(res, 200, {
        heroes: rows.map((row) => ({
          user_hero_id: Number(row.user_hero_id),
          hero_id: Number(row.hero_id),
          level: Number(row.level),
          exp: Number(row.exp),
        })),
      });
    }

    routes/home.ts(変更した関数のみ)

    /**
     * 使用中デッキで一番前に入っている個体。1人も入っていなければ null。
     *
     * 先頭が空いていても次の枠を見る。1枠目だけ外したときに
     * ホームが「まだ仲間がいません」に戻らないようにするため。
     * 枠数を減らした後に残っている行(slot_no が deck_size 以上)は見ない
     */
    async function selectDeckLeadUserHeroId(
      conn: PoolConnection,
      userId: number,
      deckId: number,
    ): Promise<number | null> {
      const [rows] = await conn.execute<RowDataPacket[]>(
        "SELECT `user_hero_id` FROM `user_deck`" +
          " WHERE `user_id` = ? AND `deck_id` = ? AND `slot_no` < ?" +
          " ORDER BY `slot_no` LIMIT 1",
        [userId, deckId, configNumber(GAME_CONFIG_KEY.DECK_SIZE)],
      );
    
      const row = rows[0];
      return row === undefined ? null : Number(row.user_hero_id);
    }

    master/stats.ts

    // カードに出す HP / ATK / DEF / SPD の計算。
    //
    // **この式はバトルの回でサーバにも同じものを置く。** 表示と戦闘の数値が食い違わないよう、
    // 式と丸めをここで固定する。
    //
    // 倍率は DECIMAL なので文字列で来る("1.80")。Number() で浮動小数にして掛けると
    // 環境によって最後の桁がずれるので、万分率の整数に直してから整数のまま計算する。
    import type { Hero, HeroLevelCurve, Rarity } from './types';
    
    /** 倍率の分母。1倍 = 10000 */
    const PERMYRIAD = 10000;
    
    /** 倍率を2つ掛けた状態の分母 */
    const PERMYRIAD_SQUARED = PERMYRIAD * PERMYRIAD;
    
    /** 小数部の桁数。DECIMAL(6,4) に合わせる */
    const FRACTION_DIGITS = 4;
    
    /** カードに出すステータス */
    export interface HeroStats {
      hp: number;
      atk: number;
      def: number;
      spd: number;
    }
    
    /**
     * "1.80" → 18000、"1.0800" → 10800。
     *
     * parseFloat は経由しない。文字列を小数点で分けて、整数として組み立てる
     */
    export function toPermyriad(decimal: string): number {
      const [integer, fraction = ''] = decimal.split('.');
      // 小数部は4桁に揃える。足りなければ0で埋め、多ければ落とす
      const digits = `${fraction}0000`.slice(0, FRACTION_DIGITS);
      return Number(integer) * PERMYRIAD + Number(digits);
    }
    
    /**
     * 1体分のステータス。
     *
     *   HP / ATK / DEF = base × レアリティ倍率 × レベル倍率
     *   SPD            = base × レアリティ倍率          ← レベルでは伸ばさない
     *
     * 丸めは四捨五入。マスタに行が無ければ倍率は1倍として、描画は止めない
     */
    export function heroStats(
      hero: Hero,
      rarity: Rarity | undefined,
      levelCurve: HeroLevelCurve | undefined,
    ): HeroStats {
      const rarityMul = rarity === undefined ? PERMYRIAD : toPermyriad(rarity.stat_multiplier);
      const levelMul =
        levelCurve === undefined ? PERMYRIAD : toPermyriad(levelCurve.stat_multiplier);
    
      return {
        hp: withLevel(hero.base_hp, rarityMul, levelMul),
        atk: withLevel(hero.base_atk, rarityMul, levelMul),
        def: withLevel(hero.base_def, rarityMul, levelMul),
        spd: withoutLevel(hero.base_spd, rarityMul),
      };
    }
    
    /**
     * 倍率2つを掛けて四捨五入する。
     * 値はすべて正なので、分母の半分を足してから切り捨てれば四捨五入と同じ結果になる
     */
    function withLevel(base: number, rarityMul: number, levelMul: number): number {
      return Math.floor((base * rarityMul * levelMul + PERMYRIAD_SQUARED / 2) / PERMYRIAD_SQUARED);
    }
    
    /** レアリティ倍率だけを掛けて四捨五入する */
    function withoutLevel(base: number, rarityMul: number): number {
      return Math.floor((base * rarityMul + PERMYRIAD / 2) / PERMYRIAD);
    }

    api/deck.ts

    // 所持ヒーローの一覧と、使用中デッキの取得・保存。
    import { apiGet, apiPost } from './client';
    
    /** 所持ヒーロー1体。名前もステータスも来ないので、hero_id でマスタを引く */
    export interface UserHero {
      user_hero_id: number;
      hero_id: number;
      level: number;
      exp: number;
    }
    
    /** デッキ1つ分。slots の添字が slot_no(0始まり)、空き枠は null */
    export interface DeckResponse {
      deck_id: number;
      slots: (number | null)[];
    }
    
    /** GET /user/heroes。ページングは無いので全件そのまま返る */
    export async function fetchUserHeroes(token: string): Promise<UserHero[]> {
      return (await apiGet<{ heroes: UserHero[] }>('/user/heroes', token)).heroes;
    }
    
    /** GET /user/deck。使用中のデッキだけ。切り替えはまだ無い */
    export function fetchDeck(token: string): Promise<DeckResponse> {
      return apiGet<DeckResponse>('/user/deck', token);
    }
    
    /**
     * POST /user/deck。
     * 差分ではなくデッキ全体を送って全体を置き換える。同じ内容を2回送っても結果は変わらない
     */
    export function postDeck(
      token: string,
      deckId: number,
      slots: readonly (number | null)[],
    ): Promise<DeckResponse> {
      return apiPost<DeckResponse>('/user/deck', { deck_id: deckId, slots }, token);
    }

    ui/screens/DeckScreen.tsx

    // 編成画面:デッキの枠+所持一覧+強化ボタン。左に選択中の個体の3Dプレビュー。プロトから移植。
    //
    // プロトはローカルの UserData を見ていたが、ここでは GET /user/heroes と GET /user/deck で取る。
    // タップのたびに、変更後のデッキ全体を POST /user/deck で保存する。
    //
    // 画面を先に変えて後から送る(楽観的更新)はしない。サーバが返した状態だけを映す。
    // 失敗したときは「保存できたかどうか分からない」ものとして、デッキを取り直す
    import { useEffect, useState, type MouseEvent } from 'react';
    import { fetchDeck, fetchUserHeroes, postDeck, type UserHero } from '../../api/deck';
    import { elementLabel, roleIcon, toHeroLook } from '../../master/codes';
    import { heroStats } from '../../master/stats';
    import type { MasterStore } from '../../master/store';
    import { LoadingScreen } from './LoadingScreen';
    import { Stage, CameraRig } from '../three/Stage';
    import { CharacterModel } from '../three/CharacterModel';
    
    /** 保存に失敗したときの文言。保存できたかどうかはクライアントには分からない */
    const SAVE_FAILED_MESSAGE = '通信に失敗しました。いまの編成を表示しています';
    
    /**
     * カード1枚。デッキの枠にも所持一覧にも同じものを使う。
     *
     * 出るのは user_hero_id・hero_id・レベルだけなので、
     * 名前もレアリティもステータスもマスタから引いて組み立てる
     */
    function HeroCard({
      userHero,
      master,
      slot,
      selected,
      onTap,
    }: {
      userHero: UserHero;
      master: MasterStore;
      /** デッキ内の位置(0始まり)。入っていなければ -1 */
      slot: number;
      selected: boolean;
      onTap: () => void;
    }) {
      const hero = master.heroById.get(userHero.hero_id);
      if (hero === undefined) return null;
    
      const rarity = master.rarityById.get(hero.rarity_id);
      const rarityCode = rarity?.code ?? '';
      const curve = master.heroLevelCurveByLevel.get(userHero.level);
      const stats = heroStats(hero, rarity, curve);
    
      // 強化はショップと強化の回で繋ぐ。今は押しても何も起きない。
      // カードのタップ(デッキの出し入れ)まで道連れにしないよう、伝播だけ止める
      const upgrade = (event: MouseEvent) => {
        event.stopPropagation();
      };
    
      return (
        <div
          className={`heroCard ${rarityCode} ${selected || slot >= 0 ? 'sel' : ''}`}
          onClick={onTap}
        >
          <span className="rar">{rarityCode}</span>
          {slot >= 0 && <span className="slot">{slot + 1}</span>}
          <div className="roleIc">{roleIcon(hero.role)}</div>
          <div className="nm">{hero.name}</div>
          <div className="lvline">Lv.{userHero.level}・HP{stats.hp}・ATK{stats.atk}</div>
          <div className="tags">
            <span className={`tag el-${elementLabel(hero.element)}`}>{elementLabel(hero.element)}</span>
            <span className="tag">SPD{stats.spd}</span>
          </div>
          <button className="upBtn" onClick={upgrade}>
            強化(🔨{curve?.need_materials ?? 0}・🪙{curve?.need_gold ?? 0})
          </button>
        </div>
      );
    }
    
    /** レアリティの sort_no。マスタに無ければ 0(一覧の最後に回る) */
    function raritySortNo(master: MasterStore, heroId: number): number {
      const hero = master.heroById.get(heroId);
      if (hero === undefined) return 0;
      return master.rarityById.get(hero.rarity_id)?.sort_no ?? 0;
    }
    
    /** 所持一覧の並び。レアリティの降順 → レベルの降順 → 入手順 */
    function sortOwned(heroes: readonly UserHero[], master: MasterStore): UserHero[] {
      return [...heroes].sort(
        (a, b) =>
          raritySortNo(master, b.hero_id) - raritySortNo(master, a.hero_id) ||
          b.level - a.level ||
          a.user_hero_id - b.user_hero_id,
      );
    }
    
    export function DeckScreen({
      token,
      master,
      deckId,
      onFail,
    }: {
      token: string;
      master: MasterStore;
      /** 編集するデッキ。使用中のものだけで、切り替えはまだ無い */
      deckId: number;
      /** 最初の取得に失敗したとき。再試行は起動からやり直す */
      onFail: (error: unknown) => void;
    }) {
      // heroes が null の間は取得中。所持一覧とデッキは持ち回らず、画面を開くたびに取り直す
      const [heroes, setHeroes] = useState<UserHero[] | null>(null);
      const [slots, setSlots] = useState<readonly (number | null)[]>([]);
      // 保存中は一覧もデッキもタップを受け付けない
      const [busy, setBusy] = useState(false);
      const [message, setMessage] = useState<string | null>(null);
      const [selectedUserHeroId, setSelectedUserHeroId] = useState<number | null>(null);
    
      useEffect(() => {
        Promise.all([fetchUserHeroes(token), fetchDeck(token)]).then(([owned, deck]) => {
          setHeroes(owned);
          setSlots(deck.slots);
        }, onFail);
        // 開いた時に1度だけ取る。以後はタップの応答で差し替える
      }, [token, onFail]);
    
      if (heroes === null) return <LoadingScreen message="読み込み中…" />;
    
      const sorted = sortOwned(heroes, master);
      // プレビューの初期選択はデッキの一番前。いなければ所持一覧の先頭
      const defaultUserHeroId = slots.find((slot) => slot !== null) ?? sorted[0]?.user_hero_id ?? null;
      const selectedId = selectedUserHeroId ?? defaultUserHeroId;
      const selected = heroes.find((userHero) => userHero.user_hero_id === selectedId);
      const selectedHero = selected === undefined ? undefined : master.heroById.get(selected.hero_id);
      const selectedRarityCode =
        selectedHero === undefined ? '' : master.rarityById.get(selectedHero.rarity_id)?.code ?? '';
    
      /** 変更後のデッキ全体を保存する。応答が返ってから画面を変える */
      const save = async (next: readonly (number | null)[]) => {
        setBusy(true);
        setMessage(null);
        try {
          setSlots((await postDeck(token, deckId, next)).slots);
        } catch {
          // 保存できたかどうかは分からないものとして扱う。
          // サーバでは保存されていて、応答だけ届かなかった可能性がある。
          // 変更前に戻すのではなく、サーバにある状態を取り直して映す
          setMessage(SAVE_FAILED_MESSAGE);
          try {
            setSlots((await fetchDeck(token)).slots);
          } catch {
            // 取り直しにも失敗したら、タップを受け付けないままメッセージだけ出す。
            // 下部ナビで画面を出入りすれば取り直される
            return;
          }
        }
        setBusy(false);
      };
    
      /** カードのタップ。入っていれば外し、入っていなければ一番前の空き枠に入れる */
      const toggle = (userHeroId: number) => {
        if (busy) return;
        setSelectedUserHeroId(userHeroId);
    
        const slot = slots.indexOf(userHeroId);
        if (slot >= 0) {
          // 外した枠は空けたままにする。前詰めはしない
          void save(slots.map((value, index) => (index === slot ? null : value)));
          return;
        }
    
        const empty = slots.indexOf(null);
        if (empty < 0) {
          setMessage(`編成は${master.deckSize}人までです`);
          return;
        }
        void save(slots.map((value, index) => (index === empty ? userHeroId : value)));
      };
    
      return (
        <div className="screenBody deckBody">
          <div className="deckPreview">
            <div className="spot" />
            {selectedHero !== undefined ? (
              <>
                <Stage camera={{ position: [0, 1.35, 3.4], fov: 42 }}>
                  <CameraRig position={[0, 1.35, 3.4]} target={[0, 1.05, 0]} />
                  <CharacterModel look={{ kind: 'hero', ...toHeroLook(selectedHero) }} bob spin />
                </Stage>
                <div className="charLabel">
                  <span className={`rarBadge ${selectedRarityCode}`}>{selectedRarityCode}</span>
                  <span className="charName">{selectedHero.name}</span>
                </div>
              </>
            ) : (
              <div className="emptyChar">キャラを選ぶと<br />ここに表示されます</div>
            )}
          </div>
          <div className="deckRight">
            <div>
              <div className="secTitle">
                デッキ({master.deckSize}人) 
                <span style={{ color: 'var(--sub)', fontSize: 12 }}>タップで出し入れ</span>
              </div>
              <div className="deckSlots">
                {slots.map((userHeroId, index) => {
                  const userHero =
                    userHeroId === null
                      ? undefined
                      : heroes.find((owned) => owned.user_hero_id === userHeroId);
                  return userHero === undefined ? (
                    <div key={`slot${index}`} className="heroCard empty">+<div>枠{index + 1}</div></div>
                  ) : (
                    <HeroCard
                      key={`slot${index}`}
                      userHero={userHero}
                      master={master}
                      slot={index}
                      selected={false}
                      onTap={() => toggle(userHero.user_hero_id)}
                    />
                  );
                })}
              </div>
            </div>
            {message !== null && <div className="screenError">{message}</div>}
            <div className="secTitle" style={{ paddingBottom: 0 }}>所持キャラ({heroes.length})</div>
            <div className="ownList">
              {sorted.length === 0 ? (
                <div className="emptyMsg">まだキャラがいません。<br />ガチャを引いてみましょう。</div>
              ) : (
                sorted.map((userHero) => (
                  <HeroCard
                    key={userHero.user_hero_id}
                    userHero={userHero}
                    master={master}
                    slot={slots.indexOf(userHero.user_hero_id)}
                    selected={userHero.user_hero_id === selectedId}
                    onTap={() => toggle(userHero.user_hero_id)}
                  />
                ))
              )}
            </div>
          </div>
        </div>
      );
    }
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ