
前回は、4人が同じ対戦の部屋に入れるようになりました。いよいよ、このシリーズのタイトルの「ターン」です。今回は、赤チームと青チームが交互にサイコロを振って、マス目の盤でコマを進めます。誰の番か・サイコロの目・コマの位置は、ぜんぶサーバーが決めます。
今回やること

- サーバーの部屋に、チーム・ターン・コマの位置を持たせる
- 番のチームの人から「サイコロを振る」(opcode 10)が届いたら、サーバーがサイコロを振ってコマを進め、次のチームの番にする
- 番ではない人のメッセージや、古いターンのメッセージは、サーバーが捨てる
- Unityは、届いた状態(opcode 1)で盤とコマと「誰の番か」を描き、自分のチームの番のときだけボタンを押せるようにする
盤は、20マスを横に並べただけの最小のものです(最後のマスの次は、最初のマスに戻ります)。ゴールや止まったマスのイベントは作らず、「順番がまわる」ことだけを確かめます。
ターンはサーバーが持つ
なぜサーバーで決めるの?
オンラインのターン制では、「誰の番か」と「サイコロの目」をクライアントに決めさせると、ズルが出来てしまいます。
- 自分の番ではないのに振る
- 好きな目を出す(6ばかり出す)
- 1回の番で2回振る
そこで、クライアントが送るのは「サイコロを振りたい」だけにします。サーバーは、番のチームの人かどうかを確かめてから、自分でサイコロを振り、コマを進め、次のチームの番にして、その結果を全員に送ります。前回作った権威マッチは、このためのものです。
スライムえー、サイコロくらい自分で振りたいなあ



画面のボタンを押すのはスライムよ。でも、目を決めるのはサーバー。そうしないと、6しか出ないスライムが現れるもの
部屋の状態に、チームとターンを足す
Server/src/main.tsを直します。前回のコードに足したところを中心に載せます(RPCのjoin_roomと、matchJoinAttempt・matchTerminate・matchSignalは前回のままです)。
// 盤のマスの数(最後のマスの次は、最初のマスに戻る)
const BoardSize = 20;
// メッセージの種類
enum OpCode {
// サーバー → 全員:状態の全体
Snapshot = 1,
// 番のチームの人 → サーバー:サイコロを振る(何ターン目のつもりか)
RollDice = 10,
}
interface Player {
userId: string;
name: string;
// 入っているチーム(Nakama のグループのID)。チームに入っていなければ ""
teamId: string;
}
interface Team {
id: string;
name: string;
// コマのいるマス(0 から BoardSize - 1)
position: number;
}
// 最後に振ったサイコロ
interface DiceRoll {
teamId: string;
playerName: string;
dice: number;
}
interface RoomState {
room: string;
// 部屋にいる人(入った順。オブジェクトのキーの順番は保たれないので、配列にする)
players: Player[];
// チーム(番の順。最初に誰かが入ったチームから)
teams: Team[];
// 今、番のチーム(teams の何番目か)
turnTeamIndex: number;
// 何ターン目か(1から)
turnNumber: number;
lastRoll: DiceRoll | null;
// 誰もいない tick が続いた数
emptyTicks: number;
}
BoardSize:盤のマスの数。コマの位置は0〜19OpCode:メッセージの種類を、TypeScriptのenumにした。サーバー → 全員の「状態の全体」が1、番の人 → サーバーの「サイコロを振る」が10teams:部屋にいるチームを、番の順に並べたもの。最初に誰かが入ったチームが1番目になるturnTeamIndex:今、番のチームがteamsの何番目か。turnNumberは何ターン目か
matchInitでは、teamsを空、turnTeamIndexを0、turnNumberを1、lastRollをnullにしておきます。
const state: RoomState = { room: params.room, players: [], teams: [], turnTeamIndex: 0, turnNumber: 1, lastRoll: null, emptyTicks: 0 };
チームは、サーバーが調べる
// 入った人を覚えて、状態の全体を全員に送る
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) {
// チームはサーバーが調べる(クライアントの言うことを信じない)
const team = findTeamOfUser(nk, user.userId);
let teamId = "";
if (team != null) {
teamId = team.id;
addTeam(logger, state, team);
}
// 同じ人が入り直したときは、前の分を外してから足す
state.players = state.players.filter(player => player.userId != user.userId);
state.players.push({ userId: user.userId, name: user.displayName || user.username, teamId: teamId });
logger.info("部屋「%s」に%sが入りました", state.room, user.displayName);
}
sendSnapshot(dispatcher, state);
return { state: state };
}
// ユーザーが入っているチーム(グループ)。入っていなければ null
function findTeamOfUser(nk: nkruntime.Nakama, userId: string): nkruntime.Group | null {
const userGroupList = nk.userGroupsList(userId, 1);
if (!userGroupList.userGroups || userGroupList.userGroups.length == 0) {
return null;
}
return userGroupList.userGroups[0].group || null;
}
// まだ無いチームなら、番の順の最後に足す
function addTeam(logger: nkruntime.Logger, state: RoomState, group: nkruntime.Group) {
const found = state.teams.filter(team => team.id == group.id);
if (found.length > 0) {
return;
}
state.teams.push({ id: group.id, name: group.name, position: 0 });
logger.info("部屋「%s」に%sが加わりました(%d番目)", state.room, group.name, state.teams.length);
}
部屋に入った人のチームは、nk.userGroupsListでサーバーが調べます。クライアントに「自分は赤チームです」と送ってもらう方法もありますが、それだとほかのチームのふりが出来てしまいます。サーバーが知っていることは、サーバーで調べます。
- #5で、1人が入れるチームは1つだけにしたので、
limitは1 - まだ
teamsに無いチームなら、番の順の最後に足す
サイコロはサーバーで振る
届いたメッセージは、matchLoopでまとめて受け取る
// 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 {
for (const message of messages) {
if (message.opCode == OpCode.RollDice) {
rollDice(logger, nk, dispatcher, state, message);
}
}
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 };
}
クライアントが送ったメッセージは、matchLoopのmessagesにまとめて届きます。tick rateは1なので、1秒のあいだに届いたものが、届いた順に並んでいます。opcodeが10(サイコロを振る)なら、rollDiceを呼びます。
番の人か・今のターンかを確かめてから振る
// 番のチームの人なら、サーバーがサイコロを振ってコマを進め、次のチームの番にする
function rollDice(logger: nkruntime.Logger, nk: nkruntime.Nakama, dispatcher: nkruntime.MatchDispatcher, state: RoomState, message: nkruntime.MatchMessage) {
const player = findPlayer(state, message.sender.userId);
const turnTeam = state.teams[state.turnTeamIndex];
if (player == null || turnTeam == null) {
return;
}
// 番ではないチームの人のメッセージは、何もしないで捨てる
if (player.teamId != turnTeam.id) {
logger.info("%sのチームの番ではないので、サイコロを振れません", player.name);
return;
}
// { "turnNumber": 3 }:何ターン目のつもりで押したか。今のターンでなければ、前のターンの古いメッセージなので捨てる
const request = JSON.parse(nk.binaryToString(message.data));
if (request.turnNumber != state.turnNumber) {
logger.info("%sの「振る」は%dターン目のものなので捨てます(今は%dターン目)", player.name, request.turnNumber, state.turnNumber);
return;
}
const dice = Math.floor(Math.random() * 6) + 1;
turnTeam.position = (turnTeam.position + dice) % BoardSize;
state.lastRoll = { teamId: turnTeam.id, playerName: player.name, dice: dice };
logger.info("%sの%sが%dを出して、%dマス目へ", turnTeam.name, player.name, dice, turnTeam.position);
// 次のチームの番
state.turnTeamIndex = (state.turnTeamIndex + 1) % state.teams.length;
state.turnNumber++;
sendSnapshot(dispatcher, state);
}
rollDiceは、2つを確かめてから振ります。
- 番のチームの人か:送った人の
teamIdが、今の番のチームと同じか - 今のターンのつもりか:一緒に送ってもらった
turnNumberが、今のturnNumberと同じか
どちらかが違えば、何もしないで捨てます。合っていれば、Math.randomで1〜6を出し、コマを進めて(BoardSizeで割った余りで、19の次は0に戻る)、次のチームの番にします。最後にsendSnapshotで、状態の全体を全員に送ります。
メッセージの中身(message.data)はバイト列なので、nk.binaryToStringで文字列にしてからJSON.parseで読みます。
なぜ、何ターン目かも送るの?


初めは、①の「番のチームの人か」だけを確かめていました。でも試してみると、青チームの番にスライムが押した「振る」が、そのまま赤チームの次の番の分として通ってしまいました。
- メッセージは1秒ごとの
matchLoopにまとめて届く - 同じ1秒の中で、青チームのキョンシーの「振る」が先、スライムの「振る」があとに並んでいた
- キョンシーの分で赤チームの番になったので、スライムの分は「番のチームの人」に見えた
そこで、クライアントに「何ターン目のつもりで押したか」も送ってもらい、今のターンと違うものは捨てるようにしました。2回押してしまったときや、通信が遅れて古いメッセージが届いたときも、これで防げます。
サーバーは、メッセージが「いつ押されたものか」を知りません。届いたときの状態だけで判断すると、古いメッセージが今の番の分として通ることがあります。ターン制では、何ターン目のつもりかを一緒に送ってもらうと安心です。
状態の全体を送る
// 状態の全体を全員に送り、ラベルの人数も直す
function sendSnapshot(dispatcher: nkruntime.MatchDispatcher, state: RoomState) {
const snapshot = {
players: state.players,
teams: state.teams,
turnTeamIndex: state.turnTeamIndex,
turnNumber: state.turnNumber,
lastRoll: state.lastRoll,
};
dispatcher.broadcastMessage(OpCode.Snapshot, JSON.stringify(snapshot));
dispatcher.matchLabelUpdate(makeLabel(state));
}
前回は部屋にいる人だけを送っていましたが、チーム・ターン・最後のサイコロも足しました。人が入ったとき・抜けたとき・サイコロを振ったときに、これを全員に送ります。毎回ぜんぶを送るのは少し無駄ですが、今は分かりやすさを優先しています(変わったところだけを送る「差分」は、このシリーズの#10でやります)。
書き終えたら、前回と同じくServerフォルダでdocker compose up -d --buildします。
Unityで盤とコマを出そう
メッセージの種類とJSONの形
Assets/ScriptsにOpCode.csを作ります。サーバーのOpCodeと同じ数字にします。
// メッセージの種類(サーバーの main.ts の OpCode と同じ数字にする)
public enum OpCode : long
{
// サーバー → 全員:状態の全体
Snapshot = 1,
// 番のチームの人 → サーバー:サイコロを振る(何ターン目のつもりか)
RollDice = 10,
}
C#のenumは、: longで中身の型を決められます。Nakamaのopcodeはlongなので、(long)OpCode.Snapshotのように変えて使います。
RoomMessages.csには、サイコロを振るときに送るJSONと、チーム・最後のサイコロを足しました。
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;
}
// サイコロを振る(opcode 10)。何ターン目のつもりで押したか
[Serializable]
public class RollDiceRequest
{
public int turnNumber;
}
// 部屋にいる1人
[Serializable]
public class RoomPlayer
{
public string userId;
public string name;
// 入っているチームのID(チームに入っていなければ空)
public string teamId;
}
// 部屋にいるチーム
[Serializable]
public class TeamState
{
public string id;
public string name;
// コマのいるマス
public int position;
}
// 最後に振ったサイコロ(まだ誰も振っていなければ dice は 0)
[Serializable]
public class DiceRoll
{
public string teamId;
public string playerName;
public int dice;
}
// サーバーから届く、状態の全体(opcode 1)
[Serializable]
public class RoomSnapshot
{
public RoomPlayer[] players;
// 番の順
public TeamState[] teams;
// 今、番のチーム(teams の何番目か)
public int turnTeamIndex;
public int turnNumber;
public DiceRoll lastRoll;
}
マスとコマのプレハブ


Assets/Prefabsに、マスとコマのプレハブを作ります。
- Square(マス):Image(Source Imageは無し、Colorは白で少しだけ透明(A 230))、Width 72・Height 72。子に、左上にマスの番号を出すTextMeshPro(
Number、Font Size 20、灰色)


- Piece(コマ):Image(Source Imageは、Unityに最初からある丸い画像のKnob)、Width 34・Height 34。子に、チームの名前の1文字目を出すTextMeshPro(
Letter、Font Size 20、太字、白、真ん中)
盤を並べるBoardView


Canvasの下に、空のゲームオブジェクトBoardを作ります。
- Rect Transform:アンカーは真ん中、Pos X 0・Pos Y 0、Width 1592・Height 72
- Horizontal Layout Group:Spacing 8、Child Alignment は Middle Center、Control Child Size と Child Force Expand のチェックは外す(マスの大きさはプレハブのまま)
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
// マス目の盤と、チームのコマを出す
public class BoardView : MonoBehaviour
{
// マスの数(サーバーの BoardSize と同じ)
private const int SquareCount = 20;
// マスを並べる親(Horizontal Layout Group)
[SerializeField] private RectTransform squaresParent;
[SerializeField] private Image squarePrefab;
[SerializeField] private Image piecePrefab;
// チームの色(番の順)
[SerializeField] private Color[] teamColors;
// マスの中での、コマの位置(番の順)
[SerializeField] private Vector2[] pieceOffsets;
private readonly List<Image> squares = new List<Image>();
private readonly List<Image> pieces = new List<Image>();
private void Awake()
{
for (int i = 0; i < SquareCount; i++)
{
Image square = Instantiate(squarePrefab, squaresParent);
square.name = $"Square{i}";
square.GetComponentInChildren<TMP_Text>().text = i.ToString();
squares.Add(square);
}
}
public void Show(TeamState[] teams)
{
for (int i = 0; i < teams.Length; i++)
{
if (pieces.Count <= i)
{
pieces.Add(Instantiate(piecePrefab));
}
Image piece = pieces[i];
TeamState team = teams[i];
// コマのいるマスの子にして、マスの中で少しずらす
piece.transform.SetParent(squares[team.position].transform, false);
piece.rectTransform.anchoredPosition = pieceOffsets[i % pieceOffsets.Length];
piece.color = TeamColor(i);
// コマの字は、チームの名前の1文字目
piece.GetComponentInChildren<TMP_Text>().text = team.name.Substring(0, 1);
}
}
public Color TeamColor(int teamIndex)
{
return teamColors[teamIndex % teamColors.Length];
}
}
Awake:Squareを20個作って、Boardの子に並べる(Horizontal Layout Groupが横に並べてくれる)Show:チームのコマを、いるマスの子にして、マスの中で少しずらす(2チームが同じマスでも重ならない)- 色は、番の順(
teamsの何番目か)で決める。今回は赤チームが先に入ったので、1番目の赤が赤チームの色になる


BoardViewをBoardに付けて、次のように入れます。
- Squares Parent:Board(自分)
- Square Prefab・Piece Prefab:作ったプレハブ
- Team Colors:赤(E84A4A)・青(3A78E0)・緑・黄の4つ
- Piece Offsets:(-17, -12)・(17, -12)・(-17, 16)・(17, 16)
誰の番かとボタンを出すTurnView
Canvasの下に空のゲームオブジェクトTurnView(Pos Y -230、Width 1400・Height 360)を作り、その子に2つ作ります。
TurnText:TextMeshPro、上に寄せる(Font Size 40、真ん中そろえ)DiceButton:「+」>UI (Canvas)>Button – TextMeshPro。下に寄せて Width 400・Height 100、子のテキストは「サイコロを振る」(Font Size 40)
using System;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
// 誰の番か・最後のサイコロの目と、「サイコロを振る」ボタン
public class TurnView : MonoBehaviour
{
[SerializeField] private TMP_Text turnText;
[SerializeField] private Button diceButton;
// ボタンが押された
public event Action RollClicked;
private void Awake()
{
diceButton.onClick.AddListener(OnDiceButtonClicked);
diceButton.interactable = false;
}
public void Show(RoomSnapshot snapshot, Color turnTeamColor, bool isMyTurn)
{
string turnTeamName = snapshot.teams[snapshot.turnTeamIndex].name;
string colorCode = ColorUtility.ToHtmlStringRGB(turnTeamColor);
string text = $"{snapshot.turnNumber}ターン目:<color=#{colorCode}>{turnTeamName}</color>の番";
if (snapshot.lastRoll != null && snapshot.lastRoll.dice > 0)
{
text += $"\n(前の番:{snapshot.lastRoll.playerName}が {snapshot.lastRoll.dice} を出した)";
}
turnText.text = text;
// 自分のチームの番のときだけ押せる
diceButton.interactable = isMyTurn;
}
private void OnDiceButtonClicked()
{
// 次の状態が届くまで、続けて押せないようにする
diceButton.interactable = false;
RollClicked?.Invoke();
}
}
Show:「何ターン目:どのチームの番」と、前の番のサイコロを出す。チームの名前は、コマと同じ色にするdiceButton.interactable:自分のチームの番のときだけtrueにする。falseのボタンは灰色になって押せない- 押したら、次の状態が届くまで押せないようにしてから、
RollClickedで知らせる


RoomManagerで、届いた状態を描いて「振る」を送ろう
RoomManager.csを直します。
using System;
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 float AutoRollDelaySeconds = 3f;
[SerializeField] private RoomView roomView;
[SerializeField] private BoardView boardView;
[SerializeField] private TurnView turnView;
// テスト用:自分のチームの番になったら、自動でサイコロを振る
public bool AutoRoll { get; set; }
private ISocket socket;
private string myUserId;
private string roomName;
private string matchId;
// 最後に届いた状態のターン
private int turnNumber;
// 自動で振ったターン(同じターンに2回振らないため)
private int autoRolledTurnNumber;
private void Awake()
{
turnView.RollClicked += OnRollClicked;
}
public async Task EnterAsync(ISocket nakamaSocket, string userId, string enteringRoomName)
{
socket = nakamaSocket;
myUserId = userId;
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 != (long)OpCode.Snapshot)
{
return;
}
string json = Encoding.UTF8.GetString(matchState.State);
RoomSnapshot snapshot = JsonUtility.FromJson<RoomSnapshot>(json);
roomView.Show(roomName, snapshot.players);
if (snapshot.teams.Length == 0)
{
return;
}
turnNumber = snapshot.turnNumber;
boardView.Show(snapshot.teams);
bool isMyTurn = IsMyTurn(snapshot);
turnView.Show(snapshot, boardView.TeamColor(snapshot.turnTeamIndex), isMyTurn);
TeamState turnTeam = snapshot.teams[snapshot.turnTeamIndex];
string positions = string.Join("、", snapshot.teams.Select(team => $"{team.name} {team.position}マス目"));
Debug.Log($"{snapshot.turnNumber}ターン目:{turnTeam.name}の番({positions}){(isMyTurn ? "← 自分のチーム" : "")}");
if (isMyTurn && AutoRoll && autoRolledTurnNumber != snapshot.turnNumber)
{
autoRolledTurnNumber = snapshot.turnNumber;
AutoRollAsync();
}
}
// 番のチームに、自分が入っているか
private bool IsMyTurn(RoomSnapshot snapshot)
{
RoomPlayer me = snapshot.players.FirstOrDefault(player => player.userId == myUserId);
TeamState turnTeam = snapshot.teams[snapshot.turnTeamIndex];
return me != null && me.teamId == turnTeam.id;
}
private async void OnRollClicked()
{
try
{
await RollDiceAsync();
}
catch (Exception e)
{
Debug.LogError($"サイコロを振れませんでした:{e.Message}");
}
}
// サイコロを振ってほしいと、サーバーに送る(目はサーバーが決める)
public async Task RollDiceAsync()
{
// 何ターン目のつもりで押したかも送る
RollDiceRequest request = new RollDiceRequest { turnNumber = turnNumber };
await socket.SendMatchStateAsync(matchId, (long)OpCode.RollDice, JsonUtility.ToJson(request));
Debug.Log($"{turnNumber}ターン目のサイコロを振ってと、サーバーに送りました");
}
// テスト用:少し待ってから振る
private async void AutoRollAsync()
{
try
{
await Awaitable.WaitForSecondsAsync(AutoRollDelaySeconds);
await RollDiceAsync();
}
catch (Exception e)
{
Debug.LogError($"サイコロを振れませんでした:{e.Message}");
}
}
}
OnMatchState:状態の全体が届いたら、部屋の一覧・盤・番の表示を書き換える。届いたturnNumberは覚えておくIsMyTurn:届いたplayersから自分を探し、自分のteamIdが番のチームと同じかを見る。自分のユーザーIDはEnterAsyncでもらうRollDiceAsync:SendMatchStateAsyncで、opcode 10と{"turnNumber": 3}のようなJSONを送る。目はサーバーが決めるので、送るのは「何ターン目のつもりか」だけ
ボタンを押せなくするのは、まちがえて押さないための見た目の工夫です。改造したクライアントなら、ボタンに関係なくメッセージを送れます。本当に守るのは、サーバーの確かめです。今回も、わざと番ではないときに送って、サーバーが捨てるのを確かめました(あとの「4人で確かめよう」)。
テスト用のオート


テストでは、メインのエディタ(スライム)のボタンは自分で押せますが、仮想プレイヤーのボタンを押すのは手間です。そこで、Multiplayer Play Modeのタグにオートを作り、Player 3(キョンシー)に付けました。オートのタグの人は、自分のチームの番になると、3秒待ってから自動で「振る」を送ります(AutoRollとAutoRollAsync)。
NakamaConnection.csは、オートのタグを見るところと、RoomManagerに自分のユーザーIDを渡すところを直しました。
// テスト用:このタグの人は、自分のチームの番に自動でサイコロを振る
private const string AutoRollTag = "オート";
roomManager.AutoRoll = CurrentPlayer.Tags.Contains(AutoRollTag);
await roomManager.EnterAsync(socket, session.UserId, roomName);
名前にするタグを選ぶところ(SetDisplayNameAsync)も、オートのタグを除くようにしています。


HierarchyでNakamaを選び、Room ManagerのBoard ViewにBoard、Turn ViewにTurnViewを入れます。シーンを保存したら、Player 2〜4のチェックを外して入れ直します。
仮想プレイヤーのGameビューは、初めはFree Aspectでした。そのままだと横に長い盤が両はしで切れるので、仮想プレイヤーの窓のGameビューでも**Full HD (1920×1080)**を選んでおきます。
4人で確かめよう
順番にまわる
Nakamaのデータを空にしてから再生し、メインのエディタでスライムの「サイコロを振る」を押しました。サーバーのログです。
部屋「room1」に赤チームが加わりました(1番目)
部屋「room1」にスライムが入りました
部屋「room1」に青チームが加わりました(2番目)
部屋「room1」にキョンシーが入りました
部屋「room1」にメデューサが入りました
部屋「room1」にフェアリーが入りました
赤チームのスライムが6を出して、6マス目へ
スライムのチームの番ではないので、サイコロを振れません
青チームのキョンシーが2を出して、2マス目へ
赤チームのスライムが2を出して、8マス目へ
青チームのキョンシーが4を出して、6マス目へ
スライムの「振る」は3ターン目のものなので捨てます(今は5ターン目)
赤チームのスライムが5を出して、13マス目へ
青チームのキョンシーが5を出して、11マス目へ
- 最初に入ったスライムの赤チームが1番目、次の青チームが2番目になった
- スライムが押す → 3秒後にキョンシー(オート)が振る、で赤・青・赤・青と交互にまわった
- 4人の画面のコマと「何ターン目」は、いつも同じだった(記事のいちばん上のGIF)


番のチームの2人だけ押せる


青チームの番では、キョンシーとメデューサのボタンが押せて、スライムとフェアリーのボタンは灰色になりました。今は、番のチームの人なら誰でも振れます。同じチームの2人が同時に押したら、先に届いたほうが振り、あとのほうは「次のチームの番」なので捨てられます。
番ではないのに送ると
ボタンが灰色の青チームの番に、テスト用のスクリプトで、スライムから「振る」を送りました。サーバーは「スライムのチームの番ではないので、サイコロを振れません」と捨てて、コマは動きませんでした。
赤チームの番には、2ターン前のつもりの「振る」(turnNumberが3)を送りました。こちらも「3ターン目のものなので捨てます(今は5ターン目)」と捨てられました。



灰色のボタンを無理やり押しても、サーバーが聞いてくれないんだね
今回の通信チェック
- 4人の画面に、同じ盤とコマと「何ターン目:どのチームの番」が出た
- スライムが押すと、サーバーが振った目だけ赤のコマが進み、青チームの番になった
- 赤・青・赤・青と、チームの順にまわった
- 番のチームの人だけ、ボタンが押せた
- 番ではないチームの「振る」と、古いターンの「振る」は、サーバーが捨てた
- 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



今はチームの誰でも振れるわね。次は、番が来たチームの中で、誰が振るか(代表)を決めるわよ
次回は
次回は、番が来たチームの代表を決めます。チームの中でマッチにいる人から代表を1人選び、代表にだけ「あなたの番」を出して、代表をゆずれるようにしたいと思います。
コメント
コメント一覧 (1件)
[…] 前回:#8|Nakamaで順番をまわす:ターンとサイコロはサーバーが持つ […]