やはり俺のターンがまわってこないのはまちがっている。#7|Nakamaの権威マッチで対戦の部屋を作る:TypeScriptのサーバーコードとRPC

4つの窓を2行2列に並べたところ(初めての再生)。4人の Game ビューの右上に「部屋「room1」(4人) スライム フェアリー メデューサ キョンシー」。左上は前回のチームの一覧。4つの部屋の一覧を赤枠で囲んだもの
今回のゴール:4人が同じ部屋に入り、全員の画面に4人の名前が出る

前回までで、4人がログインして、チームに分かれて、誰がオンラインかも分かるようになりました。いよいよ対戦の準備です。今回は、Nakamaのサーバーで動くコードをTypeScriptで書いて、対戦の部屋(権威マッチ)を作ります。4人が同じ部屋に入って、部屋にいる人の名前が全員の画面に出るところまでやりたいと思います。

目次

今回やること

4人が同じ部屋に入り、部屋にいる人が全員の画面に出る。左に4人(スライム・フェアリー・キョンシー・メデューサ)。右の Nakama の枠の中に、①RPC「join_room」(部屋のマッチIDを返す(無ければ作る))とその下の Storage「rooms」(room1 → マッチID(1つだけ))、マッチIDの矢印の先に部屋(権威マッチ、turn_match)。部屋の中に「②マッチIDで入る(JoinMatchAsync)」「③入った・抜けたら、部屋にいる人の一覧を全員に送る(opcode 1)」
RPC で部屋の番号をもらって、その部屋に入る
  • サーバーのコードを書く準備をする(TypeScript・tsconfig・Dockerfile)
  • 部屋(マッチのハンドラー)を書く。入った人・抜けた人の一覧を、サーバーから全員に送る
  • 部屋に入るためのRPCを書く。4人が同時に頼んでも、部屋は1つにする
  • Unityで、RPCで部屋の番号をもらって入り、部屋にいる人を画面に出す

Unityのプロジェクトは前回のClientをそのまま使います。サーバーは、今回からServerフォルダにコードが増え、docker compose up -d --buildで起動するようになります。

サーバーのコードを書く準備をしよう

TypeScriptで書いて、ES5のJavaScriptにする

サーバーのコードを、Nakama のイメージに入れる(Dockerfile の2段)。左の1段目(node:22-alpine):src/main.ts(TypeScript)→ npx tsc → build/index.js(ES5 の JavaScript)、tsconfig.json:target es5・outFile、TypeScript は 5.9.3 に固定(6 は ES5 が非推奨、7 では使えない)。右の2段目(heroiclabs/nakama:3.42.0):/nakama/data/modules/build/index.js(1段目からコピー)と /nakama/data/local.yml(runtime.js_entrypoint: build/index.js)。下に「docker compose up -d --build で、作り直して起動(Node は自分の PC に入れなくてよい)」
TypeScript を JavaScript にして、Nakama に入れる

ここまでは、Nakamaに最初からある機能(ログイン・グループ・ステータス)だけを使ってきました。対戦の部屋のように、ゲームごとに決まりが違うものは、サーバーで動くコードを自分で書きます。Nakamaのサーバーのコードは、Go・Lua・TypeScriptで書けます。このシリーズは、C#に近くて読みやすいTypeScriptにしました。

NakamaはTypeScriptのコードをそのまま動かすのではなく、JavaScriptにしたものを読み込みます。気をつけることが3つあります。

  • ES5のJavaScriptにする:Nakamaの中のJavaScriptのエンジン(goja)は、古い形のES5で動く
  • Nodeの機能(fsなど)やnpmのパッケージは使えない。使えるのは、Nakamaが用意しているnkの関数だけ
  • グローバル変数に状態を持てない:コードは何台ものエンジンで使い回されるので、部屋の状態などは、あとで出てくるマッチのstateか、Storageに置く

公式のドキュメントはTypeScript Runtime(Heroic Labs)です。

package.jsonとtsconfig.json

Serverフォルダにpackage.jsonを作って、TypeScriptと、Nakamaの型の定義(nakama-runtime)を入れます。

{
  "name": "unity-online-turn-server",
  "private": true,
  "scripts": {
    "build": "tsc"
  },
  "devDependencies": {
    "nakama-runtime": "github:heroiclabs/nakama-common#v1.49.0",
    "typescript": "5.9.3"
  }
}

ファイルを書いたら、Serverフォルダでnpm installして、package-lock.json(入れたもののバージョンの控え)を作ります。nakama-testのUbuntuにはNodeを入れていないので、DockerのNodeで動かしました。

docker run --rm -u $(id -u):$(id -g) -e HOME=/tmp -v "$PWD":/backend -w /backend node:22 npm install
  • node:22:Nodeの入ったイメージ。nakama-runtimeはGitHubから取ってくるのでgitが要る。gitの入っていないnode:22-alpineでは「spawn git」のエラーになった
  • -u $(id -u):$(id -g):出来たファイルを自分のものにする(付けないとrootのファイルになる)
  • nakama-runtime:Nakamaのnkやnkruntimeの型。サーバーのバージョンに合わせる。Nakama v3.42.0はnakama-common v1.49.0を使っているので、#v1.49.0を付けた
  • typescript:5.9.3に固定する(下の注意)

TypeScriptは、5.9.3のようにバージョンを固定します。今の最新のTypeScript 7でビルドすると「Option ‘target=ES5’ has been removed.」「Option ‘outFile’ has been removed.」のエラーで止まりました。TypeScript 6でも、ES5とoutFileは「非推奨」のエラーになります。

tsconfig.jsonは、公式のドキュメントの形のままです。

{
  "compilerOptions": {
    "target": "es5",
    "strict": true,
    "skipLibCheck": true,
    "outFile": "./build/index.js",
    "typeRoots": [
      "./node_modules"
    ]
  },
  "files": [
    "./src/main.ts"
  ]
}
  • target:ES5にする
  • outFile:1つのファイル(build/index.js)にまとめる
  • typeRoots:node_modulesのnakama-runtimeの型を読む

Dockerfileとlocal.yml

ビルドはDockerの中でやります。ServerフォルダにDockerfileを作ります。

# 1段目:Node で TypeScript を JavaScript(ES5)にする
FROM node:22-alpine AS node-builder
WORKDIR /backend
COPY package*.json ./
RUN npm ci
COPY tsconfig.json ./
COPY src/*.ts src/
RUN npx tsc

# 2段目:Nakama に、できた JavaScript と設定を入れる
FROM heroiclabs/nakama:3.42.0
COPY --from=node-builder /backend/build/*.js /nakama/data/modules/build/
COPY local.yml /nakama/data/

1段目でビルドして、出来たindex.jsだけを2段目のNakamaにコピーします(マルチステージビルド)。Nodeは1段目の中にあるので、自分のパソコンにNodeが無くてもビルドできます。npm ciはpackage-lock.jsonのとおりに入れるので、gitの無いnode:22-alpineでも動きました。

Nakamaの設定はlocal.ymlに書きます。

# ローカル専用の設定
logger:
  level: "DEBUG"
runtime:
  js_entrypoint: "build/index.js"

js_entrypointで、読み込むJavaScriptを指定します。ログの細かさ(DEBUG)も、#2ではコマンドラインに書いていましたが、ここへ移しました。

.dockerignoreには、node_modules/とbuild/を書いておきます(自分のパソコンのものをDockerにコピーしないため)。

docker-compose.ymlは、nakamaの2か所だけ直します。

  nakama:
    # Dockerfile で、サーバーのコードを入れた Nakama を作る
    build: .
    entrypoint:
      - "/bin/sh"
      - "-ecx"
      - >
        /nakama/nakama migrate up --database.address postgres:localdb@postgres:5432/nakama &&
        exec /nakama/nakama --name nakama1 --config /nakama/data/local.yml --database.address postgres:localdb@postgres:5432/nakama
  • image: heroiclabs/nakama:3.42.0をbuild: .にする(Dockerfileから作る)
  • 起動のコマンドの--logger.level DEBUGを、--config /nakama/data/local.ymlにする

部屋(マッチ)のコードを書こう

Server/src/main.tsに、部屋のコードを全部書きます。少し長いので、あとで分けて説明します。

// 対戦の部屋(Nakama の権威マッチ)と、部屋に入るための RPC

const MatchModuleName = "turn_match";
const JoinRoomRpcId = "join_room";

// 1秒に1回 matchLoop を呼ぶ(ターン制なので、これで足りる)
const TickRate = 1;
// 1つの部屋に入れる人数
const MaxPlayers = 8;
// 誰もいなくなってから、部屋を閉じるまでの秒数
const EmptyTimeoutSeconds = 60;

// サーバーから全員へ送るメッセージの種類:状態の全体
const OpCodeSnapshot = 1;

// 部屋の名前ごとに、マッチIDを1つだけ置いておく Storage(サーバーのもの)
const RoomCollection = "rooms";
const SystemUserId = "00000000-0000-0000-0000-000000000000";

interface Player {
    userId: string;
    name: string;
}

interface RoomState {
    room: string;
    // 部屋にいる人(入った順。オブジェクトのキーの順番は保たれないので、配列にする)
    players: Player[];
    // 誰もいない tick が続いた数
    emptyTicks: number;
}

function InitModule(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, initializer: nkruntime.Initializer) {
    // InitModule で例外が出るとサーバーが止まるので、登録は try/catch で囲む
    try {
        initializer.registerMatch<RoomState>(MatchModuleName, {
            matchInit: matchInit,
            matchJoinAttempt: matchJoinAttempt,
            matchJoin: matchJoin,
            matchLeave: matchLeave,
            matchLoop: matchLoop,
            matchTerminate: matchTerminate,
            matchSignal: matchSignal,
        });
        initializer.registerRpc(JoinRoomRpcId, rpcJoinRoom);
    } catch (error) {
        logger.error("登録できませんでした:%s", (error as Error).message);
    }
    logger.info("対戦の部屋のモジュールを読み込みました");
}

// ---- 部屋に入るための RPC ----

// { "room": "room1" } を受け取り、{ "matchId": "…" } を返す
function rpcJoinRoom(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, payload: string): string {
    const request = JSON.parse(payload);
    const room: string = request.room;
    const matchId = findOrCreateRoom(logger, nk, room);
    return JSON.stringify({ matchId: matchId });
}

// 部屋の名前のマッチがあればそのID、無ければ作ってそのIDを返す
function findOrCreateRoom(logger: nkruntime.Logger, nk: nkruntime.Nakama, room: string): string {
    const objects = nk.storageRead([{ collection: RoomCollection, key: room, userId: SystemUserId }]);
    // "*":まだ無いときだけ書ける
    let version = "*";
    if (objects.length > 0) {
        const savedMatchId: string = objects[0].value.matchId;
        // 部屋がまだ開いていれば、そこに入る
        if (nk.matchGet(savedMatchId) != null) {
            return savedMatchId;
        }
        // 閉じていれば作り直す。読んだときのバージョンのままなら書き換えられる
        version = objects[0].version;
    }

    const newMatchId = nk.matchCreate(MatchModuleName, { room: room });
    try {
        nk.storageWrite([{
            collection: RoomCollection,
            key: room,
            userId: SystemUserId,
            value: { matchId: newMatchId },
            version: version,
            permissionRead: 0,
            permissionWrite: 0,
        }]);
        logger.info("部屋「%s」を作りました:%s", room, newMatchId);
        return newMatchId;
    } catch (error) {
        // ほかの人が同時に作って、先に書いた。そちらの部屋に入る(作った部屋は誰も入らないので、そのうち閉じる)
        logger.info("部屋「%s」は先に作られていました", room);
        const latest = nk.storageRead([{ collection: RoomCollection, key: room, userId: SystemUserId }]);
        return latest[0].value.matchId;
    }
}

// ---- マッチのハンドラー ----

// 部屋を作ったときに1回:最初の状態・tick rate・ラベル
function matchInit(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, params: { [key: string]: any }): { state: RoomState, tickRate: number, label: string } {
    const state: RoomState = { room: params.room, players: [], emptyTicks: 0 };
    return { state: state, tickRate: TickRate, label: makeLabel(state) };
}

// 入ろうとした人を、入れるかどうか決める
function matchJoinAttempt(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, presence: nkruntime.Presence, metadata: { [key: string]: any }): { state: RoomState, accept: boolean, rejectMessage?: string } | null {
    if (countPlayers(state) >= MaxPlayers) {
        return { state: state, accept: false, rejectMessage: "部屋がいっぱいです" };
    }
    return { state: state, accept: true };
}

// 入った人を覚えて、部屋にいる人の一覧を全員に送る
function matchJoin(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, presences: nkruntime.Presence[]): { state: RoomState } | null {
    // 表示名は presence に無いので、ユーザーの情報をもらう
    const users = nk.usersGetId(presences.map(presence => presence.userId));
    for (const user of users) {
        // 同じ人が入り直したときは、前の分を外してから足す
        state.players = state.players.filter(player => player.userId != user.userId);
        state.players.push({ userId: user.userId, name: user.displayName || user.username });
        logger.info("部屋「%s」に%sが入りました", state.room, user.displayName);
    }
    sendPlayers(dispatcher, state);
    return { state: state };
}

// 抜けた人を外して、一覧を全員に送る
function matchLeave(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, presences: nkruntime.Presence[]): { state: RoomState } | null {
    for (const presence of presences) {
        const leavingPlayers = state.players.filter(player => player.userId == presence.userId);
        if (leavingPlayers.length > 0) {
            logger.info("部屋「%s」から%sが抜けました", state.room, leavingPlayers[0].name);
        }
        state.players = state.players.filter(player => player.userId != presence.userId);
    }
    sendPlayers(dispatcher, state);
    return { state: state };
}

// tick ごと(1秒に1回)。null を返すと部屋が閉じる
function matchLoop(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, messages: nkruntime.MatchMessage[]): { state: RoomState } | null {
    if (countPlayers(state) > 0) {
        state.emptyTicks = 0;
        return { state: state };
    }
    state.emptyTicks++;
    if (state.emptyTicks >= EmptyTimeoutSeconds * TickRate) {
        logger.info("部屋「%s」に誰もいないので閉じます", state.room);
        return null;
    }
    return { state: state };
}

// サーバーが止まるときなど
function matchTerminate(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, graceSeconds: number): { state: RoomState } | null {
    return { state: state };
}

// サーバーのほかのコードからの合図(このシリーズでは使わない)
function matchSignal(ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, tick: number, state: RoomState, data: string): { state: RoomState, data?: string } | null {
    return { state: state };
}

// ---- 小さな関数 ----

function countPlayers(state: RoomState): number {
    return state.players.length;
}

// ラベル:マッチの一覧や Console で見える、部屋の名前と人数
function makeLabel(state: RoomState): string {
    return JSON.stringify({ room: state.room, players: countPlayers(state) });
}

// 部屋にいる人の一覧(状態の全体)を全員に送り、ラベルの人数も直す
function sendPlayers(dispatcher: nkruntime.MatchDispatcher, state: RoomState) {
    dispatcher.broadcastMessage(OpCodeSnapshot, JSON.stringify({ players: state.players }));
    dispatcher.matchLabelUpdate(makeLabel(state));
}

マッチのハンドラーの7つの関数

マッチのハンドラーの7つの関数(いつ呼ばれる?)。上の段に矢印でつないで、matchInit(部屋を作ったとき1回、最初の状態・tick rate・ラベル)→ matchJoinAttempt(入ろうとしたとき、入れる(accept)か断るか)→ matchJoin(入ったとき、一覧に足して、全員に送る)→ matchLoop(1秒に1回(tick)、誰もいない60秒で null → 閉じる)→ matchLeave(抜けたとき、一覧から外して、全員に送る)。下の段に matchTerminate(サーバーが止まるときなど)と matchSignal(サーバーのほかのコードからの合図)。下に「7つとも書かないと登録できない。使わない関数も、state をそのまま返す」
部屋の一生で、7つの関数が呼ばれる

Nakamaの部屋は「マッチ」と呼びます。マッチには2種類あります。

  • リレーのマッチ:クライアントが送ったものを、サーバーはそのまま配るだけ
  • 権威マッチ:サーバーのコードが部屋の決まりを持つ。ターン・サイコロ・盤面をサーバーが決めるので、ズルが出来ない

このシリーズは、順番もサイコロもサーバーが決めたいので、権威マッチにします。権威マッチは、7つの関数(マッチのハンドラー)をregisterMatchで登録して作ります。公式の説明はAuthoritative Multiplayer(Heroic Labs)です。

  • matchInit:部屋を作ったときに1回。最初のstate、1秒に何回matchLoopを呼ぶか(tick rate)、ラベルを返す
  • matchJoinAttempt:入ろうとした人を入れるかどうか。8人より多ければ断る
  • matchJoin・matchLeave:入った人・抜けた人。一覧を直して、全員に送る
  • matchLoop:tickごとに呼ばれる。nullを返すと部屋が閉じる。誰もいない時間が60秒続いたら閉じる
  • matchTerminate・matchSignal:今回は使わないので、stateをそのまま返すだけ

ターン制なので、tick rateは1(1秒に1回)で足ります。リアルタイムのアクションなら、もっと多くします。

登録する関数は、function matchInit(…) { … }のように、ファイルのいちばん外側にfunctionで書きます。変数に入れた関数(const matchInit = function …)は登録できない、と公式のドキュメントに書かれています。

部屋にいる人は、配列で持つ

配列にする前のメデューサ(Player 4)の画面。Game の右上の部屋の一覧が「フェアリー スライム メデューサ キョンシー」の順。Console に「部屋にいる人(2人):スライム、メデューサ」「部屋にいる人(3人):スライム、メデューサ、キョンシー」「部屋にいる人(4人):フェアリー、スライム、メデューサ、キョンシー」。部屋の一覧と3行のログを赤枠で囲んだもの
オブジェクトで持っていたときは、最後に入ったフェアリーが先頭に来た

部屋の状態(RoomState)は、部屋の名前・部屋にいる人(players)・誰もいない時間(emptyTicks)です。どの関数も、受け取ったstateを直して、return { state: state }で返します。

playersは配列にしました。初めはユーザーIDをキーにしたオブジェクトにしていたのですが、そうすると、入った順に並びませんでした(最後に入ったフェアリーが先頭に来ていた)。stateは呼ぶたびにNakamaの中(Goの言葉)を通るので、オブジェクトのキーの順番は保たれないようです。順番が大事なものは配列で持ちます。次回、チームの順番をまわすときにも大事になります。

入った人の一覧を全員に送る

matchJoinとmatchLeaveの最後にsendPlayersを呼んで、部屋にいる人の一覧を全員に送ります。

dispatcher.broadcastMessage(OpCodeSnapshot, JSON.stringify({ players: state.players }));
  • broadcastMessage:部屋の全員にメッセージを送る。1つ目の数字(opcode)で、メッセージの種類を分ける
  • opcodeの1は、シリーズの最初に決めた「状態の全体(スナップショット)」。今は部屋にいる人だけですが、次回から盤面やターンも入れていきます
  • 名前は、ユーザーの表示名(displayName)。presence(入った人の情報)には表示名が無いので、nk.usersGetIdでもらっています

ラベル

makeLabelで作るラベルは、部屋の名前と人数のJSONです。matchInitで最初のラベルを返し、人が入ったり抜けたりしたらmatchLabelUpdateで直します。ラベルはNakamaのConsoleで見られて、部屋の一覧で探すときにも使えます(部屋の一覧を出すのは、このシリーズの後半で)。

部屋に入るRPCを書こう

RPCは、サーバーの関数を呼ぶ仕組み

RPCは、Unityからサーバーの関数を名前で呼ぶ仕組みです。registerRpcでjoin_roomという名前で登録したrpcJoinRoomは、{"room":"room1"}を受け取って、その部屋のマッチID({"matchId":"…"})を返します。部屋が無ければ作ります。

部屋の番号は、Storageに1つだけ置く

4人が同時に「部屋は?」と聞いても、部屋は1つになる。4人それぞれが「部屋が無いので作る」(マッチ A・B・C・D)。スライムだけ「Storage に書けた(version "*":まだ無いときだけ)」、フェアリー・キョンシー・メデューサは「書けない(もうある)、読み直して、マッチ A を返す」。右に「4人とも マッチ A に入る。B・C・D は誰も入らず、60秒で閉じる」。下に「#5 のチームと同じ「先に作ってみて、だめなら今あるものに入る」」
Storage に書けるのは1人だけ

部屋の名前(room1)とマッチIDの組は、Storage(サーバーの小さな保存場所)のroomsに置きます。

  1. Storageを読む。マッチIDがあって、その部屋がまだ開いていれば(nk.matchGetがnullでなければ)、そのIDを返す
  2. 無ければ、nk.matchCreateで部屋を作る
  3. 作ったマッチIDを、Storageに書く

心配なのは、4人がほぼ同時に頼んだときです。4人とも「まだ無い」と読んで、4つの部屋を作ってしまいます。そこで、Storageに書くときにversion: "*"を付けます。"*"は「まだ無いときだけ書ける」という意味で、4人のうち書けるのは1人だけになります。書けなかった人は、Storageを読み直して、先に書いた人の部屋のIDを返します。

試しに、curlで4人分のRPCを同時に呼んでみました。サーバーのログは、1回が「作りました」、3回が「先に作られていました」になり、4回とも同じマッチIDが返ってきました。

部屋「racetest」を作りました:1de068e6-c358-4e11-8200-58396bd16fca.nakama1
部屋「racetest」は先に作られていました
部屋「racetest」は先に作られていました
部屋「racetest」は先に作られていました
スライム

使われなかった3つの部屋は、どうなるの?

フェアリー

誰も入らないから、matchLoopが60秒で閉じてくれるわ。#5のチームと同じで、先に作ってみて、だめなら今あるほうに入るのよ

  • userIdの00000000-0000-0000-0000-000000000000は、特定のユーザーのものではない「サーバーのもの」の印
  • permissionRead: 0・permissionWrite: 0で、Unityからは読めも書けもしない(サーバーのコードだけが使う)

閉じた部屋は、作り直す

部屋は、誰もいなくなってから60秒で閉じます。Nakamaを再起動したときも、部屋(マッチ)はサーバーのメモリにあるだけなので消えます。でも、Storageには古いマッチIDが残っています。

そのときはnk.matchGetがnullを返すので、作り直します。Storageを書き換えるときは、読んだときのversionを付けます。読んでから書くまでのあいだに、ほかの人が先に書き換えていたら書けないので、ここでも部屋は1つになります。

サーバーを作り直して起動しよう

nakama-testのUbuntuで、Serverフォルダに移って、作り直して起動します。

docker compose up -d --build
docker compose logs nakama | grep -E "JavaScript|部屋"

ログに、こう出れば読み込めています。

"msg":"Initialising JavaScript runtime provider","path":"/nakama/data/modules","entrypoint":"build/index.js"
"msg":"対戦の部屋のモジュールを読み込みました"
"msg":"JavaScript runtime modules loaded"
Nakama の Console の Runtime Modules。JavaScript Modules に「/nakama/data/modules/build/index.js」、Registered RPC Functions の JavaScript RPC Functions に「join_room」。この2行を赤枠で囲んだもの
Console の Runtime Modules に、index.js と join_room が出る

NakamaのConsole(http://localhost:7351)のRuntime Modulesでも、読み込んだindex.jsと、登録したRPCのjoin_roomが見られます。

コードを直したら
  • main.tsを直したら、もう一度docker compose up -d --buildする(ビルドからやり直して、Nakamaを入れ替える)
  • InitModuleで例外が出ると、Nakamaが起動しない。登録をtry/catchで囲んでおくと、ログにエラーが出てNakamaは動き続ける
  • 書き間違いは、npx tscのところで止まるので、docker compose upのログで分かる

Unityで部屋に入ろう

JSONの形を決める

サーバーとやり取りするJSONを、C#のクラスにします。Assets/ScriptsにRoomMessages.csを作ります。

using System;

// サーバーとやり取りする JSON の形(JsonUtility で読み書きするので、名前はサーバーの JSON と同じにする)

// RPC「join_room」に送る
[Serializable]
public class JoinRoomRequest
{
    public string room;
}

// RPC「join_room」から返ってくる
[Serializable]
public class JoinRoomResponse
{
    public string matchId;
}

// 部屋にいる1人
[Serializable]
public class RoomPlayer
{
    public string userId;
    public string name;
}

// サーバーから届く、状態の全体(opcode 1)
[Serializable]
public class RoomSnapshot
{
    public RoomPlayer[] players;
}

JsonUtilityで読み書きするので、フィールドの名前をサーバーのJSONのキーと同じ(room・matchId・players・userId・name)にしています。JsonUtilityの使い方は、12-6 データを保存しよう:PlayerPrefsとJSONで紹介しています。

部屋の一覧を出すRoomView

Hierarchy。Canvas の下に TeamView と RoomView。RoomView を赤枠で囲んだもの
Canvas の下に RoomView

前回のTeamViewと同じように、Hierarchyの「+」>UI (Canvas)>Text – TextMeshProでテキストを作り、名前をRoomViewにします。今度は画面の右上に置きます。

RoomView の Inspector の Rect Transform。アンカーは右上(right・top)、Pos X -60・Pos Y -60、Width 600・Height 400、Pivot X 1・Y 1。アンカーの絵と Pos X・Pos Y、Pivot を赤枠で囲んだもの
アンカーと Pivot を右上に
  • Rect Transform:アンカーを右上(top・right)、Pivot X 1・Y 1、Pos X -60・Pos Y -60、Width 600・Height 400
  • TextMeshPro:Font Size 48、Alignment は右上
using System.Text;
using TMPro;
using UnityEngine;

// 部屋にいる人の一覧を画面に出す
public class RoomView : MonoBehaviour
{
    [SerializeField] private TMP_Text playersText;

    public void Show(string roomName, RoomPlayer[] players)
    {
        StringBuilder builder = new StringBuilder();
        builder.AppendLine($"部屋「{roomName}」({players.Length}人)");
        foreach (RoomPlayer player in players)
        {
            builder.AppendLine(player.name);
        }
        playersText.text = builder.ToString();
    }
}
RoomView の Inspector。Rect Transform・Canvas Renderer・TextMeshPro - Text (UI) はたたんであり、Room View (Script) の Players Text に「RoomView (Text Mesh Pro UGUI)」。Players Text を赤枠で囲んだもの
Players Text に、同じゲームオブジェクトのテキストを入れる

RoomView.csを作ってRoomViewに付け、Players Textに同じゲームオブジェクトのTextMeshProを入れます。

部屋に入るRoomManager

Assets/ScriptsにRoomManager.csを作ります。

using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Nakama;
using UnityEngine;

// 対戦の部屋(Nakama のマッチ)に入って、部屋にいる人を画面に出す
public class RoomManager : MonoBehaviour
{
    // サーバーの RPC の名前
    private const string JoinRoomRpcId = "join_room";
    // サーバーから届くメッセージの種類:状態の全体
    private const long SnapshotOpCode = 1;

    [SerializeField] private RoomView roomView;

    private ISocket socket;
    private string roomName;
    private string matchId;

    public async Task EnterAsync(ISocket nakamaSocket, string enteringRoomName)
    {
        socket = nakamaSocket;
        roomName = enteringRoomName;

        // サーバーの RPC で、部屋のマッチIDをもらう(無ければサーバーが作る)
        JoinRoomRequest request = new JoinRoomRequest { room = roomName };
        IApiRpc rpc = await socket.RpcAsync(JoinRoomRpcId, JsonUtility.ToJson(request));
        JoinRoomResponse response = JsonUtility.FromJson<JoinRoomResponse>(rpc.Payload);
        matchId = response.matchId;

        // 入った直後に届く一覧を見のがさないように、先に受け取れるようにしておく
        socket.ReceivedMatchState += OnMatchState;
        IMatch match = await socket.JoinMatchAsync(matchId);
        Debug.Log($"部屋「{roomName}」に入りました:{match.Id}");
    }

    // サーバーからメッセージが届いた
    private void OnMatchState(IMatchState matchState)
    {
        if (matchState.MatchId != matchId || matchState.OpCode != SnapshotOpCode)
        {
            return;
        }
        string json = Encoding.UTF8.GetString(matchState.State);
        RoomSnapshot snapshot = JsonUtility.FromJson<RoomSnapshot>(json);
        roomView.Show(roomName, snapshot.players);
        string[] names = snapshot.players.Select(player => player.name).ToArray();
        Debug.Log($"部屋にいる人({names.Length}人):{string.Join("、", names)}");
    }
}
  • socket.RpcAsync:サーバーのRPCを名前で呼ぶ。送るのも返ってくるのも文字列(JSON)
  • socket.JoinMatchAsync:マッチIDの部屋に入る
  • ReceivedMatchState:部屋からメッセージが届くと呼ばれる。自分の部屋の、opcodeが1のものだけを見る
  • 届いた中身(State)はバイト列なので、Encoding.UTF8.GetStringで文字列にしてからJsonUtility.FromJsonで読む

先に受け取る準備をしてから入る

先に受け取る準備をしてから、部屋に入る。メデューサと Nakama の縦の線。メデューサから Nakama へ「JoinMatchAsync(入りたい)」、Nakama からメデューサへ「matchJoin → 部屋にいる人(4人)」、そのあとに「入れました(JoinMatchAsync の返事)」。右の囲みに「一覧が、返事より先に届いた。await のあとで ReceivedMatchState に登録すると、この一覧を見のがす → 登録してから JoinMatchAsync」
入った返事より先に、一覧が届くことがある
socket.ReceivedMatchState += OnMatchState;
IMatch match = await socket.JoinMatchAsync(matchId);

ReceivedMatchStateの登録は、JoinMatchAsyncより前にしています。サーバーはmatchJoinの中で一覧を送るので、入った返事より先に、一覧が届くことがあります(あとの「4人で確かめよう」で、本当にそうなりました)。awaitのあとで登録すると、その一覧を見のがして、画面が空のままになります。前回の「チャンネルに入ってから一覧をもらう」と同じ考え方です。

マッチIDはRPCで先にもらっているので、OnMatchStateの中で自分の部屋のメッセージかどうかを見分けられます。

NakamaConnectionとInspector

NakamaConnection.csには、Room Managerと部屋の名前を足して、Startのチームに入ったあとで部屋に入ります。

[SerializeField] private TeamManager teamManager;
[SerializeField] private RoomManager roomManager;
// テストで入る部屋の名前(4人とも同じ部屋に入る)
[SerializeField] private string roomName = "room1";
await EnterTeamAsync();
await roomManager.EnterAsync(socket, roomName);
Nakama のゲームオブジェクトの Inspector。Nakama Connection (Script) の Team Manager に「Nakama (Team Manager)」、Room Manager に「Nakama (Room Manager)」、Room Name に「room1」。Team Manager (Script) はたたんであり、Room Manager (Script) の Room View に「RoomView (Room View)」。Room Manager と Room Name、Room View を赤枠で囲んだもの
Room Manager と Room View をつなぐ

HierarchyでNakamaを選び、RoomManagerを付けてRoom ViewにRoomViewを入れます。Nakama ConnectionのRoom Managerには、同じゲームオブジェクトのRoomManagerを入れます。シーンを保存したら、Multiplayer Play Modeの窓でPlayer 2〜4のチェックを外して入れ直しておきます(#5の注意と同じ)。

4人で確かめよう

初めての再生

Nakamaのデータを空にしてから(docker compose down -v→docker compose up -d)、メインのエディタで再生しました。4人とも同じ部屋「room1」に入り、全員の画面の右上に4人の名前が出ました(記事のいちばん上の画像)。

メインのエディタ(スライム)。Game ビューの右上に「部屋「room1」(4人) スライム フェアリー メデューサ キョンシー」。Console の最後に「部屋にいる人(2人):スライム、フェアリー」「部屋にいる人(3人):スライム、フェアリー、メデューサ」「部屋にいる人(4人):スライム、フェアリー、メデューサ、キョンシー」。部屋の一覧と3行のログを赤枠で囲んだもの
人が入るたびに、サーバーから一覧が届く

最初に部屋を頼んだスライム(メインのエディタ)のログです。

部屋「room1」に入りました:b96a3cb2-2a45-41c0-8d8b-d39f84ac906e.nakama1
部屋にいる人(1人):スライム
チームに新しいメンバーが入りました
「赤チーム」のオンライン(2/2人):スライム、フェアリー
部屋にいる人(2人):スライム、フェアリー
部屋にいる人(3人):スライム、フェアリー、メデューサ
部屋にいる人(4人):スライム、フェアリー、メデューサ、キョンシー

人が入るたびに、サーバーから一覧が届いて、1人→4人と増えていきました。並びは、部屋に入った順です。サーバーのログでも、部屋を作ったのは1回だけでした。

部屋「room1」を作りました:b96a3cb2-2a45-41c0-8d8b-d39f84ac906e.nakama1
部屋「room1」にスライムが入りました
部屋「room1」にフェアリーが入りました
部屋「room1」にメデューサが入りました
部屋「room1」にキョンシーが入りました

Consoleで部屋を見る

Nakama の Console の Matches。Match ID「e1df02d8-…nakama1」、Presence Count 4、Authoritative true、Node nakama1、Handler Name turn_match、Tick Rate 1 の1行。1行を赤枠で囲んだもの
部屋は1つだけ、4人いる

4人で再生したまま、NakamaのConsoleのMatchesを開きました(下の「2回目の再生」のとき)。部屋は1つだけで、Presence Count(いる人)は4、Handler Nameは登録したturn_match、Tick Rateは1です。

Matches で部屋の行をクリックして開いた Match State。Match Label に {"room": "room1", "players": 4}、Match State に {"emptyTicks":0,"players":[{"name":"スライム",…},{"name":"キョンシー",…},{"name":"フェアリー",…},{"name":"メデューサ",…}],"room":"room1"}。Match Label と Match State を赤枠で囲んだもの
ラベルと、サーバーが持っている state が見られる

行をクリックすると、Match Label(ラベル)とMatch State(stateの中身)が見られます。サーバーのコードが持っている状態を、そのまま確かめられるので便利です。キーの順番がemptyTicks・players・roomの名前の順に並び替わっていて、オブジェクトのキーの順番が保たれないのも分かります。

Nakama の Console の Storage で、rooms・room1 を開いたところ(Edit Storage Object)。User ID は 00000000-0000-0000-0000-000000000000、Write Permissions は NO_WRITE、Read Permissions は NO_READ、Version と、値の {"matchId": "e1df02d8-…nakama1"}。Version と値を赤枠で囲んだもの
Storage の rooms に、部屋のマッチIDが1つ

Storageには、roomsのroom1があり、値は部屋のマッチIDです。CreatedとUpdatedの時刻が違うのは、部屋が閉じたあとに作り直して、書き換えたからです(次の「2回目の再生」)。

一覧が、入った返事より先に届いた

メデューサ(Player 4)の画面。Game の右上に「部屋「room1」(4人)」。Console の最後の2行が「部屋にいる人(4人):スライム、キョンシー、フェアリー、メデューサ」「部屋「room1」に入りました:e1df02d8-…」の順。2行を赤枠で囲んだもの
「部屋にいる人」が「入りました」より先に出た

最後に入ったメデューサのConsoleでは、「部屋にいる人(4人)」が「部屋「room1」に入りました」より先に出ていました。JoinMatchAsyncの返事より先に、サーバーの一覧が届いたということです。ReceivedMatchStateを先に登録しておいたので、見のがさずに済みました。

2回目の再生と、部屋が閉じるまで

止めて、1分ほどたってから、もう一度再生しました。サーバーのログはこうなりました。

部屋「room1」からスライムが抜けました
(ほかの3人も抜けた)
部屋「room1」に誰もいないので閉じます
部屋「room1」を作りました:e1df02d8-3282-40e4-9e3b-2357b7b1d5f9.nakama1
  • 4人が抜けてから60秒で、matchLoopがnullを返して部屋が閉じた
  • 次に頼んだときは、Storageの古いマッチIDの部屋が無いので、新しい部屋を作って書き換えた

止めて60秒たたないうちに再生したときは、「作りました」が出ずに、同じマッチIDの部屋にそのまま入りました。

1人がゲームを閉じると

キョンシー(Player 3)の画面を左右に並べたもの。左「4人のとき」:右上に「部屋「room1」(4人) スライム キョンシー フェアリー メデューサ」。右「Player 4 のチェックを外したあと」:右上に「部屋「room1」(3人) スライム キョンシー フェアリー」、左上のチームの一覧ではメデューサが灰色の○、Console の最後に「部屋にいる人(3人):スライム、キョンシー、フェアリー」。部屋の一覧と最後のログを赤枠で囲んだもの
メデューサが抜けると、部屋の一覧から消える

再生したまま、Multiplayer Play Modeの窓でPlayer 4(メデューサ)のチェックを外しました。ソケットが切れると、サーバーのmatchLeaveが呼ばれて、残った3人に新しい一覧が届きました。

  • 部屋の一覧からメデューサが消えて「部屋「room1」(3人)」になった
  • チームの一覧(前回)では、メデューサは灰色の○で残ったまま

チームは「メンバーかどうか」、部屋は「今ここにいるかどうか」なので、出方が違います。

スライム

これで、みんなで同じ部屋に集まれたね!

今回の通信チェック

  • docker compose up -d --buildで、TypeScriptのコードを入れたNakamaが起動した(ConsoleのRuntime Modulesにindex.jsとjoin_room)
  • 4人とも同じ部屋「room1」に入り、全員の画面の右上に4人の名前が出た
  • ConsoleのMatchesに部屋が1つ、Presence Countが4
  • curlで4人分のRPCを同時に呼んでも、マッチIDは1つになった
  • 誰もいなくなって60秒で部屋が閉じ、次の再生で作り直された
  • Player 4を外すと、残った3人の一覧からメデューサが消えた
プロジェクトの環境
  • Unityのバージョン:6.3 LTS(6000.3.22f1)
  • テンプレート:Universal 2D(Windows向け、Game ビューは Full HD)
  • Multiplayer Play Mode:2.0.2
  • Nakama Unity SDK:v3.23.0
  • サーバー:Nakama v3.42.0(WSL2のDocker Engine)、TypeScript 5.9.3、nakama-runtime(nakama-common)v1.49.0
フェアリー

部屋が出来たら、次は順番ね。誰の番かもサイコロの目も、ぜんぶサーバーが決めるのよ

次回は

次回は、この部屋で順番をまわします。ターンはサーバーが持ち、自分のチームの番のときだけボタンが押せて、サイコロもサーバーが振ります。チームの順に、サイコロの目だけコマが進むところまでやりたいと思います。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメント一覧 (1件)

コメントする

目次