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

ソシャゲのサーバーを作る。バトルの報酬(15)

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

    勝ち負けはサーバが決めるようになりました。
    ただ、勝っても「WIN!」と出るだけで、何ももらえていないんですよね。

    今回は報酬を付けます。

    報酬は共有しない

    前回、バトルのコードはサーバとクライアントで共有しました。
    同じバトルを両方で回す必要があったので。

    報酬は、共有しません。
    報酬の計算は、サーバで1回やれば済みます。
    クライアントで同じ計算をして答え合わせをする理由がない。

    クライアントがやるのは、サーバが返してきた数字を出すだけです。

    "rewards": {
      "elite": false,
      "gold": 1,
      "materials": 1,
      "exp": 6,
      "first_clear_bonus": 5
    }

    プロトは画面側で報酬を計算して表示していましたが、そこは移植していません。
    クエスト画面に出ている「報酬 1G・素材1・EXP6」はマスタの値をそのまま出しているだけで、
    実際にいくら入ったかは、必ずサーバの応答を見ます。

    共有するのは「両方で同じ計算をしないといけないもの」だけ。
    なんでも共有に寄せると、今度はクライアントに要らないものまで見えてしまうので。

    1つのトランザクションで

    勝ったときに書き換えるものを並べるとこうなります。

    クリアの記録(初回なら)
    ゴールド(報酬 + 初回ボーナス)
    強化素材
    プレイヤーEXP、Lv
    スタミナ(Lvが上がったら)

    全部、1つのトランザクションに入れています。
    ガチャのときと同じで、「ゴールドは入ったのにEXPが入っていない」を作らないためですね。

    ここで、テーブルが増えてきたのでロックの順番を一度まとめました。

    user_status → user_stage → user_currency → user_item → user_deck → user_hero

    ガチャ、編成、バトル開始、今回の報酬。
    どのAPIも、この順番でしか行を押さえません。

    2つのAPIが同じ行を逆の順番で押さえに行くと、お互いを待ち続けて止まります。
    いわゆるデッドロックですね。
    順番を1本に決めておけば、少なくともそれは起きません。

    APIごとに気をつけるより、一覧にして貼っておくほうが確実です。

    行が無いかもしれない

    ゴールドと素材を足すところで、1つ引っかかります。

    10本目で、新規アカウントの初期データには、アイテムの行を作らないことにしました。

    素材を1つも持っていない人は、`user_item` に素材の行が無い。
    なので「今の値に足す」UPDATE を流しても、何も起きません。
    ゴールドは初期データで行を作っていますが、同じ書き方にそろえておきます。

    先に行があるか見て、無ければINSERT、あればUPDATE。
    これを2文でやると、間に同じユーザーのリクエストが来たときに両方がINSERTしようとします。

    なので1文にしました。

    INSERT INTO `user_item` (`user_id`, `item_id`, `amount`) VALUES (?, ?, ?)
      ON DUPLICATE KEY UPDATE `amount` = LEAST(`amount` + VALUES(`amount`), ?)

    行が無ければ入れる。あれば足す。

    `LEAST` は桁あふれの頭打ちです。
    `amount` は `INT` なので、21億を超えるとエラーになります。
    普通に遊んでいて届く数字ではないですが、
    届いたときにエラーで報酬ごと消えるよりは、上限で止まってくれたほうがいいので。

    レベルは何段でも上がる

    EXPを足してLvを上げるところは、ループにしています。

    今のLvの必要EXPに届いたら、差し引いて1つ上げる
    届かなくなるまで繰り返す

    1回で1段、と決め打ちすると、大量のEXPをもらったときに取りこぼします。
    今の第1章だとそこまでのEXPは出ませんが、
    イベントの報酬などで一気に入るのはソシャゲではよくある話なので。

    Lvが上がったら、スタミナ上限が増えて全回復します。

    ただし、上限を超えて持っている分は削りません。
    回復アイテムで上限を超えて持っている人が、Lvアップで減ったら怒りますよね。
    10本目で `stamina` の列に「上限を超えることがある」と書いておいたのは、こういうときのためです。

    最大Lvに届いたら、それ以上は上げません。
    EXPはその段の必要量で止めて、ゲージが満タンのままになるようにしています。

    同じ意味の値が2つあった

    マスタを見直していて、気づいたことがあります。

    `game_config` に、スタミナの回復間隔が2つ入っていました。

    stamina_regen_seconds   900     プロトから持ってきた値
    stamina_recover_ms      30000   サーバが実際に使っている値

    Lvアップでスタミナ上限が増える量も、
    `game_config` の `stamina_levelup_bonus` と、`player_level_curve` の `stamina_max` の2か所にあります。

    どちらも、プロトの定数をマスタに移したときの名残ですね。

    困るのは、企画がどちらを直せばいいか分からないことです。
    片方だけ直して、ゲームの挙動が変わらない。
    しばらくして誰かが気づく。

    今回は、サーバが使っている側を正にしました。
    使っていない2つは、コードから一切参照しません。
    マスタの仕様書にも「これは使っていない、正はこっち」と書いておきます。

    マスタから消すのが本当は一番いいのですが、
    それはマスタデータエディタ側の作業なので、今回は仕様書に残すだけにしています。

    強敵の報酬

    強敵に勝つと、ゴールドと素材が1.6倍になります。EXPはそのまま。

    1-5 山賊頭ゴラ
    ゴールド  8 × 1.6 = 12.8 → 13
    素材      3 × 1.6 =  4.8 →  5

    強敵かどうかは、バトルが始まるときに分かります。

    画像
    1-3で「強敵出現!! 報酬アップ」

    ここも整数で計算しています。
    バトルのように答え合わせをする相手はいないのですが、
    お金の計算で浮動小数を使う理由もないので。

    前回、強敵の倍率はクライアントに配信しないことにしました。
    なので結果の画面にも「×1.6」とは出さず、
    「強敵ボーナス込み」とだけ出して、入った数字を見せています。

    2回はもらえない

    前回、バトルの終了はRedisの `GETDEL` で1回だけ、と決めました。

    「2回記録されるより、記録されないほうに倒す。次回、ここに報酬が乗ってくるので」
    と書いたのが、今回です。

    同じバトルの終了を2回送っても、2回目はもうバトルがありません。
    報酬が2回入ることは、仕組みとして起きない。

    その代わり、取り出した後でDBが失敗すると、報酬は入らないまま終わります。
    ここは、もらえるはずのものがもらえない側に倒しています。

    実際の運用だと、ここで問い合わせが来ます。
    ログに `battle_id` が残っていれば、補填するかどうかを判断できる。
    2回入ってしまったものを後から回収するより、ずっと話が簡単です。

    ついでに直したこと

    前回のスクショで気づいた不具合です。

    クエスト画面の左には、デッキの先頭のヒーローが立ちます。
    ところが、編成を変えたあと、ホームを通らずにクエストへ行くと、古いデッキのままでした。

    クエスト画面は、ホームを開いたときに取った情報を見ていたんですよね。
    挑戦するときの「デッキが空なら編成へ」の判定も、同じ古い値を見ていました。

    サーバが `EMPTY_DECK` で弾くので、おかしなバトルが始まることはありません。
    ただ、デッキを組んだ直後に「先に編成をしてください」と止められるのは困る。

    なので、クエスト画面に入るときは、必ずホームの情報を取り直すようにしました。
    バトルから戻るときも同じ経路を通るので、HUDのゴールドやLvも、報酬が入った値になります。

    動かす

    1-1 を初めてクリアしたところです。

    画像
    獲得 1G +初回ボーナス 5G /素材1/EXP6、初クリア!

    もう一度 1-1 をクリアすると、初回ボーナスは付きません。
    そのかわりEXPが12になって、Lvが上がりました。

    画像
    Lv UP! Lv.2 スタミナ全回復

    こちらは強敵に勝ったときです。
    ゴールドと素材が1.6倍になっていて、EXPはそのままですね。

    画像
    1-2の強敵。2G +初回ボーナス 5G /素材2/EXP7

    クエスト画面に戻ると、HUDに反映されています。

    画像
    Lv.2、EXP 9/18、スタミナ 12/12

    ※ゴールドが多いのは、動作確認でガチャを回すために増やしているためです

    今回はここまで

    • 報酬の計算はサーバだけ。共有するのは両方で同じ計算が要るものだけ

    • 報酬・EXP・Lv・クリア記録を1つのトランザクションで

    • ロックの順番を1本にまとめた

    • 行が無いときのために、INSERT と UPDATE を1文で

    • Lvアップはループで、上限超えのスタミナは削らない

    • マスタに意味の重なる値があったので、正を決めて仕様書に残した

    • 報酬が2回入ることは、前回の `GETDEL` で起きない

    次回はショップと強化です。
    バトルで集めたゴールドと素材を、ここで使います。

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

    コード

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

    api-server/src/battle/rewards.ts

    import { master } from "../master/store.ts";
    import { configNumber } from "../master/config.ts";
    import { configValue } from "./master.ts";
    import { GAME_CONFIG_KEY } from "../constants.ts";
    import type { Stage } from "../master/types.ts";
    import { PERMYRIAD, roundDiv, toPermyriad } from "../../../shared/battle/fixed.ts";
    
    // クリア報酬の計算。DBは触らず、マスタと「強敵か」「初回か」だけから確定値を出す。
    //
    // shared/ には置かない。バトル本体と違ってクライアントが回し直す必要がなく、
    // サーバが1回計算して結果を返すだけだから。
    // 強敵の倍率も初回ボーナスの額も配信していないので、クライアントには計算できない。
    
    export type StageRewards = {
      /** 周回報酬。強敵なら倍率込み */
      gold: number;
      /** 強化素材。強敵なら倍率込み */
      materials: number;
      /** プレイヤーEXP。強敵でも変えない */
      exp: number;
      /** 初回クリアボーナス(ゴールド)。初回でなければ 0 */
      firstClearBonus: number;
    };
    
    /**
     * ステージ1回分の報酬。
     *
     * 倍率は万分率の整数で持ち、割り算は roundDiv だけを通す。
     * 浮動小数を経由させないのはバトルの計算と同じ理由(環境で最後の桁がずれる)
     */
    export function stageRewards(
      stage: Stage,
      { elite, firstClear }: { elite: boolean; firstClear: boolean },
    ): StageRewards {
      // 強敵でなければ等倍。1倍 = 10000 なので、同じ式のまま元の値に戻る
      const mul = elite ? toPermyriad(configValue(GAME_CONFIG_KEY.ELITE_REWARD_MUL)) : PERMYRIAD;
    
      return {
        gold: roundDiv(stage.reward_gold * mul, PERMYRIAD),
        materials: roundDiv(stage.reward_materials * mul, PERMYRIAD),
        // EXP は強敵でも増やさない。強敵はゴールドと素材だけが増える
        exp: stage.reward_exp,
        firstClearBonus: firstClear ? firstClearBonus(stage) : 0,
      };
    }
    
    /**
     * 初回クリアボーナス。ボスとそれ以外で額が違う。
     * 強敵の倍率は掛けない(初回に強敵が出たかどうかで額が変わらないようにする)
     */
    function firstClearBonus(stage: Stage): number {
      return configNumber(
        stage.is_boss !== 0
          ? GAME_CONFIG_KEY.FIRST_CLEAR_BONUS_BOSS
          : GAME_CONFIG_KEY.FIRST_CLEAR_BONUS_NORMAL,
      );
    }
    
    /** ステージ1行。無ければ例外(開始できている以上、終了時に消えていることはない) */
    export function requireStage(stageId: number): Stage {
      const stage = master.get_stage(stageId);
      if (stage === undefined) throw new Error(`stage に id=${stageId} が無い`);
      return stage;
    }

    api-server/src/user/level.ts

    import { master } from "../master/store.ts";
    import { INT_MAX } from "../constants.ts";
    import type { PlayerLevelCurve } from "../master/types.ts";
    
    // プレイヤーEXPとレベルアップ。DBは触らない。
    //
    // 必要EXPも最大Lvもマスタ(player_level_curve)が持っていて、
    // user_status には「今のLv」と「今のLvの中で貯まっている分」だけを置く。
    // 累計EXPを持たないので、マスタのカーブを直しても過去の値が化けない。
    
    export type LevelUpResult = {
      playerLv: number;
      /** 今のLvの中で貯まっている分。累計ではない */
      playerExp: number;
      /** 今回上がった段数。1回で2段以上上がることがある */
      levelUps: number;
    };
    
    // 最大Lvはマスタが変わらない限り同じ。呼ばれるたびに全行を走査しない
    let cachedMaxPlayerLv: number | null = null;
    
    /** player_level_curve に入っている最大の player_lv。ここに達したらもう上がらない */
    function maxPlayerLv(): number {
      if (cachedMaxPlayerLv === null) {
        const rows = master.get_table("player_level_curve") as readonly PlayerLevelCurve[];
        cachedMaxPlayerLv = rows.reduce((max, row) => Math.max(max, row.player_lv), 0);
      }
      return cachedMaxPlayerLv;
    }
    
    /** そのLvから次のLvまでに要るEXP。無ければ例外 */
    function needExpOf(playerLv: number): number {
      const curve = master.get_player_level_curve(playerLv);
      if (curve === undefined) {
        throw new Error(`player_level_curve に Lv${playerLv} が無い`);
      }
      return curve.need_exp;
    }
    
    /**
     * EXP を足して、上がるだけレベルを上げる。
     *
     * 必要EXPを差し引いて1段上げ、足りなくなるまで繰り返す。
     * 最大Lvに達したらそこで止め、EXP はそのLvの need_exp で頭打ちにする
     * (バーが満タンのまま止まって見えるだけで、あふれた分は捨てる)。
     *
     * @param playerLv 今のレベル
     * @param playerExp 今のレベルの中で貯まっているEXP
     * @param amount 足すEXP
     */
    export function gainPlayerExp(
      playerLv: number,
      playerExp: number,
      amount: number,
    ): LevelUpResult {
      const maxLv = maxPlayerLv();
    
      // 足す前に頭打ちにする。INT_MAX を超えた値を一度も作らないため
      let exp = Math.min(playerExp, INT_MAX - amount) + amount;
      let lv = playerLv;
      let levelUps = 0;
    
      while (lv < maxLv) {
        const need = needExpOf(lv);
        if (exp < need) break;
        exp -= need;
        lv += 1;
        levelUps += 1;
      }
    
      // 最大Lvでは差し引く先が無いので、貯まる上限をそのLvの need_exp にする
      if (lv >= maxLv) exp = Math.min(exp, needExpOf(lv));
    
      return { playerLv: lv, playerExp: exp, levelUps };
    }

    api-server/src/routes/battle.ts(勝ったときの記録と報酬の部分)

    /**
     * クリアを記録して報酬を渡す。全部で1トランザクション。
     *
     * 行ロックの順番は user_status → user_stage → user_currency → user_item で固定する
     * (全体の順は db.ts のコメントを参照)。
     *
     * GETDEL の後にここで落ちたら、報酬もクリアも入らない。
     * 2回入るより入らないほうに倒す、という決め方は開始時と同じ
     */
    async function grantVictory(
      conn: PoolConnection,
      userId: number,
      session: BattleSession,
      now: Date,
    ): Promise<Victory> {
      const stage = requireStage(session.stage_id);
    
      const status = await selectStatusForUpdate(conn, userId);
      // セッションは生きているのに user_status がいない。通常は起きない
      if (status === null) throw new Error(`user_status に user_id=${userId} が無い`);
    
      const firstClear = await insertStageClear(conn, userId, stage.id, now);
    
      // 強敵かどうかは開始時に決まっている。クライアントからは受け取らない
      const rewards = stageRewards(stage, { elite: session.elite, firstClear });
    
      // 初回ボーナスもゴールド。同じ通貨なので1文にまとめて足す
      await addCurrency(conn, userId, CURRENCY_ID.GOLD, rewards.gold + rewards.firstClearBonus);
      await addItem(conn, userId, ITEM_ID.MATERIAL, rewards.materials);
    
      const level = gainPlayerExp(status.playerLv, status.playerExp, rewards.exp);
      await updateLevel(conn, userId, status, level, now);
    
      return { firstClear, rewards, level };
    }
    
    /**
     * クリアの行を作る。初回なら true。
     * 既に行があれば何もしない(cleared_at も動かさない)
     */
    async function insertStageClear(
      conn: PoolConnection,
      userId: number,
      stageId: number,
      now: Date,
    ): Promise<boolean> {
      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;
    }
    
    /**
     * 通貨を足す。行が無ければ作る(持っていない種別の行は作らない方針なので、無いことがある)。
     *
     * 「読んで、有無で分岐して、書く」ではなく INSERT ... ON DUPLICATE KEY UPDATE の1文にする。
     * VALUES() は 8.0.20 で非推奨になり警告が出るので、行エイリアス(AS `new`)で書く。
     * 上限は INT_MAX。所持上限のルールはまだ無いので、桁があふれないようにするだけ
     */
    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],
      );
    }
    
    /** アイテムを足す。形も理由も addCurrency と同じ */
    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],
      );
    }
    
    /**
     * レベルとEXPを書く。レベルが1段でも上がったらスタミナも一緒に書く。
     *
     * スタミナは「時間回復を済ませてから、上がった後の上限まで引き上げる」。
     * max を取るのは、上限を超えて持っている分を全回復で削らないため
     * (回復アイテムなどで上限超えを持てる。user_status.stamina のコメントどおり)。
     * レベルが上がらなければスタミナは触らない(起点も進めない)
     */
    async function updateLevel(
      conn: PoolConnection,
      userId: number,
      status: UserStatus,
      level: LevelUpResult,
      now: Date,
    ): Promise<void> {
      if (level.levelUps === 0) {
        await conn.execute(
          "UPDATE `user_status` SET `player_lv` = ?, `player_exp` = ? WHERE `user_id` = ?",
          [level.playerLv, level.playerExp, userId],
        );
        return;
      }
    
      const recovered = recoverStamina(
        status.stamina,
        status.staminaUpdatedAt,
        staminaMaxOf(status.playerLv),
        now,
      );
      const stamina = Math.max(recovered.stamina, staminaMaxOf(level.playerLv));
    
      await conn.execute(
        "UPDATE `user_status` SET `player_lv` = ?, `player_exp` = ?," +
          " `stamina` = ?, `stamina_updated_at` = ? WHERE `user_id` = ?",
        [level.playerLv, level.playerExp, stamina, now, userId],
      );
    }

    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 BattleRewards {
      /** 強敵だったか。gold と materials は倍率が掛かった後の値 */
      elite: boolean;
      gold: number;
      materials: number;
      exp: number;
      /** 初回クリアボーナス(ゴールド)。初回でなければ 0 */
      first_clear_bonus: number;
    }
    
    /** 報酬を受け取った後のプレイヤーレベル */
    export interface BattleLevel {
      player_lv: number;
      /** 今回上がった段数。0 なら上がっていない */
      level_ups: number;
    }
    
    export interface BattleFinishResponse {
      win: boolean;
      turns: number;
      first_clear: boolean;
      /** 負けたときは null */
      rewards: BattleRewards | null;
      /** 負けたときは null */
      level: BattleLevel | null;
    }
    
    /** クライアントで出た結果。判定には使われず、食い違いの検知にだけ使われる */
    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,
      );
    }

    game-client/src/App.tsx(クエストへ行く部分)

      /**
       * クエストへ。ホームを取り直してから表示する。
       *
       * クエスト画面は左の3Dと「デッキが空か」の判定に home.lead_hero を見ている。
       * この値はホームを開いたときのものなので、編成を変えた後にホームを通らずに来ると古いままになる。
       * バトルの後もここを通るので、HUD のゴールド・素材・EXP・Lv・スタミナもここで揃う
       */
      const goQuest = useCallback(
        (session: Session) => {
          setPhase({ kind: 'loading' });
          fetchHome(session.token).then(
            (home) => setPhase({ kind: 'quest', session: { ...session, home } }),
            fail,
          );
        },
        [fail],
      );
     
     
    泥臭い現場のリアルを語る現役エンジニア ゲーム開発歴30年。会社員・フリーランスの両方で修羅場をくぐり抜けてきた50代現役サーバプログラマです

    あなたへのおすすめ