
ソシャゲのサーバーを作る。ヒーロー一覧とデッキ編成(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枠目が空いたまま残ります。
この状態でホームに戻ると、

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>
);
}