
ソシャゲのサーバーを作る。ショップと強化(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/homeHUDの出どころが1本になるので、表示がずれません。
通信は1回増えますが、画面を開き直したときと同じ道を通るだけです。
ガチャのほうは、そのままにしてあります。
動いているものを揃え直すのは、今回やることではないので。
買えるものを制限するなら
`shop` テーブルには `daily_limit` という列があります。
「1日に何個まで」ですね。
今回は全部0(無制限)なので、使っていません。
入れるとなると、リセットが何時なのかを決めることになります。
日本時間の朝5時なのか、UTCの0時なのか。
そして「その日にいくつ買ったか」をどこに持つか。
ソシャゲだと、日付が変わる時刻はだいたい早朝です。
深夜にプレイしている人の途中で切り替わらないように。
このあたりは、ログインボーナスやデイリーミッションと同じ仕組みになります。
今回は作らないので、また別の機会に。
動かす
ショップです。並んでいるのはマスタの2件だけですね。

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

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

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

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

強化するとステータスが上がります。
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>
);
}