
ソシャゲのサーバーを作る。ステージ選択とバトル(14)
前回はデッキを組めるようにしました。
ヒーローがいて、デッキも組める。
今回はいよいよ戦います。
誰が勝ちを決めるか
最初に決めることがあります。
バトルの勝ち負けを、誰が決めるかです。
ガチャのときは簡単でした。
抽選をサーバに移して、クライアントには結果だけを渡す。
バトルも同じようにしたいのですが、
このゲームのバトルには、そうできない事情があります。
先に全部は計算できない
プロトのバトルには、AUTOとSEMIの2つのモードがあります。
AUTOは全部おまかせ。
SEMIは、必殺ゲージが溜まったキャラの手番で止まって、
撃つか温存するかをプレイヤーが選べます。

ここで撃つか撃たないかで、その後の展開が変わるんですよね。
なのでサーバが最初に最後まで計算して渡す、という形にはできません。
途中でプレイヤーの手が入るので。
考えられる形は3つありました。
1. サーバが最後まで計算して、クライアントは再生するだけ(SEMIは捨てる)
2. クライアントの勝ち負けを信じて、サーバは最低限だけ見る
3. クライアントが戦った手順を、サーバでもう一度再現する1は堅いですが、SEMIが無くなります。
2は、実務だとそれなりに見かける形です。
この話は、最後におまけで書きます。
ただこの連載は、ずっと「クライアントを信用しない」でやってきたので。
3にしました。
送るのは「撃ったかどうか」だけ
流れはこうなります。
1. 開始のとき、サーバが乱数のシードを決めて渡す
2. クライアントはそのシードでバトルを回して、画面に見せる
3. 終わったら、プレイヤーの入力だけを送る
4. サーバが同じシード・同じ入力で、同じバトルを回し直す
5. サーバで出た結果を正とするプレイヤーが選べるのは「必殺を撃つか、温存するか」だけです。
なので送るものも、それだけにしました。
{
"battle_id": "5f0c...",
"ultimate_decisions": [true, true, false, true]
}必殺を撃てる手番が来るたびに、撃ったら `true`、温存したら `false`。
それを順番に並べただけの配列です。
AUTOのときも、同じ配列を作っています。
AUTOは「毎回すぐに撃つと答えている」だけ、という扱いにしました。
こうすると、戦闘の途中でAUTOとSEMIを切り替えても、
記録の形が変わりません。
勝ったかどうかは、送りません。
正確には、送ってはいるけど判定には使いません。
"client_result": { "win": true, "turns": 7 }これはログ用です。
サーバで回し直した結果と食い違ったら、ログに出す。
食い違うということは、サーバとクライアントのバトルの計算がどこかずれているか、
誰かが何かをしたか、なので。
同じコードを両方で動かす
この形の前提は、サーバとクライアントが、まったく同じバトルの計算をすることです。
同じ計算を2回書くと、どこかで必ずずれます。
なので1回だけ書いて、両方から読み込むことにしました。
これができるのは、サーバもクライアントもTypeScriptだからですね。
shared/
battle/
battle.ts バトル本体
rng.ts シード付き乱数
stats.ts ステータス計算
replay.ts 入力の列で最後まで回すリポジトリの直下に `shared` を作って、ここに置きました。
サーバは、Nodeが型を消してそのまま読みます。
1本目で「TypeScriptをそのまま実行する」構成にしたのが、ここで効いてきますね。
クライアントは、Viteがいつもどおりバンドルします。
置くコードには決まりを1つだけ作りました。
DBもRedisも画面も、何も知らないこと。
マスタの持ち方も、サーバとクライアントで違います。
なので `shared` はマスタを読みに行かず、必要な行を引数で受け取るだけにしています。
整数だけで計算する
13本目で、ステータスの計算を整数にしました。
「バトルの回でサーバにも同じ式を置くので」と書いたのが、ここです。
今回はステータスだけでなく、バトルの計算を全部整数にしています。
ダメージ = ATK × 威力 × 属性 − DEF × 0.5威力も属性の倍率も、万分率の整数で持つ。
四捨五入も、自前の関数1つだけを使う。
`Math.round` も `Math.random` も使いません。
実は、同じJavaScriptで同じ順番に計算すれば、
浮動小数でも結果は同じになることがほとんどです。
ただ、「ほとんど」だと困るんですよね。
ずれたら、画面では勝ったのにサーバでは負け、になる。
しかも1回ずれると、その後の乱数の使われ方まで変わるので、
1ダメージの差が、最後には勝敗の差になります。
整数にしておけば、ずれないと言い切れます。
再現できる乱数
ガチャのとき、乱数は `crypto.randomInt` を使いました。
予測されにくい乱数です。
バトルでは逆に、同じシードから同じ列が出てくる乱数が要ります。
予測されにくいかどうかより、再現できることのほうが大事なので。
32bitの整数演算だけで次の値を作る、小さな乱数を `shared` に置きました。
これならNodeでもブラウザでも同じ列になります。
ただ、強敵が出るかどうかの抽選だけは、開始のときにサーバが `crypto.randomInt` で済ませています。
強敵は報酬が上がるので、ここはガチャと同じ扱いですね。

シードを渡していいのか
気になるのはここだと思います。
シードをクライアントに渡すということは、
バトルが始まる前に、結果を先読みできるということです。
手元で同じバトルを回せば、
「ここで撃てば勝てる」「ここで温存すると負ける」が分かってしまう。
ただ、それで変えられるのは必殺のタイミングだけです。
ステータスも敵も乱数も、サーバが決めている。
やっていることは、上手なプレイヤーが最善手を選ぶのと同じです。
開始をやり直して、良いシードが来るまで粘ることもできます。
でも開始のたびにスタミナを払っているので、
それはそれで普通に周回しているのと変わりません。
守りたいのは「サーバが決めたこと」で、そこは動かせない。
なのでシードは渡すことにしました。
隠していた敵のステータス
8本目でマスタを配信したとき、
敵のステータスとレベルは、クライアントに渡しませんでした。
まだ行けないステージの敵まで、全部見えてしまうので。
ところが今回、クライアントでもバトルを回します。
敵のステータスが無いと回せません。
なので、開始のときに、そのバトルの敵の分だけ渡すことにしました。
"enemies": [
{ "unit_id": "e0", "enemy_id": 1, "max_hp": 70, "atk": 14, "def": 6, "spd": 8, "skill_id": 0 }
]レベルも強敵の倍率も、サーバで計算済みの値です。
マスタごと渡すのではなく、目の前の敵の数字だけ。
味方のステータスも、計算済みで返しています。
開始したあとに強化や編成を変えても、そのバトルには効かないようにするためですね。
終わるときは、開始のときに保存しておいたこの値で回し直します。
DBとRedisは一緒にコミットできない
開始のときにやることは、2か所に分かれています。
DB スタミナを減らす
Redis バトルの中身(シード・敵・味方)を置いておく困るのは、この2つは1つのトランザクションにできないことです。
片方だけ成功したらどうなるか、を並べてみます。
スタミナは減ったのに、バトルが無い → 払ったのに戦えない
バトルはあるのに、スタミナが減っていない → タダで1回戦えるどちらかには倒れるので、ましなほうを選びます。
Redisに書くのを、DBのコミットの前に置きました。
Redisに書けなければ、DBはロールバックされてスタミナは減らない。
コミットが失敗したときだけ、「タダで1回」が起きます。
払ったのに戦えないよりは、そっちのほうがいいので。
2回終わらせない
終わるときは、Redisからバトルを取り出して、同時に消します。
6本目のワンタイムキーで使った `GETDEL` ですね。
取り出せるのは1回だけなので、
同じバトルを2回終わらせることはできません。
その代わり、取り出した後でDBへの書き込みが失敗すると、
バトルはもう無いので、クリアが記録されないまま終わります。
2回記録されるより、記録されないほうに倒す。
次回、ここに報酬が乗ってくるので、なおさらですね。
応答が届かなかったときは、ガチャや編成と同じです。
クエスト画面に戻れば、クリアしたかどうかは取り直せます。
1000回まわして確かめる
同じ入力で回し直して、本当に同じ結果になるか。
スクリプトで確かめておきます。
ランダムなデッキ、ランダムなシード、ランダムな入力でバトルを回し、
その入力の列を使って、もう一度回す。
回数 1000
一致 1000 (100.00%)
勝率 87.70%
平均ターン 3.481000戦、全部一致しました。
デッキの人数も1人〜4人でばらつかせています。
最初は4人満員で回していたのですが、第1章だと全部勝ってしまって、
負ける流れも、ターン上限まで粘る流れも、一度も通らなかったんですよね。
一致を確かめたいのに、通っていない道があっては意味がないので。
ちなみに平均3.48ターン。
第1章はだいぶ優しいです。
ブラウザで戦った分も確かめました。
サーバのログを開いたまま、AUTOとSEMIを混ぜて第1章を最後まで戦っています。
app-1 | [master] delivery payload 21.0KB -> 4.2KB (gzip)
app-1 | listening on http://localhost:3000起動のログのあと、何も出ていません。
食い違いがあったときだけ出す作りなので、何も出ないのが一致の証拠です。
ブラウザで回したバトルと、サーバで回し直したバトル。
同じコードが、同じ結果を出しています。
動かす
最初は1-1しか挑戦できません。

左に立っているのは、デッキの先頭のヒーローです。
これはデッキを組み直す前に撮ったので、新米僧侶ですね。
SEMIでアルドの必殺を撃ってみます。


勝つと、次のステージが解放されます。
ボスまで進めると、第1章が全部CLEARになりました。

左も、組み直したデッキの先頭のアルドに変わっています。
報酬はまだ出ていません。
結果の画面が「WIN!」だけなのは、そのためです。
おまけ:開始と終了しか通信しないゲーム
今回は「サーバで回し直す」形にしましたが、
実際のソシャゲがみんなこうしているわけではありません。
ゲームや設計にもよりますが、
クエストの通信が「開始」と「終了」の2回しかないものは珍しくないです。
クエストの中の進行は、全部クライアント任せ。
終わったら勝ち負けやスコアを受け取って、
サーバは「このステージでこのスコアはありえるか」くらいの、上限と下限のチェックだけで通してしまう。
上限と下限の間なら、何を送っても通るということです。
いわゆるチートし放題ですね。
それが一番はっきり出るのがランキングで、
上位がありえない数字で埋まって荒れる、ということが起きます。
一方で、ランキングのような「他人と比べるもの」が無いゲームだと、
あえてこの形にしている場合もあります。
通信の回数も、サーバの処理も抑えられるので。
自分で一人遊びの結果をいじっても、困るのはその人だけ。
なら、守るためのコストをかけない、という判断ですね。
ただ、どうなんだろうとは思っています。
処理の負荷について言えば、このゲームのバトルをサーバで回し直すのにかかる時間は、
プロトのコードで測って1戦あたり0.03msほどでした。
少なくともこの規模なら、サーバの負荷は理由になりにくい。
本当に重いのは、たぶんそこではないんですよね。
同じバトルのコードをサーバとクライアントで揃え続けること。
アプリの更新が行き渡っていない人がいても、結果がずれないようにすること。
そういう、作ったあとの手間のほうです。
それと、今はランキングが無くても、あとから足したくなるのがソシャゲです。
そのときに「終了で送られてくるスコアは信用できない」状態だと、
ランキングを作る前に、バトルの作りから直すことになる。
最初から守っておくか、割り切って負荷と手間を取るか。
どちらが正解というより、あとから守る側に寄せるのは、とても大変、というのが実感です。
今回はここまで
勝ち負けは、クライアントの入力をサーバで再現して決める
送るのは「必殺を撃ったかどうか」の列だけ
バトルのコードは1つだけ書いて、サーバとクライアントの両方で動かす
計算は整数だけ。乱数はシード付き
敵のステータスは、そのバトルの分だけ開始時に渡す
DBとRedisは、片方だけ成功したときにましなほうへ倒す
終了は `GETDEL` で1回だけ
量が多くなったので、報酬は次に分けます。
次回はバトルの報酬です。
ゴールド、素材、経験値、レベルアップ、初回クリアボーナスを付けます。
【最後まで読んでいただきありがとうございます!】
面白かったと感じた方は、ぜひ「スキ」と「フォロー」をお願いします!
コード
今回の記事で作ったコードです、興味のある方はどうぞ。
shared/battle/rng.ts
// シード付き乱数。
//
// 同じシードなら Node でもブラウザでも同じ列が出る必要がある。
// 32bit の整数演算(Math.imul と >>>)だけで次の値を作る mulberry32 を使う。
// Math.random は使わない。サーバとクライアントで結果が食い違う
/** 0 以上 n 未満の整数を返すだけの乱数。バトルが使うのはこれだけ */
export type Rng = { nextInt(n: number): number };
/** u32 の分母。2^32 */
const U32_DIVISOR = 4294967296;
/** mulberry32 の加算定数 */
const MULBERRY32_INCREMENT = 0x6d2b79f5;
/**
* シードから乱数を作る。seed は 0 〜 2^32-1 の整数。
*
* 状態は32bitの整数1つ。`>>> 0` で毎回 32bit に畳んでいるので、
* 途中で浮動小数になることがない
*/
export function createRng(seed: number): Rng {
let state = seed >>> 0;
const nextU32 = (): number => {
state = (state + MULBERRY32_INCREMENT) >>> 0;
let t = state;
t = Math.imul(t ^ (t >>> 15), t | 1);
t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
return (t ^ (t >>> 14)) >>> 0;
};
return {
nextInt(n: number): number {
// u32 は 2^32 未満、n は候補の数(せいぜい数個)なので、積は 2^53 に収まる
return Math.floor((nextU32() * n) / U32_DIVISOR);
},
};
}shared/battle/fixed.ts
// 整数だけで計算するためのヘルパ。
//
// サーバ(Node)とクライアント(ブラウザ)で同じ結果を出すのが目的。
// 浮動小数を1度でも通すと、環境によって最後の桁がずれる。
// 倍率はすべて万分率の整数(1倍 = 10000)で持ち、割り算は roundDiv だけを使う。
/** 倍率の分母。1倍 = 10000 */
export const PERMYRIAD = 10000;
/** 倍率を2つ掛けた状態の分母 */
export const PERMYRIAD_SQUARED = PERMYRIAD * PERMYRIAD;
/** 小数部の桁数。DECIMAL(6,4) に合わせる */
const FRACTION_DIGITS = 4;
/**
* DECIMAL の文字列を万分率の整数にする。"1.80" → 18000、"1.0800" → 10800。
*
* parseFloat も Number(全体) も経由しない。文字列を小数点で分けて、整数として組み立てる
*/
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);
}
/**
* x / d を四捨五入する。値はすべて正なので、分母の半分を足してから切り捨てれば四捨五入と同じ。
*
* 丸めを伴う割り算はこれ1つに集約する。Math.round は使わない
* (負の値の扱いが切り捨てと食い違ううえ、浮動小数を経由するため)
*/
export function roundDiv(x: number, d: number): number {
return Math.floor((x + d / 2) / d);
}shared/battle/replay.ts
// 入力の列でバトルを最後まで回す。
//
// クライアントが送ってくるのは「必殺を撃つか撃たないか」の真偽値の列だけ。
// サーバは同じシードと同じ列でここを回し、出た勝敗を正とする。
// クライアントが送ってきた勝敗は使わない。
import { battleStep, createBattle } from './battle.ts';
import type { BattleSetup } from './setup.ts';
/**
* battleStep を呼ぶ回数の上限。
* 壊れた入力で無限ループに落ちないための保険で、正常なバトルでは遠く及ばない
*/
export const REPLAY_STEP_LIMIT = 10000;
export type ReplayResult =
| { kind: 'ok'; win: boolean; turns: number; events: number }
| { kind: 'invalid'; reason: 'not_enough_decisions' | 'too_many_decisions' | 'step_limit' };
/**
* 入力の列でバトルを回し切る。
*
* awaitUltimate で止まるたびに decisions を先頭から1つ使う。
* 途中で足りなくなっても、終わったあとに余っていても、入力が食い違っているということなので invalid
*/
export function runReplay(
setup: BattleSetup,
seed: number,
decisions: readonly boolean[],
): ReplayResult {
const state = createBattle(setup, seed);
let used = 0;
let steps = 0;
let events = 0;
while (!state.finished) {
if (steps >= REPLAY_STEP_LIMIT) return { kind: 'invalid', reason: 'step_limit' };
steps++;
if (state.awaiting === null) {
events += battleStep(state).length;
continue;
}
if (used >= decisions.length) return { kind: 'invalid', reason: 'not_enough_decisions' };
events += battleStep(state, decisions[used]).length;
used++;
}
if (used < decisions.length) return { kind: 'invalid', reason: 'too_many_decisions' };
return { kind: 'ok', win: state.win, turns: state.turn, events };
}shared/battle/battle.ts
// オートバトルのシミュレーション(表示に一切依存しない)。
//
// 1ステップ(= 1ユニットの行動)ずつ進め、結果は BattleEvent の列で返す。
// 演出はクライアントが、勝敗の判定はサーバが、同じこのコードを回して決める。
//
// プロト(prototype/src/core/battle.ts)からの移植。ルールは変えていない。
// 速度順・行動ごとにゲージ+25・満タンで必殺・属性三すくみ・ヒーラーAI・状態異常・ターン上限。
// 変えたのは次の2点。
//
// 1. モードを持たない。味方の必殺が撃てる状態になったら、AUTO でも SEMI でも必ず
// awaitUltimate を返して入力を待つ。こうすると入力の列が1種類になり、
// サーバが同じ列で回し直せる(AUTO はクライアントが即座に true を返す)
// 2. 計算を整数だけで行う。倍率は万分率、割り算は roundDiv。Math.round は使わない
import { EFFECT_CODE, ROLE, SKILL_KIND, SKILL_TARGET } from './codes.ts';
import { PERMYRIAD, PERMYRIAD_SQUARED, roundDiv } from './fixed.ts';
import { createRng } from './rng.ts';
import type { Rng } from './rng.ts';
import { affinityMultiplier, BASIC_ATTACK } from './setup.ts';
import type { BattleSetup, BattleSkill, BattleSkillEffect, BattleUnitSpec } from './setup.ts';
export type Side = 'ally' | 'enemy';
/** ユニットに付いている効果。duration はターン数で、ターン開始時に1ずつ減る */
export interface BattleEffect {
code: string;
/** 万分率 */
value: number;
duration: number;
}
/**
* バトル中に起きたこと。演出はこれを見て作る。
* 名前は入っていない。skillId からマスタを引くのはクライアントの担当
*/
export type BattleEvent =
| { kind: 'turnStart'; unitId: string }
| {
kind: 'attack';
actorId: string;
targetId: string;
damage: number;
damageType: number;
element: number;
/** 属性相性。万分率 */
effective: number;
isUltimate: boolean;
skillId: number;
}
| { kind: 'heal'; actorId: string; targetId: string; amount: number; skillId: number }
| { kind: 'effect'; targetId: string; effect: BattleEffect }
| { kind: 'dot'; targetId: string; amount: number; effectType: 'poison' | 'regen' }
| { kind: 'skip'; unitId: string; reason: 'stun' }
| { kind: 'defeat'; unitId: string }
/** 味方の必殺が撃てる。次の battleStep に撃つかどうかを渡す */
| { kind: 'awaitUltimate'; readyUnitIds: string[] }
| { kind: 'end'; win: boolean };
export interface BattleUnit {
id: string;
side: Side;
element: number;
role: number;
isBoss: boolean;
maxHp: number;
hp: number;
atk: number;
def: number;
spd: number;
gauge: number;
alive: boolean;
normalSkill: BattleSkill;
ultimate: BattleSkill;
effects: BattleEffect[];
}
export interface BattleState {
units: BattleUnit[];
turn: number;
/** このターンの残り行動者(速度降順) */
queue: string[];
finished: boolean;
win: boolean;
/** 必殺の入力を待っているユニットID */
awaiting: string | null;
setup: BattleSetup;
rng: Rng;
}
// ---- 生成 ----
function toUnit(spec: BattleUnitSpec): BattleUnit {
return {
id: spec.unitId,
side: spec.side,
element: spec.element,
role: spec.role,
isBoss: spec.isBoss,
maxHp: spec.maxHp,
hp: spec.maxHp,
atk: spec.atk,
def: spec.def,
spd: spec.spd,
gauge: 0,
alive: true,
normalSkill: spec.normalSkill,
ultimate: spec.ultimate,
effects: [],
};
}
/** バトルを始める。setup とシードが同じなら、どこで回しても同じ結果になる */
export function createBattle(setup: BattleSetup, seed: number): BattleState {
return {
units: setup.units.map(toUnit),
turn: 0,
queue: [],
finished: false,
win: false,
awaiting: null,
setup,
rng: createRng(seed),
};
}
// ---- 参照ヘルパ ----
export function unitById(state: BattleState, id: string): BattleUnit {
const unit = state.units.find((u) => u.id === id);
if (unit === undefined) throw new Error(`unknown battle unit: ${id}`);
return unit;
}
function livingFoes(state: BattleState, unit: BattleUnit): BattleUnit[] {
return state.units.filter((u) => u.side !== unit.side && u.alive);
}
function livingFriends(state: BattleState, unit: BattleUnit): BattleUnit[] {
return state.units.filter((u) => u.side === unit.side && u.alive);
}
/** バフとデバフの合計(万分率)。上げる効果を足し、下げる効果を引く */
function effectSum(unit: BattleUnit, up: string, down: string): number {
let sum = 0;
for (const effect of unit.effects) {
if (effect.code === up) sum += effect.value;
if (effect.code === down) sum -= effect.value;
}
return sum;
}
export function currentAtk(unit: BattleUnit): number {
const mul = PERMYRIAD + effectSum(unit, EFFECT_CODE.ATK_UP, EFFECT_CODE.ATK_DOWN);
return Math.max(1, roundDiv(unit.atk * mul, PERMYRIAD));
}
export function currentDef(unit: BattleUnit): number {
const mul = PERMYRIAD + effectSum(unit, EFFECT_CODE.DEF_UP, EFFECT_CODE.DEF_DOWN);
return Math.max(0, roundDiv(unit.def * mul, PERMYRIAD));
}
export function currentSpd(unit: BattleUnit): number {
const mul = PERMYRIAD + effectSum(unit, EFFECT_CODE.SPD_UP, EFFECT_CODE.SPD_DOWN);
return Math.max(1, roundDiv(unit.spd * mul, PERMYRIAD));
}
function isStunned(unit: BattleUnit): boolean {
return unit.effects.some((effect) => effect.code === EFFECT_CODE.STUN);
}
/** いま必殺を撃てる味方。入力待ちの表示に使う */
export function readyAllies(state: BattleState): string[] {
return state.units
.filter((u) => u.side === 'ally' && u.alive && u.gauge >= state.setup.rules.ultGaugeMax)
.map((u) => u.id);
}
// ---- 進行 ----
function endBattle(state: BattleState, win: boolean, events: BattleEvent[]): BattleEvent[] {
state.finished = true;
state.win = win;
events.push({ kind: 'end', win });
return events;
}
function checkEnd(state: BattleState, events: BattleEvent[]): boolean {
const allyAlive = state.units.some((u) => u.side === 'ally' && u.alive);
const enemyAlive = state.units.some((u) => u.side === 'enemy' && u.alive);
if (!allyAlive || !enemyAlive) {
endBattle(state, allyAlive && !enemyAlive, events);
return true;
}
return false;
}
function applyDamage(target: BattleUnit, damage: number, events: BattleEvent[]): void {
target.hp = Math.max(0, target.hp - damage);
if (target.hp <= 0 && target.alive) {
target.alive = false;
events.push({ kind: 'defeat', unitId: target.id });
}
}
/** 継続ダメージ/継続回復の量。最大HPの割合(万分率)で、最低1 */
function overTimeAmount(unit: BattleUnit, value: number): number {
return Math.max(1, roundDiv(unit.maxHp * value, PERMYRIAD));
}
/** ターン開始時:継続効果を適用し、残りターンを1減らして切れたものを落とす */
function tickEffects(state: BattleState, events: BattleEvent[]): void {
for (const unit of state.units) {
if (!unit.alive || unit.effects.length === 0) continue;
for (const effect of unit.effects) {
if (effect.code === EFFECT_CODE.POISON) {
const damage = overTimeAmount(unit, effect.value);
events.push({ kind: 'dot', targetId: unit.id, amount: damage, effectType: 'poison' });
applyDamage(unit, damage, events);
if (!unit.alive) break;
} else if (effect.code === EFFECT_CODE.REGEN) {
const heal = overTimeAmount(unit, effect.value);
unit.hp = Math.min(unit.maxHp, unit.hp + heal);
events.push({ kind: 'dot', targetId: unit.id, amount: heal, effectType: 'regen' });
}
}
unit.effects = unit.effects
.map((effect) => ({ ...effect, duration: effect.duration - 1 }))
.filter((effect) => effect.duration > 0);
}
}
/** HP割合が最も低い味方。割り算をせず、たすき掛けで比べる。同率なら units の並びで先のもの */
function lowestHpRatio(friends: readonly BattleUnit[]): BattleUnit[] {
let lowest = friends[0];
if (lowest === undefined) return [];
for (const friend of friends) {
if (friend.hp * lowest.maxHp < lowest.hp * friend.maxHp) lowest = friend;
}
return [lowest];
}
/**
* スキルの対象を決める。敵味方は「行動者から見た陣営」で解決する
* (敵が撃つ『敵単体』はプレイヤー側になる)。
*
* 例外:kind がデバフの『味方単体』指定(毒キノコの胞子)は、相手側の単体として解釈する
*/
function resolveTargets(
state: BattleState,
actor: BattleUnit,
skill: BattleSkill,
): BattleUnit[] {
const foes = livingFoes(state, actor);
const friends = livingFriends(state, actor);
const pick = (list: BattleUnit[]): BattleUnit[] =>
list.length === 0 ? [] : [list[state.rng.nextInt(list.length)]];
switch (skill.target) {
case SKILL_TARGET.ENEMY:
return pick(foes);
case SKILL_TARGET.ALL_ENEMIES:
return foes;
case SKILL_TARGET.ALLY:
return skill.kind === SKILL_KIND.DEBUFF ? pick(foes) : pick(friends);
case SKILL_TARGET.ALL_ALLIES:
return friends;
case SKILL_TARGET.LOWEST_ALLY:
return lowestHpRatio(friends);
case SKILL_TARGET.SELF:
return [actor];
default:
return [];
}
}
function applySkillEffects(
skill: BattleSkill,
targets: readonly BattleUnit[],
events: BattleEvent[],
): void {
for (const target of targets) {
if (!target.alive) continue;
for (const effect of skill.effects) {
target.effects.push(toEffect(effect));
events.push({ kind: 'effect', targetId: target.id, effect: toEffect(effect) });
}
}
}
/** スキルの効果を、ユニットに付ける1つ分にする。使い回さないよう毎回作り直す */
function toEffect(effect: BattleSkillEffect): BattleEffect {
return { code: effect.code, value: effect.value, duration: effect.duration };
}
/**
* ダメージ = max(1, 現在ATK × 威力 × 属性 − 現在DEF × DEF係数)。
*
* 威力・属性・DEF係数がそれぞれ万分率なので、分母は 10000^2 = 1e8 に揃える。
* 途中の値は ATK×威力×属性 で 1e12 程度。MAX_SAFE_INTEGER には十分収まる
*/
function damageOf(state: BattleState, actor: BattleUnit, target: BattleUnit, skill: BattleSkill): {
damage: number;
effective: number;
} {
const effective = affinityMultiplier(state.setup.affinity, actor.element, target.element);
const attack = currentAtk(actor) * skill.power * effective;
const defense = currentDef(target) * state.setup.rules.defReduction * PERMYRIAD;
return {
damage: Math.max(1, roundDiv(attack - defense, PERMYRIAD_SQUARED)),
effective,
};
}
function executeSkill(
state: BattleState,
actor: BattleUnit,
skill: BattleSkill,
events: BattleEvent[],
): void {
const targets = resolveTargets(state, actor, skill);
if (skill.kind === SKILL_KIND.ATTACK) {
for (const target of targets) {
const { damage, effective } = damageOf(state, actor, target, skill);
events.push({
kind: 'attack',
actorId: actor.id,
targetId: target.id,
damage,
damageType: skill.damageType,
element: actor.element,
effective,
isUltimate: skill.isUltimate,
skillId: skill.skillId,
});
applyDamage(target, damage, events);
}
applySkillEffects(skill, targets, events);
return;
}
if (skill.kind === SKILL_KIND.HEAL) {
for (const target of targets) {
const amount = roundDiv(currentAtk(actor) * skill.power, PERMYRIAD);
target.hp = Math.min(target.maxHp, target.hp + amount);
events.push({
kind: 'heal',
actorId: actor.id,
targetId: target.id,
amount,
skillId: skill.skillId,
});
}
applySkillEffects(skill, targets, events);
return;
}
// バフ / デバフ:効果を付けるだけ
applySkillEffects(skill, targets, events);
}
/**
* ヒーラーAI:味方に HP が閾値(割合)を割っている者がいれば回復、いなければ基本攻撃。
*
* 割合の比較は割り算をせず、両辺に分母を掛けた整数のまま行う
*/
function healerChoice(state: BattleState, actor: BattleUnit): BattleSkill {
const threshold = state.setup.rules.healerAiThreshold;
const needHeal = livingFriends(state, actor).some(
(friend) => friend.hp * PERMYRIAD < friend.maxHp * threshold,
);
return needHeal ? actor.normalSkill : BASIC_ATTACK;
}
/** 行動の中身。必殺を使うかどうかは決まった状態で呼ぶ */
function performAction(
state: BattleState,
actor: BattleUnit,
useUltimate: boolean,
events: BattleEvent[],
): BattleEvent[] {
if (useUltimate) {
actor.gauge = 0;
executeSkill(state, actor, actor.ultimate, events);
} else if (actor.role === ROLE.HEALER && actor.normalSkill.kind === SKILL_KIND.HEAL) {
executeSkill(state, actor, healerChoice(state, actor), events);
} else {
executeSkill(state, actor, actor.normalSkill, events);
}
checkEnd(state, events);
return events;
}
/**
* バトルを1ステップ進める(= 1ユニットの行動、またはターン境界の処理)。
*
* awaitUltimate が返ったら、次の呼び出しで ultDecision を渡すこと
* (true = 必殺発動 / false = 通常行動でゲージ維持)
*/
export function battleStep(state: BattleState, ultDecision?: boolean): BattleEvent[] {
const events: BattleEvent[] = [];
if (state.finished) return events;
const rules = state.setup.rules;
// 必殺の入力待ちを解決する
if (state.awaiting !== null) {
const actor = unitById(state, state.awaiting);
state.awaiting = null;
if (ultDecision === undefined) throw new Error('awaiting ultimate decision');
return performAction(state, actor, ultDecision && actor.gauge >= rules.ultGaugeMax, events);
}
// ターン境界
while (state.queue.length === 0) {
state.turn++;
// 保険:時間切れは敗北扱い
if (state.turn > rules.turnLimit) return endBattle(state, false, events);
if (state.turn > 1) {
tickEffects(state, events);
if (checkEnd(state, events)) return events;
}
state.queue = state.units
.filter((u) => u.alive)
// 同速なら units の並びで先のもの。Array#sort は安定なのでそのままで満たせる
.sort((a, b) => currentSpd(b) - currentSpd(a))
.map((u) => u.id);
}
// 次の行動者
const id = state.queue.shift();
if (id === undefined) return events;
const actor = unitById(state, id);
if (!actor.alive) {
// ターンの途中で倒れたユニットは飛ばす。ここまでに積んだイベントは落とさない
for (const event of battleStep(state)) events.push(event);
return events;
}
events.push({ kind: 'turnStart', unitId: actor.id });
actor.gauge = Math.min(rules.ultGaugeMax, actor.gauge + rules.ultGaugePerAction);
if (isStunned(actor)) {
events.push({ kind: 'skip', unitId: actor.id, reason: 'stun' });
return events;
}
const canUlt = actor.gauge >= rules.ultGaugeMax;
// 味方の必殺は必ず入力を待つ。AUTO かどうかはクライアントの都合で、バトルは知らない
if (canUlt && actor.side === 'ally') {
state.awaiting = actor.id;
events.push({ kind: 'awaitUltimate', readyUnitIds: readyAllies(state) });
return events;
}
return performAction(state, actor, canUlt, events);
}shared/battle/setup.ts
// マスタの行から、バトルの入力(BattleSetup)を組み立てる。
//
// サーバとクライアントでマスタの持ち方が違う(サーバはDBから読んだ行、クライアントは配信JSON)。
// ここではストアもDBも import せず、引き方だけを BattleMaster として受け取る。
// こうしておけば、バトルに渡る値が両側で同じであることをこのファイルだけで保証できる。
import { DAMAGE_TYPE, SKILL_KIND, SKILL_TARGET } from './codes.ts';
import { PERMYRIAD, roundDiv, toPermyriad } from './fixed.ts';
// ---- バトルに渡る形 ----
/** スキル1つ。power と effects の value は万分率 */
export interface BattleSkill {
/** マスタに無い基本技は 0 */
skillId: number;
kind: number;
target: number;
damageType: number;
/** 万分率 */
power: number;
isUltimate: boolean;
effects: BattleSkillEffect[];
}
/** スキルが付ける効果。value は万分率 */
export interface BattleSkillEffect {
code: string;
value: number;
duration: number;
}
/** バトルに出る1体。ステータスは計算済み */
export interface BattleUnitSpec {
/** 味方は "a{slot_no}"、敵は "e{sort_no}" */
unitId: string;
side: 'ally' | 'enemy';
element: number;
role: number;
isBoss: boolean;
maxHp: number;
atk: number;
def: number;
spd: number;
normalSkill: BattleSkill;
ultimate: BattleSkill;
}
/** バトルの数値ルール。倍率は万分率、回数は整数 */
export interface BattleRules {
ultGaugePerAction: number;
ultGaugeMax: number;
/** 万分率 */
defReduction: number;
/** 万分率 */
healerAiThreshold: number;
turnLimit: number;
}
/** バトル1回分の入力。これとシードが決まれば結果は決まる */
export interface BattleSetup {
/** 味方(slot_no 順)→ 敵(sort_no 順)。この並びが同点時の優先順になる */
units: BattleUnitSpec[];
/** "攻撃側属性:防御側属性" → 万分率 */
affinity: Map<string, number>;
rules: BattleRules;
}
// ---- マスタから受け取る最小限の形 ----
// サーバの型(api-server/src/master/types.ts)もクライアントの型(game-client/src/master/types.ts)も
// これを満たす。どちらかに寄せず、必要な列だけを書く。
export interface SkillSource {
id: number;
kind: number;
target: number;
/** DECIMAL。文字列のまま受け取る */
power: string;
damage_type: number;
/** TINYINT(1)。0 / 1 で来る */
is_ultimate: number;
}
export interface SkillEffectSource {
effect_code: string;
/** DECIMAL。文字列のまま受け取る */
value: string;
duration: number;
}
export interface ElementAffinitySource {
attacker_element: number;
defender_element: number;
/** DECIMAL。文字列のまま受け取る */
multiplier: string;
}
/** バトルに要るヒーローの列。ステータスは別途計算済みのものを渡す */
export interface HeroSource {
element: number;
role: number;
normal_skill_id: number;
ultimate_skill_id: number;
}
/** バトルに要る敵の列。ステータスもスキルも配信されないので、これ以外はサーバが渡す */
export interface EnemySource {
element: number;
role: number;
is_boss: number;
}
/** マスタの引き方。サーバもクライアントも、自分のストアにこの形を被せて渡す */
export interface BattleMaster {
hero(heroId: number): HeroSource | undefined;
enemy(enemyId: number): EnemySource | undefined;
skill(skillId: number): SkillSource | undefined;
skillEffects(skillId: number): readonly SkillEffectSource[];
}
/** POST /battle/start が返す味方1体。Redis に入るのも同じ形 */
export interface BattleAllyStats {
unit_id: string;
hero_id: number;
max_hp: number;
atk: number;
def: number;
spd: number;
}
/** POST /battle/start が返す敵1体。Redis に入るのも同じ形 */
export interface BattleEnemyStats {
unit_id: string;
enemy_id: number;
max_hp: number;
atk: number;
def: number;
spd: number;
skill_id: number;
}
// ---- 基本技 ----
/** マスタにスキルを持たないときの通常攻撃。ATK×1.0 の物理・敵単体 */
export const BASIC_ATTACK: BattleSkill = {
skillId: 0,
kind: SKILL_KIND.ATTACK,
target: SKILL_TARGET.ENEMY,
damageType: DAMAGE_TYPE.PHYSICAL,
power: 10000,
isUltimate: false,
effects: [],
};
/** 専用の必殺を持たないときの必殺。ATK×2.2 の物理・敵単体 */
export const GENERIC_ULTIMATE: BattleSkill = {
skillId: 0,
kind: SKILL_KIND.ATTACK,
target: SKILL_TARGET.ENEMY,
damageType: DAMAGE_TYPE.PHYSICAL,
power: 22000,
isUltimate: true,
effects: [],
};
// ---- 組み立て ----
/**
* マスタの skill / skill_effect の行を BattleSkill にする。
* 行が無ければ fallback(基本攻撃か汎用必殺)に倒す
*/
export function toBattleSkill(
skill: SkillSource | undefined,
effects: readonly SkillEffectSource[],
fallback: BattleSkill,
): BattleSkill {
if (skill === undefined) return fallback;
return {
skillId: skill.id,
kind: skill.kind,
target: skill.target,
damageType: skill.damage_type,
power: toPermyriad(skill.power),
isUltimate: skill.is_ultimate !== 0,
effects: effects.map((effect) => ({
code: effect.effect_code,
value: toPermyriad(effect.value),
duration: effect.duration,
})),
};
}
/** ヒーローの通常技と必殺。マスタに行が無ければ基本技に倒す */
function heroSkills(
master: BattleMaster,
hero: HeroSource,
): { normalSkill: BattleSkill; ultimate: BattleSkill } {
return {
normalSkill: lookupSkill(master, hero.normal_skill_id, BASIC_ATTACK),
ultimate: lookupSkill(master, hero.ultimate_skill_id, GENERIC_ULTIMATE),
};
}
/**
* 敵の通常技と必殺。敵が持てる専用スキルは1つだけなので、それが必殺かどうかで置き場が変わる。
*
* skill_id = 0 … 通常は基本攻撃、必殺は汎用必殺
* 必殺でないスキル … 通常がそのスキル、必殺は汎用必殺
* 必殺のスキル … 通常は基本攻撃、必殺がそのスキル
*/
function enemySkills(
master: BattleMaster,
skillId: number,
): { normalSkill: BattleSkill; ultimate: BattleSkill } {
const skill = skillId === 0 ? undefined : master.skill(skillId);
if (skill === undefined) return { normalSkill: BASIC_ATTACK, ultimate: GENERIC_ULTIMATE };
const built = toBattleSkill(skill, master.skillEffects(skillId), BASIC_ATTACK);
return built.isUltimate
? { normalSkill: BASIC_ATTACK, ultimate: built }
: { normalSkill: built, ultimate: GENERIC_ULTIMATE };
}
/** skill_id からスキルを引く。0 やマスタに無いIDは fallback */
function lookupSkill(master: BattleMaster, skillId: number, fallback: BattleSkill): BattleSkill {
if (skillId === 0) return fallback;
return toBattleSkill(master.skill(skillId), master.skillEffects(skillId), fallback);
}
/** 属性相性を引くキー。"攻撃側属性:防御側属性" */
export function affinityKey(attacker: number, defender: number): string {
return `${attacker}:${defender}`;
}
/** element_affinity の行から相性表を作る。値は万分率 */
export function buildAffinity(rows: readonly ElementAffinitySource[]): Map<string, number> {
const affinity = new Map<string, number>();
for (const row of rows) {
affinity.set(
affinityKey(row.attacker_element, row.defender_element),
toPermyriad(row.multiplier),
);
}
return affinity;
}
/** 相性の倍率(万分率)。表に無い組み合わせは等倍に倒す */
export function affinityMultiplier(
affinity: Map<string, number>,
attacker: number,
defender: number,
): number {
return affinity.get(affinityKey(attacker, defender)) ?? PERMYRIAD;
}
/** game_config から拾った値。DECIMAL の文字列のまま渡す */
export interface BattleRulesSource {
ultGaugePerAction: string;
ultGaugeMax: string;
defReduction: string;
healerAiThreshold: string;
turnLimit: string;
}
/**
* game_config の値を BattleRules にする。
*
* 文字列から数値にするのは toPermyriad だけを通す。Number() や parseFloat は使わない。
* 整数で欲しい値も、いったん万分率にしてから 10000 で割る
*/
export function buildBattleRules(source: BattleRulesSource): BattleRules {
return {
ultGaugePerAction: toInteger(source.ultGaugePerAction),
ultGaugeMax: toInteger(source.ultGaugeMax),
defReduction: toPermyriad(source.defReduction),
healerAiThreshold: toPermyriad(source.healerAiThreshold),
turnLimit: toInteger(source.turnLimit),
};
}
function toInteger(decimal: string): number {
return roundDiv(toPermyriad(decimal), PERMYRIAD);
}
/**
* バトルの入力を組み立てる。
*
* 味方(slot_no 順)→ 敵(sort_no 順)の順に並べる。この並びは、
* 速度が同じときの行動順と、対象が同点のときの選び方にそのまま効く
*/
export function buildBattleSetup(
master: BattleMaster,
allies: readonly BattleAllyStats[],
enemies: readonly BattleEnemyStats[],
affinity: Map<string, number>,
rules: BattleRules,
): BattleSetup {
const units: BattleUnitSpec[] = [];
for (const ally of allies) {
const hero = master.hero(ally.hero_id);
if (hero === undefined) throw new Error(`hero に id=${ally.hero_id} が無い`);
units.push({
unitId: ally.unit_id,
side: 'ally',
element: hero.element,
role: hero.role,
isBoss: false,
maxHp: ally.max_hp,
atk: ally.atk,
def: ally.def,
spd: ally.spd,
...heroSkills(master, hero),
});
}
for (const enemy of enemies) {
const row = master.enemy(enemy.enemy_id);
if (row === undefined) throw new Error(`enemy に id=${enemy.enemy_id} が無い`);
units.push({
unitId: enemy.unit_id,
side: 'enemy',
element: row.element,
role: row.role,
isBoss: row.is_boss !== 0,
maxHp: enemy.max_hp,
atk: enemy.atk,
def: enemy.def,
spd: enemy.spd,
...enemySkills(master, enemy.skill_id),
});
}
return { units, affinity, rules };
}api-server/src/routes/battle.ts
import { randomBytes, randomInt } from "node:crypto";
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 { recoverStamina, staminaMaxOf } from "../user/stamina.ts";
import { formatUtc } from "../datetime.ts";
import { master } from "../master/store.ts";
import { configNumber } from "../master/config.ts";
import type { Stage, StageEnemy } from "../master/types.ts";
import { battleSetupOf, configValue } from "../battle/master.ts";
import { consumeBattle, saveBattle } from "../battle/session.ts";
import type { BattleSession } from "../battle/session.ts";
import {
BATTLE_DECISIONS_MAX,
BATTLE_ID_BYTES,
BATTLE_SEED_LIMIT,
GAME_CONFIG_KEY,
PERMYRIAD_TOTAL,
} from "../constants.ts";
import { readArrayField, readIntegerField, readJsonBody, sendError, sendJson } from "../http.ts";
import { toPermyriad } from "../../../shared/battle/fixed.ts";
import { enemyStats, heroStats } from "../../../shared/battle/stats.ts";
import { runReplay } from "../../../shared/battle/replay.ts";
import type { BattleAllyStats, BattleEnemyStats } from "../../../shared/battle/setup.ts";
// ステージの進捗とバトル。
//
// 勝敗を決めるのはサーバ。クライアントはバトルを動かして見せるだけで、
// 送ってくるのは「必殺を撃ったかどうか」の入力の列だけにする。
// サーバは同じシードと同じ入力で、同じバトルのコード(shared/battle/)を回し直して判定する。
/** レスポンスと Redis に載る味方1体。unit_id は "a{slot_no}" */
type StartAlly = BattleAllyStats & {
user_hero_id: number;
level: number;
};
/** レスポンスと Redis に載る敵1体。unit_id は "e{sort_no}" */
type StartEnemy = BattleEnemyStats;
type StartResponse = {
battle_id: string;
seed: number;
elite: boolean;
allies: StartAlly[];
enemies: StartEnemy[];
/** スタミナ消費後の値。HUD の差し替えに使う */
status: { stamina: number; stamina_updated_at: string };
};
/**
* 開始の結果。
*
* 「解放されていない」「スタミナが足りない」は例外ではなく起きうる結果なので、
* 種類として返してハンドラ側で振り分ける(ガチャ・デッキと同じ形)
*/
type StartOutcome =
| { kind: "ok"; response: StartResponse }
| { kind: "stageLocked" }
| { kind: "emptyDeck" }
| { kind: "notEnoughStamina" }
| { kind: "userNotFound" };
/** デッキに入っている個体1つ分。ステータスはここから計算する */
type DeckMember = {
slotNo: number;
userHeroId: number;
heroId: number;
level: number;
};
/** GET /user/stages — クリア済みのステージIDを返す */
export async function handleUserStages(
_req: IncomingMessage,
res: ServerResponse,
userId: number,
): Promise<void> {
sendJson(res, 200, { cleared_stage_ids: await selectClearedStageIds(userPool, userId) });
}
/** POST /battle/start — スタミナを消費してバトルを始める */
export async function handleBattleStart(
req: IncomingMessage,
res: ServerResponse,
userId: number,
): Promise<void> {
const body = await readJsonBody(req);
const stageId = readIntegerField(body, "stage_id");
const stage = stageId === null ? undefined : master.get_stage(stageId);
if (stage === undefined) {
sendError(res, 400, "INVALID_STAGE", "stage_id が不正");
return;
}
const outcome = await withUserTransaction((conn) => startBattle(conn, userId, stage, new Date()));
// ここから先は例外を投げうる処理を置かない。
// コミット済みなのに 500 を返す(スタミナは減ったのに失敗に見える)状態を作らないため
if (outcome.kind === "userNotFound") {
sendError(res, 401, "UNAUTHORIZED", "ユーザーが存在しない");
return;
}
if (outcome.kind === "stageLocked") {
sendError(res, 400, "STAGE_LOCKED", "まだ解放されていないステージ");
return;
}
if (outcome.kind === "emptyDeck") {
sendError(res, 400, "EMPTY_DECK", "使用中のデッキが空");
return;
}
if (outcome.kind === "notEnoughStamina") {
sendError(res, 400, "NOT_ENOUGH_STAMINA", "スタミナが足りない");
return;
}
sendJson(res, 200, outcome.response);
}
/**
* バトルを開始する。
*
* 行ロックの順番は user_status → user_stage → user_deck → user_hero で固定する。
* Redis への書き込みはコミットの前に置く。書けなければ例外でロールバックされ、スタミナは減らない
*/
async function startBattle(
conn: PoolConnection,
userId: number,
stage: Stage,
now: Date,
): Promise<StartOutcome> {
const status = await selectStatusForUpdate(conn, userId);
if (status === null) return { kind: "userNotFound" };
// 解放の判定はサーバでもやる。クライアントの表示は当てにしない
const cleared = await selectClearedStageIds(conn, userId);
if (!isUnlocked(stage, new Set(cleared))) return { kind: "stageLocked" };
const deck = await selectDeckMembers(conn, userId, status.activeDeckId);
if (deck.length === 0) return { kind: "emptyDeck" };
// 時間回復を済ませてから引く。足りなければ何も書かずに終える
const recovered = recoverStamina(
status.stamina,
status.staminaUpdatedAt,
staminaMaxOf(status.playerLv),
now,
);
if (recovered.stamina < stage.stamina_cost) return { kind: "notEnoughStamina" };
const stamina = recovered.stamina - stage.stamina_cost;
await conn.execute(
"UPDATE `user_status` SET `stamina` = ?, `stamina_updated_at` = ? WHERE `user_id` = ?",
[stamina, recovered.staminaUpdatedAt, userId],
);
// 強敵の抽選とシードは暗号的な乱数で引く。シード付き乱数(バトル用)は使わない
const elite = randomInt(PERMYRIAD_TOTAL) < toPermyriad(configValue(GAME_CONFIG_KEY.ELITE_CHANCE));
const seed = randomInt(0, BATTLE_SEED_LIMIT);
const battleId = randomBytes(BATTLE_ID_BYTES).toString("hex");
const session: BattleSession = {
user_id: userId,
stage_id: stage.id,
seed,
elite,
allies: deck.map(toStartAlly),
enemies: stageEnemies(stage.id, elite),
started_at: formatUtc(now),
};
// コミットの前に置く。Redis に書けなかったらロールバックされ、スタミナも減らない
await saveBattle(battleId, session);
return {
kind: "ok",
response: {
battle_id: battleId,
seed,
elite,
allies: session.allies,
enemies: session.enemies,
status: {
stamina,
stamina_updated_at: formatUtc(recovered.staminaUpdatedAt),
},
},
};
}
/** POST /battle/finish — 入力の列を受け取り、サーバで回し直して勝敗を決める */
export async function handleBattleFinish(
req: IncomingMessage,
res: ServerResponse,
userId: number,
): Promise<void> {
const body = await readJsonBody(req);
const battleId = readBattleId(body);
const decisions = readDecisions(body);
if (battleId === null || decisions === null) {
sendError(res, 400, "INVALID_REQUEST", "battle_id か ultimate_decisions が不正");
return;
}
// 取り出しと削除を1回で行う。同じバトルを2回終わらせることはできない
const session = await consumeBattle(battleId);
if (session === null || session.user_id !== userId) {
sendError(res, 400, "BATTLE_NOT_FOUND", "そのバトルは無い");
return;
}
const result = runReplay(battleSetupOf(session.allies, session.enemies), session.seed, decisions);
if (result.kind === "invalid") {
sendError(res, 400, "INVALID_REPLAY", `入力の列で再現できない: ${result.reason}`);
return;
}
warnOnMismatch(battleId, body, result.win, result.turns);
const firstClear = result.win
? await withUserTransaction((conn) => recordClear(conn, userId, session.stage_id, new Date()))
: false;
sendJson(res, 200, { win: result.win, turns: result.turns, first_clear: firstClear });
}
/**
* クリアを記録する。既に行があれば何もしない(cleared_at も動かさない)。
*
* user_status を先に押さえるのは、次回の報酬でここに書くから。
* 報酬が入ってからロックの順番を変えなくて済むよう、いま揃えておく
*/
async function recordClear(
conn: PoolConnection,
userId: number,
stageId: number,
now: Date,
): Promise<boolean> {
await selectStatusForUpdate(conn, userId);
const [rows] = await conn.execute<RowDataPacket[]>(
"SELECT `stage_id` FROM `user_stage` WHERE `user_id` = ? AND `stage_id` = ? FOR UPDATE",
[userId, stageId],
);
if (rows[0] !== undefined) return false;
await conn.execute(
"INSERT INTO `user_stage` (`user_id`, `stage_id`, `cleared_at`) VALUES (?, ?, ?)",
[userId, stageId, now],
);
return true;
}
/**
* クライアントが出した結果と食い違っていたらログに出す。エラーにはしない。
* 正しいのは常にサーバの結果で、client_result は判定に使わない
*/
function warnOnMismatch(battleId: string, body: unknown, win: boolean, turns: number): void {
const clientResult = readClientResult(body);
if (clientResult === null) return;
if (clientResult.win === win && clientResult.turns === turns) return;
console.warn(
`[battle] client_result mismatch battle_id=${battleId}` +
` server=${JSON.stringify({ win, turns })} client=${JSON.stringify(clientResult)}`,
);
}
// ---- 入力の検証 ----
function readBattleId(body: unknown): string | null {
if (typeof body !== "object" || body === null) return null;
const value = (body as Record<string, unknown>).battle_id;
return typeof value === "string" && value !== "" ? value : null;
}
/** 真偽値の配列であることと、長さの上限だけを見る。中身が正しいかはリプレイが判定する */
function readDecisions(body: unknown): boolean[] | null {
const raw = readArrayField(body, "ultimate_decisions");
if (raw === null || raw.length > BATTLE_DECISIONS_MAX) return null;
if (raw.some((value) => typeof value !== "boolean")) return null;
return raw as boolean[];
}
/** 判定には使わないので、形が違えば「無かった」ものとして黙って捨てる */
function readClientResult(body: unknown): { win: boolean; turns: number } | null {
if (typeof body !== "object" || body === null) return null;
const value = (body as Record<string, unknown>).client_result;
if (typeof value !== "object" || value === null) return null;
const win = (value as Record<string, unknown>).win;
const turns = (value as Record<string, unknown>).turns;
if (typeof win !== "boolean" || typeof turns !== "number") return null;
return { win, turns };
}
// ---- マスタとユーザーデータの読み出し ----
/**
* 挑戦できるかどうか。
* sort_no が最小のステージは最初から、それ以外は1つ前がクリア済みなら挑戦できる
*/
function isUnlocked(stage: Stage, cleared: ReadonlySet<number>): boolean {
const stages = master.get_table("stage") as readonly Stage[];
const index = stages.findIndex((row) => row.id === stage.id);
if (index <= 0) return true;
return cleared.has(stages[index - 1].id);
}
/** クリア済みのステージID。stage_id の昇順 */
async function selectClearedStageIds(conn: Connection, userId: number): Promise<number[]> {
const [rows] = await conn.execute<RowDataPacket[]>(
"SELECT `stage_id` FROM `user_stage` WHERE `user_id` = ? ORDER BY `stage_id`",
[userId],
);
return rows.map((row) => Number(row.stage_id));
}
/**
* 使用中デッキの中身。持っていない個体を指している行は落とす(枠が空いているのと同じ)。
*
* user_deck と user_hero は同じDBなので JOIN で1回で引く。
* 他人の個体を混ぜられないよう、どちらにも user_id を条件に入れる
*/
async function selectDeckMembers(
conn: PoolConnection,
userId: number,
deckId: number,
): Promise<DeckMember[]> {
const [rows] = await conn.execute<RowDataPacket[]>(
"SELECT `d`.`slot_no`, `h`.`user_hero_id`, `h`.`hero_id`, `h`.`level`" +
" FROM `user_deck` AS `d`" +
" INNER JOIN `user_hero` AS `h`" +
" ON `h`.`user_id` = `d`.`user_id` AND `h`.`user_hero_id` = `d`.`user_hero_id`" +
" WHERE `d`.`user_id` = ? AND `d`.`deck_id` = ? AND `d`.`slot_no` < ?" +
" ORDER BY `d`.`slot_no`",
[userId, deckId, configNumber(GAME_CONFIG_KEY.DECK_SIZE)],
);
return rows.map((row) => ({
slotNo: Number(row.slot_no),
userHeroId: Number(row.user_hero_id),
heroId: Number(row.hero_id),
level: Number(row.level),
}));
}
/** デッキの個体を、ステータス計算済みの味方1体にする */
function toStartAlly(member: DeckMember): StartAlly {
const hero = master.get_hero(member.heroId);
if (hero === undefined) throw new Error(`hero に id=${member.heroId} が無い`);
const stats = heroStats(
hero,
master.get_rarity(hero.rarity_id),
master.get_hero_level_curve(member.level),
);
return {
unit_id: `a${member.slotNo}`,
user_hero_id: member.userHeroId,
hero_id: member.heroId,
level: member.level,
max_hp: stats.hp,
atk: stats.atk,
def: stats.def,
spd: stats.spd,
};
}
/**
* ステージに出る敵を、ステータス計算済みで並べる。
*
* 敵のステータスもレベルも配信していないので、クライアントはこの値をそのまま使う。
* 強敵の倍率もここで掛け終える
*/
function stageEnemies(stageId: number, elite: boolean): StartEnemy[] {
const eliteStatMul = toPermyriad(configValue(GAME_CONFIG_KEY.ELITE_STAT_MUL));
return (master.get_stage_enemies(stageId) as readonly StageEnemy[]).map((row) => {
const enemy = master.get_enemy(row.enemy_id);
if (enemy === undefined) throw new Error(`enemy に id=${row.enemy_id} が無い`);
const stats = enemyStats(
enemy,
master.get_hero_level_curve(row.enemy_level),
elite,
eliteStatMul,
);
return {
unit_id: `e${row.sort_no}`,
enemy_id: row.enemy_id,
max_hp: stats.hp,
atk: stats.atk,
def: stats.def,
spd: stats.spd,
skill_id: enemy.skill_id,
};
});
}api-server/src/battle/session.ts
import { redis } from "../redis.ts";
import { BATTLE_KEY_PREFIX, BATTLE_TTL_SECONDS } from "../constants.ts";
import type {
BattleAllyStats,
BattleEnemyStats,
} from "../../../shared/battle/setup.ts";
// 開始したバトルの置き場。読み書きはこのモジュールに閉じ、Redis であることを外に漏らさない。
//
// 終了時は DB を読み直さない。開始時に計算したステータスをそのまま使って
// BattleSetup を組み立て直す。途中で強化や編成を変えられても、このバトルには効かない。
/** Redis に入れる1バトル分。レスポンスに載せたものと同じ値を持つ */
export type BattleSession = {
user_id: number;
stage_id: number;
seed: number;
elite: boolean;
allies: BattleAllyStats[];
enemies: BattleEnemyStats[];
/** 開始時刻。UTC の文字列 */
started_at: string;
};
function battleRedisKey(battleId: string): string {
return `${BATTLE_KEY_PREFIX}${battleId}`;
}
/**
* バトルを置く。TTL を過ぎたら消える(=退却したのと同じ扱いになる)。
*
* 呼ぶのはトランザクションのコミット前。ここで失敗すれば例外でロールバックされ、
* スタミナも減らない
*/
export async function saveBattle(battleId: string, session: BattleSession): Promise<void> {
await redis.set(battleRedisKey(battleId), JSON.stringify(session), {
expiration: { type: "EX", value: BATTLE_TTL_SECONDS },
});
}
/**
* バトルを取り出すと同時に削除する。無ければ null。
*
* GETDEL は単一のコマンドなので、同じ battle_id で並行して叩かれても
* 受け取れるのは片方だけ。同じバトルを2回終わらせることはできない(ワンタイムキーと同じ)
*/
export async function consumeBattle(battleId: string): Promise<BattleSession | null> {
const raw = await redis.getDel(battleRedisKey(battleId));
if (raw === null) return null;
return JSON.parse(raw) as BattleSession;
}game-client/src/api/battle.ts
// ステージの進捗とバトル。
//
// 勝敗を決めるのはサーバ。クライアントはバトルを動かして見せるが、その結果は判定に使わない。
// 送るのは「必殺を撃ったかどうか」の入力の列だけで、サーバは同じシードで回し直す。
import { apiGet, apiPost } from './client';
/** バトルに出る味方1体。ステータスはサーバが計算済みのものを使う */
export interface BattleAlly {
unit_id: string;
user_hero_id: number;
hero_id: number;
level: number;
max_hp: number;
atk: number;
def: number;
spd: number;
}
/** バトルに出る敵1体。スキルの中身は配信済みの skill / skill_effect から引く */
export interface BattleEnemy {
unit_id: string;
enemy_id: number;
max_hp: number;
atk: number;
def: number;
spd: number;
skill_id: number;
}
export interface BattleStartResponse {
battle_id: string;
seed: number;
elite: boolean;
allies: BattleAlly[];
enemies: BattleEnemy[];
/** スタミナ消費後の値。HUD の差し替えに使う */
status: { stamina: number; stamina_updated_at: string };
}
export interface BattleFinishResponse {
win: boolean;
turns: number;
first_clear: boolean;
}
/** クライアントで出た結果。判定には使われず、食い違いの検知にだけ使われる */
export interface ClientResult {
win: boolean;
turns: number;
}
/** GET /user/stages。クリア済みのステージID(stage_id 昇順) */
export async function fetchClearedStages(token: string): Promise<number[]> {
return (await apiGet<{ cleared_stage_ids: number[] }>('/user/stages', token)).cleared_stage_ids;
}
/** POST /battle/start。ここでスタミナが減る */
export function startBattle(token: string, stageId: number): Promise<BattleStartResponse> {
return apiPost<BattleStartResponse>('/battle/start', { stage_id: stageId }, token);
}
/** POST /battle/finish。同じ battle_id で2回は送れない */
export function finishBattle(
token: string,
battleId: string,
decisions: readonly boolean[],
clientResult: ClientResult,
): Promise<BattleFinishResponse> {
return apiPost<BattleFinishResponse>(
'/battle/finish',
{ battle_id: battleId, ultimate_decisions: decisions, client_result: clientResult },
token,
);
}