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

- サーバーのコードを書く準備をする(TypeScript・tsconfig・Dockerfile)
- 部屋(マッチのハンドラー)を書く。入った人・抜けた人の一覧を、サーバーから全員に送る
- 部屋に入るためのRPCを書く。4人が同時に頼んでも、部屋は1つにする
- Unityで、RPCで部屋の番号をもらって入り、部屋にいる人を画面に出す
Unityのプロジェクトは前回のClientをそのまま使います。サーバーは、今回からServerフォルダにコードが増え、docker compose up -d --buildで起動するようになります。
サーバーのコードを書く準備をしよう
TypeScriptで書いて、ES5のJavaScriptにする

ここまでは、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つの関数

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 …)は登録できない、と公式のドキュメントに書かれています。
部屋にいる人は、配列で持つ

部屋の状態(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つだけ置く

部屋の名前(room1)とマッチIDの組は、Storage(サーバーの小さな保存場所)のroomsに置きます。
- Storageを読む。マッチIDがあって、その部屋がまだ開いていれば(
nk.matchGetがnullでなければ)、そのIDを返す - 無ければ、
nk.matchCreateで部屋を作る - 作ったマッチ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(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


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


- 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.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で読む
先に受け取る準備をしてから入る


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


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人の名前が出ました(記事のいちばん上の画像)。


最初に部屋を頼んだスライム(メインのエディタ)のログです。
部屋「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で部屋を見る


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 を赤枠で囲んだもの](https://anogame.net/wp-content/uploads/2026/11/unity-nakama-07-authoritative-match-match.png)
![Matches で部屋の行をクリックして開いた Match State。Match Label に {"room": "room1", "players": 4}、Match State に {"emptyTicks":0,"players":[{"name":"スライム",…},{"name":"キョンシー",…},{"name":"フェアリー",…},{"name":"メデューサ",…}],"room":"room1"}。Match Label と Match State を赤枠で囲んだもの](https://anogame.net/wp-content/uploads/2026/11/unity-nakama-07-authoritative-match-match.png)
行をクリックすると、Match Label(ラベル)とMatch State(stateの中身)が見られます。サーバーのコードが持っている状態を、そのまま確かめられるので便利です。キーの順番がemptyTicks・players・roomの名前の順に並び替わっていて、オブジェクトのキーの順番が保たれないのも分かります。


Storageには、roomsのroom1があり、値は部屋のマッチIDです。CreatedとUpdatedの時刻が違うのは、部屋が閉じたあとに作り直して、書き換えたからです(次の「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人がゲームを閉じると


再生したまま、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



部屋が出来たら、次は順番ね。誰の番かもサイコロの目も、ぜんぶサーバーが決めるのよ
次回は
次回は、この部屋で順番をまわします。ターンはサーバーが持ち、自分のチームの番のときだけボタンが押せて、サイコロもサーバーが振ります。チームの順に、サイコロの目だけコマが進むところまでやりたいと思います。
コメント
コメント一覧 (1件)
[…] 前回:#7|Nakamaの権威マッチで対戦の部屋を作る:TypeScriptのサーバーコードとRPC […]