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

ソシャゲのサーバーを作る。ショップと強化(16)

    前回はバトルの報酬を作りました。

    ゴールドと素材が貯まるようになったので、今回は使う側です。
    ショップで買って、ヒーローを強化します。

    3回目で、まとめる

    先に、地味だけど今回いちばん効いた話から。

    ここまでで、通貨とアイテムの増減はこういう形で書いてきました。

    12本目(ガチャ)   ゴールドを引く    条件付きの UPDATE
    15本目(報酬)     ゴールドを足す    INSERT ... ON DUPLICATE KEY UPDATE
                       素材を足す        同上

    それぞれのハンドラの中に、直接書いてあります。

    今回、ショップで両方が要ります。
    買うときはゴールドを引いて、アイテムを足す。
    強化ではゴールドと素材を両方引く。

    ここで4つ目、5つ目を同じように書くと、同じSQLが散らばります。
    なので `user/inventory.ts` を作って、4つに整理しました。

    addCurrency    通貨を足す    行が無ければ作る、INT_MAXで頭打ち
    spendCurrency  通貨を引く    足りなければ false
    addItem        アイテムを足す
    spendItem      アイテムを引く

    中身は新しく書いていません。
    12本目と15本目で書いたSQLを、そのまま移しただけです。

    最初からこうしなかったのは、1回目や2回目では形が決まらないからですね。
    ガチャのときは「引く」しか無くて、しかもゴールド固定でした。
    報酬のときに「足す」が出てきて、行が無い場合の書き方が決まった。
    3回目でようやく、4つの組み合わせが見えます。

    早くまとめすぎると、あとから来た要件が入らない入れ物になります。
    遅すぎると、直すときに全部探して回ることになる。
    だいたい3回目がちょうどいい、というのが経験則ですね。

    値段はマスタ、送らない

    ショップの商品は `shop` テーブルに入っています。

    id=1  強化素材 ×5   15G
    id=2  回復剤   ×1   20G

    クライアントが送るのは `shop_id` だけです。
    値段も個数も、サーバがマスタから引きます。

    ガチャの「どのガチャを何回」と同じですね。
    金額をクライアントから受け取らないのは、この連載では何度目かの話になります。

    ちなみに `item` テーブルにも `price` の列があって、回復剤に20が入っていました。
    前回の「同じ意味の値が2つある」と同じですね。
    今回は `shop.price` を正にして、`item.price` は使いません。
    仕様書に「使っていない」と書き足しました。

    同じことが2回続いたので、そろそろマスタ側の整理も必要そうです。

    回復剤を使う

    買ったあとに「使う」があるのが、アイテムの面倒なところです。

    1. スタミナの時間回復を計算する
    2. もう上限なら、そこで止める
    3. 回復剤を1つ減らす
    4. スタミナを上限まで戻す

    上限のときに使えてしまうと、持っているものが減るだけになります。
    クライアントでもボタンを押せなくしていますが、サーバでも弾きます。

    回復量は `item.value` を見ています。
    `-1` なら全回復、正の数ならその分だけ。
    今回のマスタは `-1` しかありませんが、
    「小さい回復剤」を足すときにコードを触らずに済む形にしてあります。

    上限を超えて持っているときに減らさないのも、前回と同じですね。

    強化はロックの順番で書き方が決まった

    ヒーローのレベルを1つ上げる処理です。

    今のレベルの行から、必要な素材とゴールドを引く
    ゴールドを引く
    素材を引く
    レベルを1つ上げる

    素直に書くなら、最初に `user_hero` を `FOR UPDATE` で読んで、
    レベルとコストを確かめてから引きたくなります。

    ただ前回、ロックの順番を決めました。

    user_status → user_stage → user_currency → user_item → user_deck → user_hero

    `user_hero` は最後です。
    先に押さえてしまうと、この順に反します。

    なので、こうしました。

    1. トランザクションの外で user_hero を読む(レベルとコストの確認)
    2. ゴールドを引く
    3. 素材を引く
    4. レベルを条件付きで上げる
    UPDATE `user_hero` SET `level` = `level` + 1
      WHERE `user_id` = ? AND `user_hero_id` = ? AND `level` = ?

    読んだときのレベルを条件に入れています。
    その間に誰か(自分の2つ目のタブとか)が強化していたら、0行になる。
    そのときは例外でロールバックです。

    試しに、同じ個体の強化を5本同時に送ってみました。
    通ったのは1本だけで、残り4本は「レベルが変わっている」で弾かれます。
    引かれたコストと上がった段数も合っていました。

    ガチャでゴールドを引いたときと同じ形ですね。
    確かめてから書くのではなく、確かめながら書く。

    ロックの順番を先に決めておくと、こういうときに迷いません。
    「順番を守れる書き方はどれか」で、手が決まります。

    返さずに、取り直す

    買っても、使っても、強化しても、HUDの数字が変わります。

    12本目のガチャでは、引いた後の残高をレスポンスに入れていました。
    変わるのがゴールドだけだったので。

    今回は、通貨・アイテム・スタミナ・ヒーローのレベルと、あちこち動きます。
    全部返すと、APIごとに「何を返すか」を決めることになる。

    なので何も返さず、成功したらホームを取り直す形にしました。

    POST /shop/buy  →  { "item_id": 1, "amount": 5 }   入った中身だけ
                       成功したら GET /user/home

    HUDの出どころが1本になるので、表示がずれません。
    通信は1回増えますが、画面を開き直したときと同じ道を通るだけです。

    ガチャのほうは、そのままにしてあります。
    動いているものを揃え直すのは、今回やることではないので。

    買えるものを制限するなら

    `shop` テーブルには `daily_limit` という列があります。
    「1日に何個まで」ですね。

    今回は全部0(無制限)なので、使っていません。

    入れるとなると、リセットが何時なのかを決めることになります。
    日本時間の朝5時なのか、UTCの0時なのか。
    そして「その日にいくつ買ったか」をどこに持つか。

    ソシャゲだと、日付が変わる時刻はだいたい早朝です。
    深夜にプレイしている人の途中で切り替わらないように。

    このあたりは、ログインボーナスやデイリーミッションと同じ仕組みになります。
    今回は作らないので、また別の機会に。

    動かす

    ショップです。並んでいるのはマスタの2件だけですね。

    画像
    ショップ画面。素材9・ゴールド731

    強化素材を買うと、下に一行出ます。

    画像
    「強化素材 ×5 を購入」。素材が14に、ゴールドが716に

    回復剤も買っておきました。所持が1になって「使う」が押せます。

    画像
    回復剤の所持1、「使う」が押せる状態

    編成画面に移って、デッキ先頭の焔帝ヴァルカを強化します。
    いまは Lv1 で HP171・ATK72、コストは素材1・3G です。

    画像
    強化前。Lv1 HP171・ATK72、強化ボタンは 🔨1・🪙3

    押すとこうなります。
    表示が小さいので見えにくいですがレベルが上がってます。

    画像
    強化後。Lv2 HP185・ATK78、強化ボタンは 🔨2・🪙6

    強化するとステータスが上がります。
    13本目で、ステータスの計算をクライアントに置いたところですね。
    サーバはレベルを上げるだけで、表示はマスタから計算されます。

    もちろんバトルにも効きます。
    14本目で、バトル開始のときに味方のステータスを計算して渡す形にしたので、
    強化した分がそのまま数字に乗ります。

    今回はここまで

    • 通貨とアイテムの増減を `user/inventory.ts` に集約した(3回目でまとめた)

    • 値段も個数もマスタ。クライアントは商品のIDだけ送る

    • 回復剤は、上限のときに使えないようサーバでも弾く

    • 強化は、ロックの順番に合わせて「確かめながら書く」形に

    • 変わるものが増えたので、返さずにホームを取り直す

    • 購入制限は、日付の切り替え時刻を決めてからの話

    これで、ゲームとしてひと通り回るようになりました。

    次回は第二部のまとめです。

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

    コード

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

    api-server/src/user/inventory.ts

    import type { PoolConnection, ResultSetHeader } from "mysql2/promise";
    import { INT_MAX } from "../constants.ts";
    
    // 通貨とアイテムの増減。所持数を書き換えるのはこのファイルだけにする。
    //
    // 増やすのも減らすのも、「読んでから足りるか見て、書く」ではなく1文で済ませる。
    // 読んでから書く間に別のリクエストが割り込んでも、数がずれないようにするため。
    // amount が 0 以下のときは何もしない(add は文を流さない、spend は「足りた」扱い)。
    
    /**
     * 通貨を足す。行が無ければ作る(持っていない種別の行は作らない方針なので、無いことがある)。
     *
     * 「読んで、有無で分岐して、書く」ではなく INSERT ... ON DUPLICATE KEY UPDATE の1文にする。
     * VALUES() は 8.0.20 で非推奨になり警告が出るので、行エイリアス(AS `new`)で書く。
     * 上限は INT_MAX。所持上限のルールはまだ無いので、桁があふれないようにするだけ
     */
    export async function addCurrency(
      conn: PoolConnection,
      userId: number,
      currencyId: number,
      amount: number,
    ): Promise<void> {
      if (amount <= 0) return;
    
      await conn.execute(
        "INSERT INTO `user_currency` (`user_id`, `currency_id`, `amount`) VALUES (?, ?, ?) AS `new`" +
          " ON DUPLICATE KEY UPDATE `amount` = LEAST(`user_currency`.`amount` + `new`.`amount`, ?)",
        [userId, currencyId, amount, INT_MAX],
      );
    }
    
    /**
     * 通貨を引く。足りたら true。足りなければ false で、1行も更新されない。
     *
     * 条件付きの UPDATE 1本で減らす。
     * 行が無いユーザーは所持0なので、同じく0行になって「足りない」に倒れる
     */
    export async function spendCurrency(
      conn: PoolConnection,
      userId: number,
      currencyId: number,
      amount: number,
    ): Promise<boolean> {
      if (amount <= 0) return true;
    
      const [result] = await conn.execute<ResultSetHeader>(
        "UPDATE `user_currency` SET `amount` = `amount` - ?" +
          " WHERE `user_id` = ? AND `currency_id` = ? AND `amount` >= ?",
        [amount, userId, currencyId, amount],
      );
      return result.affectedRows > 0;
    }
    
    /** アイテムを足す。形も理由も addCurrency と同じ */
    export async function addItem(
      conn: PoolConnection,
      userId: number,
      itemId: number,
      amount: number,
    ): Promise<void> {
      if (amount <= 0) return;
    
      await conn.execute(
        "INSERT INTO `user_item` (`user_id`, `item_id`, `amount`) VALUES (?, ?, ?) AS `new`" +
          " ON DUPLICATE KEY UPDATE `amount` = LEAST(`user_item`.`amount` + `new`.`amount`, ?)",
        [userId, itemId, amount, INT_MAX],
      );
    }
    
    /** アイテムを引く。形も理由も spendCurrency と同じ */
    export async function spendItem(
      conn: PoolConnection,
      userId: number,
      itemId: number,
      amount: number,
    ): Promise<boolean> {
      if (amount <= 0) return true;
    
      const [result] = await conn.execute<ResultSetHeader>(
        "UPDATE `user_item` SET `amount` = `amount` - ?" +
          " WHERE `user_id` = ? AND `item_id` = ? AND `amount` >= ?",
        [amount, userId, itemId, amount],
      );
      return result.affectedRows > 0;
    }

    api-server/src/routes/shop.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { PoolConnection } from "mysql2/promise";
    import { withUserTransaction } from "../db.ts";
    import { selectStatusForUpdate } from "../user/status.ts";
    import { recoverStamina, staminaMaxOf } from "../user/stamina.ts";
    import { addItem, spendCurrency, spendItem } from "../user/inventory.ts";
    import { formatUtc } from "../datetime.ts";
    import { master } from "../master/store.ts";
    import type { Item, Shop } from "../master/types.ts";
    import { CURRENCY_ID, ITEM_KIND, ITEM_VALUE_FULL_RECOVER } from "../constants.ts";
    import { readIntegerField, readJsonBody, sendError, sendJson } from "../http.ts";
    
    // ショップでの購入と、アイテムの使用。
    //
    // どちらも変わった後の所持数や残高は返さない。
    // クライアントは成功したら GET /user/home を取り直す(HUD の出どころを1つにする)。
    
    type UseOutcome =
      | { kind: "ok"; response: { stamina: number; stamina_updated_at: string } }
      | { kind: "staminaFull" }
      | { kind: "notEnoughItem" }
      | { kind: "userNotFound" };
    
    /** POST /shop/buy — ショップの商品を1件買う */
    export async function handleShopBuy(
      req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const body = await readJsonBody(req);
    
      const shopId = readIntegerField(body, "shop_id");
      const shop = shopId === null ? undefined : master.get_shop(shopId);
      if (shop === undefined) {
        sendError(res, 400, "INVALID_SHOP", "shop_id が不正");
        return;
      }
    
      const bought = await withUserTransaction((conn) => buy(conn, userId, shop));
    
      // ここから先は例外を投げうる処理を置かない
      if (!bought) {
        sendError(res, 400, "NOT_ENOUGH_CURRENCY", "ゴールドが足りない");
        return;
      }
    
      sendJson(res, 200, { item_id: shop.item_id, amount: shop.amount });
    }
    
    /**
     * 代金を引いて、商品を入れる。代金が足りなければ false。
     *
     * 行ロックの順番は user_currency → user_item(全体の順は db.ts のコメントを参照)。
     * 値段は shop.price。item.price は使わない
     */
    async function buy(conn: PoolConnection, userId: number, shop: Shop): Promise<boolean> {
      // 引けなかったときは何も書いていないので、ロールバックされてもコミットされても同じ
      if (!(await spendCurrency(conn, userId, CURRENCY_ID.GOLD, shop.price))) return false;
    
      await addItem(conn, userId, shop.item_id, shop.amount);
      return true;
    }
    
    /** POST /item/use — アイテムを1つ使う。今は回復剤だけ */
    export async function handleItemUse(
      req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const body = await readJsonBody(req);
    
      const itemId = readIntegerField(body, "item_id");
      const item = itemId === null ? undefined : master.get_item(itemId);
      // 使えるのは回復アイテムだけ。強化素材は強化で消費するもので、ここでは使えない
      if (item === undefined || item.kind !== ITEM_KIND.RECOVER) {
        sendError(res, 400, "INVALID_ITEM", "item_id が不正か、使えないアイテム");
        return;
      }
    
      const outcome = await withUserTransaction((conn) => useRecoverItem(conn, userId, item, new Date()));
    
      // ここから先は例外を投げうる処理を置かない
      if (outcome.kind === "userNotFound") {
        sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
        return;
      }
      if (outcome.kind === "staminaFull") {
        sendError(res, 400, "STAMINA_FULL", "スタミナが既に上限以上");
        return;
      }
      if (outcome.kind === "notEnoughItem") {
        sendError(res, 400, "NOT_ENOUGH_ITEM", "アイテムを持っていない");
        return;
      }
    
      sendJson(res, 200, outcome.response);
    }
    
    /**
     * 回復アイテムを1つ使ってスタミナを戻す。
     *
     * 行ロックの順番は user_status → user_item。
     * 上限の判定は時間回復を済ませてから行う。満タンなら1つも減らさずに終える
     */
    async function useRecoverItem(
      conn: PoolConnection,
      userId: number,
      item: Item,
      now: Date,
    ): Promise<UseOutcome> {
      const status = await selectStatusForUpdate(conn, userId);
      if (status === null) return { kind: "userNotFound" };
    
      const staminaMax = staminaMaxOf(status.playerLv);
      const recovered = recoverStamina(status.stamina, status.staminaUpdatedAt, staminaMax, now);
      if (recovered.stamina >= staminaMax) return { kind: "staminaFull" };
    
      if (!(await spendItem(conn, userId, item.id, 1))) return { kind: "notEnoughItem" };
    
      // 上限未満であることは上で確かめている。上限を超えて持っている分を削る心配はない
      const stamina = staminaAfterUse(item, recovered.stamina, staminaMax);
      await conn.execute(
        "UPDATE `user_status` SET `stamina` = ?, `stamina_updated_at` = ? WHERE `user_id` = ?",
        [stamina, now, userId],
      );
    
      return {
        kind: "ok",
        response: { stamina, stamina_updated_at: formatUtc(now) },
      };
    }
    
    /** 回復後のスタミナ。value が全回復の印なら上限まで、正の数ならその分だけ(上限で止める) */
    function staminaAfterUse(item: Item, stamina: number, staminaMax: number): number {
      if (item.value === ITEM_VALUE_FULL_RECOVER) return staminaMax;
      if (item.value > 0) return Math.min(staminaMax, stamina + item.value);
      // マスタの入れ間違い。回復しないのにアイテムだけ減る、という状態を作らない(例外でロールバック)
      throw new Error(`item id=${item.id} の value=${item.value} は回復量として使えない`);
    }

    api-server/src/routes/hero.ts

    import type { IncomingMessage, ServerResponse } from "node:http";
    import type { PoolConnection, ResultSetHeader, RowDataPacket } from "mysql2/promise";
    import { userPool, withUserTransaction } from "../db.ts";
    import { spendCurrency, spendItem } from "../user/inventory.ts";
    import { master } from "../master/store.ts";
    import type { HeroLevelCurve } from "../master/types.ts";
    import { CURRENCY_ID, ITEM_ID } from "../constants.ts";
    import { readIntegerField, readJsonBody, sendError, sendJson } from "../http.ts";
    
    // ヒーローの強化。1回で1レベルだけ上げる。
    //
    // user_hero はトランザクションの外で読む。行ロックの順番(db.ts のコメント)では
    // user_hero が最後なので、先に FOR UPDATE で押さえてから通貨を引くと順が逆になる。
    // 通貨と素材を引いてから、読んだときのレベルを条件にした UPDATE で上げる。
    // 読んだ値が古ければ UPDATE が0行になるので、古いレベルのコストで上がることはない。
    
    /**
     * トランザクションの結果。
     * 素材不足はゴールドを引いた後に分かるので、ここには入れない(NotEnoughItemError を参照)
     */
    type UpgradeOutcome = { kind: "ok" } | { kind: "notEnoughCurrency" };
    
    /**
     * ゴールドを引いた後に、素材が足りないと分かった。
     *
     * withUserTransaction は例外で抜けたときだけロールバックする。
     * 結果として返すとコミットされ、ゴールドだけ減ってしまうので、例外にして巻き戻す
     */
    class NotEnoughItemError extends Error {}
    
    /** POST /hero/upgrade — ヒーローのレベルを1つ上げる */
    export async function handleHeroUpgrade(
      req: IncomingMessage,
      res: ServerResponse,
      userId: number,
    ): Promise<void> {
      const body = await readJsonBody(req);
    
      const userHeroId = readIntegerField(body, "user_hero_id");
      if (userHeroId === null) {
        sendError(res, 400, "INVALID_REQUEST", "user_hero_id が不正");
        return;
      }
    
      const level = await selectOwnedHeroLevel(userId, userHeroId);
      if (level === null) {
        sendError(res, 400, "INVALID_HERO", "所持していない個体");
        return;
      }
      if (level >= maxHeroLevel()) {
        sendError(res, 400, "MAX_LEVEL", "既に最大レベル");
        return;
      }
    
      // コストは「今のレベルの行」に入っている。そのレベルから次へ上げるときの値
      const curve = master.get_hero_level_curve(level);
      if (curve === undefined) throw new Error(`hero_level_curve に Lv${level} が無い`);
    
      let outcome: UpgradeOutcome;
      try {
        outcome = await withUserTransaction((conn) =>
          upgrade(conn, userId, userHeroId, level, curve),
        );
      } catch (error) {
        if (!(error instanceof NotEnoughItemError)) throw error;
        sendError(res, 400, "NOT_ENOUGH_ITEM", "強化素材が足りない");
        return;
      }
    
      // ここから先は例外を投げうる処理を置かない
      if (outcome.kind === "notEnoughCurrency") {
        sendError(res, 400, "NOT_ENOUGH_CURRENCY", "ゴールドが足りない");
        return;
      }
    
      sendJson(res, 200, { user_hero_id: userHeroId, level: level + 1 });
    }
    
    /**
     * コストを引いてレベルを1つ上げる。
     *
     * 行ロックの順番は user_currency → user_item → user_hero(全体の順は db.ts のコメントを参照)
     */
    async function upgrade(
      conn: PoolConnection,
      userId: number,
      userHeroId: number,
      level: number,
      curve: HeroLevelCurve,
    ): Promise<UpgradeOutcome> {
      // 引けなかったときは何も書いていないので、コミットされても同じ
      if (!(await spendCurrency(conn, userId, CURRENCY_ID.GOLD, curve.need_gold))) {
        return { kind: "notEnoughCurrency" };
      }
    
      if (!(await spendItem(conn, userId, ITEM_ID.MATERIAL, curve.need_materials))) {
        throw new NotEnoughItemError();
      }
    
      // 読んだときのレベルを条件に入れる。0行なら、その間に同じ個体が強化されている。
      // 同じ個体を2回同時に強化したときにだけ起きるので、500 にしてロールバックする
      const [result] = await conn.execute<ResultSetHeader>(
        "UPDATE `user_hero` SET `level` = `level` + 1" +
          " WHERE `user_id` = ? AND `user_hero_id` = ? AND `level` = ?",
        [userId, userHeroId, level],
      );
      if (result.affectedRows === 0) {
        throw new Error(`user_hero_id=${userHeroId} のレベルが強化の途中で変わった`);
      }
    
      return { kind: "ok" };
    }
    
    /**
     * そのユーザーが持っている個体のレベル。持っていなければ null。
     * 他人の個体を強化できないよう、user_id も条件に入れる
     */
    async function selectOwnedHeroLevel(userId: number, userHeroId: number): Promise<number | null> {
      const [rows] = await userPool.execute<RowDataPacket[]>(
        "SELECT `level` FROM `user_hero` WHERE `user_id` = ? AND `user_hero_id` = ?",
        [userId, userHeroId],
      );
      const row = rows[0];
      return row === undefined ? null : Number(row.level);
    }
    
    // 最大レベルはマスタが変わらない限り同じ。呼ばれるたびに全行を走査しない
    let cachedMaxHeroLevel: number | null = null;
    
    /** hero_level_curve に入っている最大の level。ここに達したらもう上がらない */
    function maxHeroLevel(): number {
      if (cachedMaxHeroLevel === null) {
        const rows = master.get_table("hero_level_curve") as readonly HeroLevelCurve[];
        cachedMaxHeroLevel = rows.reduce((max, row) => Math.max(max, row.level), 0);
      }
      return cachedMaxHeroLevel;
    }

    game-client/src/api/shop.ts

    // ショップでの購入と、アイテムの使用。
    //
    // どちらも変わった後の所持数や残高は返ってこない。
    // 成功したら GET /user/home を取り直して HUD を差し替える
    import { apiPost } from './client';
    
    /** 入った中身。所持数ではなく、今回増えた分 */
    export interface ShopBuyResponse {
      item_id: number;
      amount: number;
    }
    
    /** 使った後のスタミナ */
    export interface ItemUseResponse {
      stamina: number;
      /** UTC。"2026-09-22T01:23:45Z" */
      stamina_updated_at: string;
    }
    
    /** POST /shop/buy。値段はサーバが shop_id から決めるので、金額は送らない */
    export function postShopBuy(token: string, shopId: number): Promise<ShopBuyResponse> {
      return apiPost<ShopBuyResponse>('/shop/buy', { shop_id: shopId }, token);
    }
    
    /** POST /item/use。今使えるのは回復剤だけ */
    export function postItemUse(token: string, itemId: number): Promise<ItemUseResponse> {
      return apiPost<ItemUseResponse>('/item/use', { item_id: itemId }, token);
    }

    game-client/src/ui/screens/ShopScreen.tsx

    // ショップ画面:強化素材・回復剤の購入(支払いはゴールド1種)と、回復剤の使用。プロトから移植。
    //
    // プロトはローカルの UserData を書き換えていたが、ここでは POST /shop/buy と POST /item/use を叩く。
    // 応答に所持数や残高は入っていないので、成功しても失敗しても GET /user/home を取り直して HUD を差し替える。
    // プロトにあったデータリセットの行は移植しない(サーバにデータを消すAPIは作らない)
    import { useState } from 'react';
    import { currencyAmount, itemAmount, type HomeResponse } from '../../api/home';
    import { postItemUse, postShopBuy } from '../../api/shop';
    import { CURRENCY_ID, ITEM_ID } from '../../constants';
    import type { MasterStore } from '../../master/store';
    import type { Shop } from '../../master/types';
    
    /** 失敗したときの文言。買えた・使えたかどうかはクライアントには分からない */
    const BUY_FAILED_MESSAGE = '購入できませんでした。いまの所持数を表示しています';
    const USE_FAILED_MESSAGE = '使用できませんでした。いまの所持数を表示しています';
    
    /** 商品のアイコン。マスタに無いので item_id から引く */
    function itemIcon(itemId: number): string {
      if (itemId === ITEM_ID.MATERIAL) return '🔨';
      if (itemId === ITEM_ID.POTION) return '🧪';
      return '';
    }
    
    /** 商品の説明。文言はプロトのまま。回復剤だけ所持数を添える */
    function itemDescription(itemId: number, owned: number): string {
      if (itemId === ITEM_ID.MATERIAL) return 'キャラのレベルアップに使用';
      if (itemId === ITEM_ID.POTION) return `使うとスタミナを全回復(所持 ${owned})`;
      return '';
    }
    
    export function ShopScreen({
      home,
      master,
      token,
      onReloadHome,
    }: {
      home: HomeResponse;
      master: MasterStore;
      token: string;
      /** 成功・失敗のどちらでも呼ぶ。ホームを取り直して差し替えてもらう */
      onReloadHome: () => Promise<void>;
    }) {
      // 通信中はどのボタンも押せない
      const [busy, setBusy] = useState(false);
      const [notice, setNotice] = useState<string | null>(null);
      const [message, setMessage] = useState<string | null>(null);
    
      const gold = currencyAmount(home, CURRENCY_ID.GOLD);
      const potions = itemAmount(home, ITEM_ID.POTION);
      const staminaMax = master.playerLevelCurveByLv.get(home.status.player_lv)?.stamina_max ?? 0;
    
      /**
       * 通信して、結果に関係なくホームを取り直す。
       * 取り直しにも失敗したら、押せないままにしてメッセージだけ出す。下部ナビで出入りすれば取り直される
       */
      const run = async (send: () => Promise<string>, failedMessage: string) => {
        setBusy(true);
        setNotice(null);
        setMessage(null);
        try {
          setNotice(await send());
        } catch {
          setMessage(failedMessage);
        }
        try {
          await onReloadHome();
        } catch {
          return;
        }
        setBusy(false);
      };
    
      const buy = (shop: Shop) =>
        run(async () => {
          const bought = await postShopBuy(token, shop.id);
          const name = master.itemById.get(bought.item_id)?.name ?? '';
          return `${name} ×${bought.amount} を購入`;
        }, BUY_FAILED_MESSAGE);
    
      const usePotion = () =>
        run(async () => {
          await postItemUse(token, ITEM_ID.POTION);
          return 'スタミナ全回復!';
        }, USE_FAILED_MESSAGE);
    
      return (
        <div className="screenBody" style={{ flexDirection: 'column' }}>
          <div className="shopBody">
            <div className="secTitle">ショップ(支払いはゴールド)</div>
            {master.shops.map((shop) => (
              <div key={shop.id} className="shopRow panel">
                <div>
                  <div className="sn">
                    {itemIcon(shop.item_id)} {master.itemById.get(shop.item_id)?.name ?? ''} ×{shop.amount}
                  </div>
                  <div className="sd">{itemDescription(shop.item_id, potions)}</div>
                </div>
                <div style={{ display: 'flex', gap: 8 }}>
                  <button className="btnP" disabled={busy || gold < shop.price} onClick={() => buy(shop)}>
                    {shop.price} G
                  </button>
                  {shop.item_id === ITEM_ID.POTION && (
                    <button
                      className="btnS"
                      disabled={busy || potions < 1 || home.status.stamina >= staminaMax}
                      onClick={usePotion}
                    >
                      使う
                    </button>
                  )}
                </div>
              </div>
            ))}
            {notice !== null && <div className="screenNotice">{notice}</div>}
            {message !== null && <div className="screenError">{message}</div>}
            <div className="shopNote">
              育成もスタミナ回復も、ガチャと同じゴールドから。ここで使えばガチャが遠のく——この綱引きが1種通貨の肝です。
            </div>
          </div>
        </div>
      );
    }
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ