やはり俺のターンがまわってこないのはまちがっている。#8|Nakamaで順番をまわす:ターンとサイコロはサーバーが持つ

4人の Game ビューを2行2列に並べたコマ送りの GIF(約10秒)。左上がスライム(赤チーム・メインのエディタ)、右上がフェアリー(赤チーム)、左下がキョンシー(青チーム・オート)、右下がメデューサ(青チーム)。真ん中の20マスの盤で、赤の「赤」と青の「青」のコマが交互に進み、下の文字が「1ターン目:赤チームの番」から「7ターン目:赤チームの番」まで変わる。番のチームの2人だけ「サイコロを振る」が白く押せる
今回のゴール:チームの順に、サイコロの目だけコマが進む

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

目次

今回やること

サイコロは、サーバーが振る。左のスライム(赤チーム)が「「振る」を送る(opcode 10 {turnNumber: 1})」。右の Nakama(matchLoop・1秒に1回)の枠に、①番のチームの人?(ちがえば捨てる)→ ②今のターンのつもり?(古ければ捨てる)→ ③サイコロを振る(Math.random で 1〜6)→ ④コマを進めて、次のチームへ(turnTeamIndex・turnNumber)。下に「opcode 1:状態の全体を全員に」の矢印と、4人の絵(2ターン目:青チームの番。スライム・フェアリーはボタン ×、キョンシー・メデューサはボタン ○)
クライアントは「振りたい」を送るだけ
  • サーバーの部屋に、チーム・ターン・コマの位置を持たせる
  • 番のチームの人から「サイコロを振る」(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〜19
  • OpCode:メッセージの種類を、TypeScriptのenumにした。サーバー → 全員の「状態の全体」が1、番の人 → サーバーの「サイコロを振る」が10
  • teams:部屋にいるチームを、番の順に並べたもの。最初に誰かが入ったチームが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つを確かめてから振ります。

  1. 番のチームの人か:送った人のteamIdが、今の番のチームと同じか
  2. 今のターンのつもりか:一緒に送ってもらったturnNumberが、今のturnNumberと同じか

どちらかが違えば、何もしないで捨てます。合っていれば、Math.randomで1〜6を出し、コマを進めて(BoardSizeで割った余りで、19の次は0に戻る)、次のチームの番にします。最後にsendSnapshotで、状態の全体を全員に送ります。

メッセージの中身(message.data)はバイト列なので、nk.binaryToStringで文字列にしてからJSON.parseで読みます。

なぜ、何ターン目かも送るの?

サーバーが捨てる「振る」。上の段「①番ではないチームの人」:2ターン目:青チームの番 → スライム(赤)が「振る」{turnNumber: 2} → 捨てる(スライムのチームの番ではない)。下の段「②前のターンのつもりで押した「振る」が、遅れて届いた」:5ターン目:赤チームの番 → スライム(赤)の「振る」{turnNumber: 3}(2ターン前)→ 捨てる(3ターン目のもの(今は5ターン目))。下に、メッセージは1秒ごとの matchLoop にまとめて届くので、同じ1秒の中で青チームが先に振ると、そのあとのスライムの「振る」は赤チームの番に見えてしまう、という説明
チームが違うものと、古いターンのものを捨てる

初めは、①の「番のチームの人か」だけを確かめていました。でも試してみると、青チームの番にスライムが押した「振る」が、そのまま赤チームの次の番の分として通ってしまいました。

  • メッセージは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;
}

サーバーでlastRollがnullのときも、JsonUtilityは中身が空のDiceRollを作ります。そのため、まだ誰も振っていないかどうかは、diceが0かどうかで見分けます。

マスとコマのプレハブ

Square のプレハブの Inspector。Rect Transform の Width 72・Height 72、Image の Source Image が None (Sprite)、Color が白。Width・Height と Source Image・Color を赤枠で囲んだもの
マスは 72×72 の白い四角

Assets/Prefabsに、マスとコマのプレハブを作ります。

  • Square(マス):Image(Source Imageは無し、Colorは白で少しだけ透明(A 230))、Width 72・Height 72。子に、左上にマスの番号を出すTextMeshPro(Number、Font Size 20、灰色)
Piece のプレハブの Inspector。Rect Transform の Width 34・Height 34、Image の Source Image が Knob。Width・Height と Source Image を赤枠で囲んだもの
コマは丸い Knob の画像
  • Piece(コマ):Image(Source Imageは、Unityに最初からある丸い画像のKnob)、Width 34・Height 34。子に、チームの名前の1文字目を出すTextMeshPro(Letter、Font Size 20、太字、白、真ん中)

盤を並べるBoardView

Hierarchy。Canvas の下に TeamView・RoomView・Board・TurnView、TurnView の下に TurnText と DiceButton(その下に Text (TMP))。Board から Text (TMP) までを赤枠で囲んだもの
Canvas に Board と TurnView を足す

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番目の赤が赤チームの色になる
Board の Inspector。Horizontal Layout Group の Spacing 8、Child Alignment Middle Center、Control Child Size と Child Force Expand はチェック無し。Board View (Script) の Squares Parent に Board、Square Prefab に Square、Piece Prefab に Piece、Team Colors の Element 0〜3 が赤・青・緑・黄、Piece Offsets の Element 0〜3 が (-17, -12)・(17, -12)・(-17, 16)・(17, 16)。Horizontal Layout Group と Board View の欄を赤枠で囲んだもの
Team Colors と Piece Offsets は番の順

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で知らせる
TurnView の Inspector。Rect Transform はたたんであり、Turn View (Script) の Turn Text に「TurnText (Text Mesh Pro UGUI)」、Dice Button に「DiceButton (Button)」。2つの欄を赤枠で囲んだもの
TurnText と DiceButton をつなぐ

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 の窓。Main Editor のタグは スライム・赤チーム、Player 2 は フェアリー・赤チーム、Player 3 は キョンシー・青チーム・オート、Player 4 は メデューサ・青チーム。Player 3 のオートを赤枠で囲んだもの
Player 3 にオートのタグ

テストでは、メインのエディタ(スライム)のボタンは自分で押せますが、仮想プレイヤーのボタンを押すのは手間です。そこで、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)も、オートのタグを除くようにしています。

Nakama のゲームオブジェクトの Inspector。Nakama Connection と Team Manager はたたんであり、Room Manager (Script) の Room View に RoomView、Board View に「Board (Board View)」、Turn View に「TurnView (Turn View)」。Board View と Turn View を赤枠で囲んだもの
Room Manager に Board View と Turn View を入れる

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)
メインのエディタ(スライム)。Game ビューの盤で、11マス目に青、13マス目に赤のコマ。その下に「7ターン目:赤チームの番(前の番:キョンシーが 5 を出した)」と、白い「サイコロを振る」ボタン。Console の最後に「7ターン目:赤チームの番(赤チーム 13マス目、青チーム 11マス目)← 自分のチーム」。盤・番の文字・ボタン・ログを赤枠で囲んだもの
赤チームの番なので、スライムのボタンが押せる

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

4ターン目(青チームの番)の4人の Game ビュー。4人とも「4ターン目:青チームの番(前の番:スライムが 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人選び、代表にだけ「あなたの番」を出して、代表をゆずれるようにしたいと思います。

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

コメント

コメント一覧 (1件)

コメントする

目次