超入門 Unityオンラインゲーム開発 PhotonPUN2 講座

using UnityEngine;
using Photon.Pun;
using Photon.Realtime;
public class CharaScript : MonoBehaviourPun
{
    void Update()
    {
        if(!photonView.IsMine)
        {
            return;
        }
        if (Input.GetKey("up"))
        {
            transform.position += transform.forward * 0.05f;
        }
        if (Input.GetKey("down"))
        {
            transform.position -= transform.forward * 0.05f;
        }
        if (Input.GetKey("right"))
        {
            transform.Rotate(0, 100 * Time.deltaTime, 0);
        }
        if (Input.GetKey("left"))
        {
            transform.Rotate(0, -100 * Time.deltaTime, 0);
        }
    }
}

using UnityEngine;
using Photon.Pun;
using Photon.Realtime;
public class SimplePun : MonoBehaviourPunCallbacks
{
    void Start()
    {
        //旧バージョンでは引数必須でしたが、PUN2では不要です。
        PhotonNetwork.ConnectUsingSettings();
        if (string.IsNullOrEmpty(PhotonNetwork.NickName))
        {
            PhotonNetwork.NickName = "player" + Random.Range(1, 99999);
        }
    }
    void OnGUI()
    {
        //ログインの状態を画面上に出力
        GUILayout.Label(PhotonNetwork.NetworkClientState.ToString());
    }
    //ルームに入室前に呼び出される
    public override void OnConnectedToMaster()
    {
        // "room"という名前のルームに参加する（ルームが無ければ作成してから参加する）
        PhotonNetwork.JoinOrCreateRoom("room", new RoomOptions(), TypedLobby.Default);
    }
    //ルームに入室後に呼び出される
    public override void OnJoinedRoom()
    {
        //キャラクターを生成
        GameObject chara = PhotonNetwork.Instantiate("chara", new Vector3(0.0f, 0.5f, 0.0f), Quaternion.identity, 0);
        //自分だけが操作できるようにスクリプトを有効にする
        CharaScript charaScript = chara.GetComponent<CharaScript>();
        charaScript.enabled = true;
    }
}

// ルーム内のプレイヤー全員のプレイヤー名とIDをコンソールに出力する
foreach (var player in PhotonNetwork.PlayerList)
{
    Debug.Log($"{player.NickName}({player.ActorNumber})");
}

// ローカルプレイヤーの名前を設定する
PhotonNetwork.NickName = "Player";

// ローカルプレイヤーがマスタークライアントかどうかを判定する
if (PhotonNetwork.IsMasterClient)
{
    Debug.Log("自身がマスタークライアントです");
}

using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

public class PlayerCallbackSample : MonoBehaviourPunCallbacks
{
    // 他プレイヤーがルームへ参加した時に呼ばれるコールバック
    public override void OnPlayerEnteredRoom(Player newPlayer)
    {
        Debug.Log($"{newPlayer.NickName}が参加しました");
    }

    // 他プレイヤーがルームから退出した時に呼ばれるコールバック
    public override void OnPlayerLeftRoom(Player otherPlayer) 
    {
        Debug.Log($"{otherPlayer.NickName}が退出しました");
    }
}

using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

public class OwnershipSample : MonoBehaviourPun
{
    private void Start()
    {
        // 自身が管理者かどうかを判定する
        if (photonView.IsMine) 
        {
            // 所有者を取得する
            Player owner = photonView.Owner;
            // 所有者のプレイヤー名とIDをコンソールに出力する
            Debug.Log($"{owner.NickName}({photonView.OwnerActorNr})");
        }
    }
}

// "NetworkedObject"プレパブからネットワークオブジェクトを生成する(生成者と所有権が結びつく)
PhotonNetwork.Instantiate("NetworkedObject", Vector3.zero, Quaternion.identity);

// "NetworkedObject"プレパブからネットワークオブジェクトを生成する(ルームと所有権が結びつく)
PhotonNetwork.InstantiateRoomObject("NetworkedObject", Vector3.zero, Quaternion.identity);

// "NetworkedObject"プレパブからネットワークオブジェクトを生成する(シーンと所有権が結びつく)
PhotonNetwork.InstantiateSceneObject("NetworkedObject", Vector3.zero, Quaternion.identity);

using System.Collections.Generic;
using UnityEngine;
using Photon.Pun;

public class CPhotonPool : MonoBehaviourPunCallbacks, IPunPrefabPool
{
    public List<GameObject> PrefabList;

    public void Start()
    {
        // Poolの生成イベントを書き換える
        PhotonNetwork.PrefabPool = this;
    }

    public GameObject Instantiate(string prefabId, Vector3 position, Quaternion rotation)
    {
        Debug.Log(prefabId);
        foreach (var s in PrefabList)
        {
            if (s.name == prefabId)
            {
                var go = Instantiate(s, position, rotation);
                // 生成されたネットワークオブジェクトは非アクティブ状態で返す必要がある
                //（その後、PhotonNetworkの内部で正しく初期化されてから自動的にアクティブ状態に戻される）
                go.SetActive(false);
                return go;
            }
        }

        return null;
    }

    public void Destroy(GameObject go)
    {
        GameObject.Destroy(go);
    }
}

using System.Collections.Generic;
using UnityEngine;
using Photon.Pun;

public class CPhotonPool : MonoBehaviourPunCallbacks, IPunPrefabPool
{
    public List<GameObject> PrefabList;

    private Stack<GameObject> inactiveObjectPool = new Stack<GameObject>();

    public void Start()
    {
        // Poolの生成イベントを書き換える
        PhotonNetwork.PrefabPool = this;
    }

    public GameObject Instantiate(string prefabId, Vector3 position, Quaternion rotation)
    {
        foreach (var s in PrefabList)
        {
            if (s.name == prefabId)
            {
                GameObject go;
                if (inactiveObjectPool.Count > 0)
                {
                    go = inactiveObjectPool.Pop();
                    go.transform.SetPositionAndRotation(position, rotation);
                }
                else
                {
                    go = Instantiate(s, position, rotation);
                    go.SetActive(false);
                }
                return go;
            }
        }

        return null;
    }

    public void Destroy(GameObject go)
    {
        //GameObject.Destroy(go);
        // PhotonNetworkの内部で既に非アクティブ状態にされているので、以下の処理は不要
        //go.SetActive(false);
        inactiveObjectPool.Push(go);
    }
}

public class GamePlayer : MonoBehaviourPunCallbacks
{
    private void Awake() {
        // Object.Instantiateの後に一度だけ必要な初期化処理を行う
    }

    private void Start() {
        // 生成後に一度だけ（OnEnableの後に）呼ばれる、ここで初期化処理を行う場合は要注意
    }

    public override void OnEnable() {
        base.OnEnable();

        // PhotonNetwork.Instantiateの生成処理後に必要な初期化処理を行う
    }

    public override void OnDisable() {
        base.OnDisable();

        // PhotonNetwork.Destroyの破棄処理前に必要な終了処理を行う
    }
}

// 所有権のリクエストが行われた時に呼ばれるコールバック
void IPunOwnershipCallbacks.OnOwnershipRequest(PhotonView targetView, Player requestingPlayer)
{
    // 自身が所有権を持つインスタンスで所有権のリクエストが行われたら、常に許可して所有権を移譲する
    if (targetView.IsMine && targetView.ViewID == photonView.ViewID) 
    {
        bool acceptsRequest = true;
        if (acceptsRequest)
        {
            targetView.TransferOwnership(requestingPlayer);
        } else {
            // リクエストを拒否する場合は、何もしない
        }
    }
}

// 所有権の移譲が行われた時に呼ばれるコールバック
void IPunOwnershipCallbacks.OnOwnershipTransfered(PhotonView targetView, Player previousOwner)
{
    if (targetView.ViewID == photonView.ViewID)
    {
        string id = targetView.ViewID.ToString();
        string p1 = previousOwner.NickName;
        string p2 = targetView.Owner.NickName;
        Debug.Log($"ViewID {id} の所有権が {p1} から {p2} に移譲されました");
    }
}

// ルーム内のネットワークオブジェクトの名前とIDをコンソールに出力する
foreach (var photonView in PhotonNetwork.PhotonViewCollection)
{
    Debug.Log($"{photonView.gameObject.name}({photonView.ViewID})");
}

using System.Collections.Generic;
using UnityEngine;

public class AvatarContainer : MonoBehaviour
{
    private List<AvatarContainerChild> avatarList = new List<AvatarContainerChild>();

    public AvatarContainerChild this[int index] => avatarList[index];
    public int Count => avatarList.Count;

    private void OnTransformChildrenChanged() {
        avatarList.Clear();
        foreach (Transform child in transform) {
            avatarList.Add(child.GetComponent<AvatarContainerChild>());
        }
    }
}

using Photon.Pun;
using Photon.Realtime;

public class AvatarContainerChild : MonoBehaviourPunCallbacks
{
    public Player Owner => photonView.Owner;

    public override void OnEnable() {
        base.OnEnable();

        var container = FindObjectOfType<AvatarContainer>();
        transform.SetParent(container.transform);
    }
}

void IPunObservable.OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
    if (stream.IsWriting) 
    {
        // 自身が所有するオブジェクトのデータを送信する
        stream.SendNext(transform.localPosition);
        stream.SendNext(transform.localRotation);
        stream.SendNext(transform.localScale);
    } 
    else
    {
        // 他プレイヤーが所有するオブジェクトのデータを受信する
        transform.localPosition = (Vector3)stream.ReceiveNext();
        transform.localRotation = (Quaternion)stream.ReceiveNext();
        transform.localScale = (Vector3)stream.ReceiveNext();
    }
}

using Photon.Pun;
using UnityEngine;

public class RpcSample : MonoBehaviourPunCallbacks
{
    private void Update() 
    {
        if (Input.GetMouseButtonDown(0)) 
        {
            photonView.RPC(nameof(RpcSendMessage), RpcTarget.All, "こんにちは");
        }
    }

    [PunRPC]
    private void RpcSendMessage(string message, PhotonMessageInfo info) 
    {
        // メッセージを送信したプレイヤー名も表示する
        Debug.Log($"{info.Sender.NickName}: {message}");
    }
}

public void SpawnPlayer()
{
    GameObject player = Instantiate(PlayerPrefab);
    PhotonView photonView = player.GetComponent<PhotonView>();
    PhotonNetwork.AllocateViewID(photonView); // 手動でPhotonViewIDを割り当てる
}

using ExitGames.Client.Photon;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

public class CustomPropertiesCallbacksSample : MonoBehaviourPunCallbacks
{
    public override void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
    {
        // カスタムプロパティが更新されたプレイヤーのプレイヤー名とIDをコンソールに出力する
        Debug.Log($"{targetPlayer.NickName}({targetPlayer.ActorNumber})");

        // 更新されたプレイヤーのカスタムプロパティのペアをコンソールに出力する
        foreach (var prop in changedProps) {
            Debug.Log($"{prop.Key}: {prop.Value}");
        }
    }

    public override void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged) 
    {
        // 更新されたルームのカスタムプロパティのペアをコンソールに出力する
        foreach (var prop in propertiesThatChanged)
        {
            Debug.Log($"{prop.Key}: {prop.Value}");
        }
    }
}

int stageId = (PhotonNetwork.CurrentRoom.CustomProperties["StageId"] is int value) ? value : 0;

using ExitGames.Client.Photon;
using Photon.Realtime;

public static class PlayerPropertiesExtensions
{
    private const string ScoreKey = "Score";
    private const string MessageKey = "Message";

    private static readonly Hashtable propsToSet = new Hashtable();

    // プレイヤーのスコアを取得する
    public static int GetScore(this Player player) {
        return (player.CustomProperties[ScoreKey] is int score) ? score : 0;
    }

    // プレイヤーのメッセージを取得する
    public static string GetMessage(this Player player) {
        return (player.CustomProperties[MessageKey] is string message) ? message : string.Empty;
    }

    // プレイヤーのスコアを設定する
    public static void SetScore(this Player player, int score) {
        propsToSet[ScoreKey] = score;
        player.SetCustomProperties(propsToSet);
        propsToSet.Clear();
    }

    // プレイヤーのメッセージを設定する
    public static void SetMessage(this Player player, string message) {
        propsToSet[MessageKey] = message;
        player.SetCustomProperties(propsToSet);
        propsToSet.Clear();
    }
}

- int score = (PhotonNetwork.LocalPlayer.CustomProperties["Score"] is int value) ? value : 0;
+ int score = PhotonNetwork.LocalPlayer.GetScore();

- var hastable = new ExitGames.Client.Photon.Hashtable();
- hastable["Message"] = "こんにちは";
- PhotonNetwork.LocalPlayer.SetCustomProperties(hastable);
+ PhotonNetwork.LocalPlayer.SetMessage("こんにちは");

using System.Runtime.InteropServices;
using UnityEngine.SceneManagement;
using Photon.Pun;
using Photon.Realtime;
using Hashtable = ExitGames.Client.Photon.Hashtable;

public class CGameController : MonoBehaviourPunCallbacks
{
    // 一番最初に部屋に参加しようとすると失敗するので、失敗した時の処理(マスタークライアント)
    public override void OnJoinRandomFailed(short returnCode, string message)
    {
        RoomOptions roomOptions = new RoomOptions() { MaxPlayers = 20 };
        int stage_valiue = 0;
        string[] str = { "Game", "Candy", "Stage", "Fight" };
        int len = Mathf.Clamp(stage_valiue, 0, str.Length - 1);
        roomOptions.CustomRoomProperties = new ExitGames.Client.Photon.Hashtable()
        {
                { "RoomCreator",PhotonNetwork.NickName },
                { "StageName",str[len] },
                { "TimeText",0 },
                { "Timer",0 },
                { "TeamMemberText1", string.Empty },
                { "TeamMemberText2", string.Empty },
                { "TeamScoreText1", 0 },
                { "TeamScoreText2", 0 },
                { "ResultText", string.Empty },
        };
        //ロビーにカスタムプロパティの情報を表示させる
        roomOptions.CustomRoomPropertiesForLobby = new string[]
        {
                "RoomCreator","StageName","TimeText","Timer","TeamMemberText1","TeamMemberText2","TeamScoreText1","TeamScoreText2", "ResultText"
        };
        PhotonNetwork.CreateRoom(null, roomOptions, null);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System;
using Random = UnityEngine.Random;
using System.Runtime.InteropServices;
using UnityEngine.SceneManagement;
using Photon.Pun;
using Photon.Realtime;
using Hashtable = ExitGames.Client.Photon.Hashtable;    
public class CGameController : MonoBehaviourPunCallbacks
{
    void Update()
    {
        if (!PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom) return;

        if (!Finished)
        {
            Hashtable output_param = new Hashtable();
            if (output_param != null)
            {
                if (PhotonNetwork.CurrentRoom != null && PhotonNetwork.CurrentRoom.CustomProperties != null)
                {
                    output_param = PhotonNetwork.CurrentRoom.CustomProperties;
                }
            }
            if (PhotonNetwork.IsMasterClient)
            {
                string answer = string.Empty;
                System.TimeSpan t = System.TimeSpan.FromMinutes(Timer);

                answer = string.Format("{0:D2}:{1:D2}",
                                t.Hours,
                                t.Minutes);

                Timer -= Time.deltaTime;
                TimerText.text = answer;

                Hashtable input_param = new Hashtable();
                if (input_param != null)
                {
                    input_param["Timer"] = Timer;
                    input_param["TimerText"] = TimerText.text;
                }

                string player_name1 = string.Empty;
                string player_name2 = string.Empty;

                foreach (var player in PhotonNetwork.PlayerList)
                {
                    if (player.CustomProperties == null)
                    {
                        continue;
                    }
                    if (player.CustomProperties["TeamID"] == null)
                    {
                        continue;
                    }

                    if ((int)player.CustomProperties["TeamID"] == 0)
                    {
                        player_name1 += player.NickName + "\n";
                    }
                    else if ((int)player.CustomProperties["TeamID"] == 1)
                    {
                        player_name2 += player.NickName + "\n";
                    }
                }
                TeamMemberText1.text = player_name1;
                TeamMemberText2.text = player_name2;
                if (input_param != null)
                {
                    input_param["TeamMemberText1"] = player_name1;
                    input_param["TeamMemberText2"] = player_name2;
                    if (PhotonNetwork.CurrentRoom != null)
                    {
                        PhotonNetwork.CurrentRoom.SetCustomProperties(input_param);
                    }
                }
            }
            else
            {
                if (output_param != null)
                {
                    if (output_param["Timer"] != null)
                    {
                        Timer = (float)output_param["Timer"];
                    }
                    if (output_param["TimerText"] != null)
                    {
                        TimerText.text = output_param["TimerText"].ToString();
                    }
                    if (output_param["TeamMemberText1"] != null)
                    {
                        TeamMemberText1.text = output_param["TeamMemberText1"].ToString();
                    }
                    if (output_param["TeamMemberText2"] != null)
                    {
                        TeamMemberText2.text = output_param["TeamMemberText2"].ToString();
                    }
                }
            }
            if (output_param != null)
            {
                if (output_param["TeamScoreText1"] != null)
                {
                    if (output_param["TeamScoreText2"] != null)
                    {
                        TeamScoreText1.text = output_param["TeamScoreText1"].ToString();
                        TeamScoreText2.text = output_param["TeamScoreText2"].ToString();
                    }
                }
            }

            if (Timer < 0)
            {
                photonView.RPC("FinishGame", RpcTarget.All);
            }
        }
    }
}

using ExitGames.Client.Photon;
using UnityEngine;

public static class ColorSerializer
{
    private static readonly byte[] bufferColor = new byte[4];

    // カスタムタイプを登録するメソッド（起動時に一度だけ呼び出す）
    public static void Register() 
    {
        PhotonPeer.RegisterType(typeof(Color), 1, SerializeColor, DeserializeColor);
    }

    // Color型をバイト列に変換して送信データに書き込むメソッド
    private static short SerializeColor(StreamBuffer outStream, object customObject) 
    {
        Color32 color = (Color)customObject;
        lock (bufferColor) {
            bufferColor[0] = color.r;
            bufferColor[1] = color.g;
            bufferColor[2] = color.b;
            bufferColor[3] = color.a;
            outStream.Write(bufferColor, 0, 4);
        }
        return 4; // 書き込んだバイト数を返す
    }

    // 受信データからバイト列を読み込んでColor型に変換するメソッド
    private static object DeserializeColor(StreamBuffer inStream, short length) 
    {
        Color32 color = new Color32();
        lock (bufferColor) 
        {
            inStream.Read(bufferColor, 0, 4);
            color.r = bufferColor[0];
            color.g = bufferColor[1];
            color.b = bufferColor[2];
            color.a = bufferColor[3];
        }
        return (Color)color;
    }
}

using ExitGames.Client.Photon;
using UnityEngine;

public static class Vector2IntSerializer
{
    public static readonly byte[] bufferColor = new byte[4];
    public static readonly byte[] bufferVector2Int = new byte[8];

    public static void Register()
    {
        PhotonPeer.RegisterType(typeof(Color), 1, SerializeColor, DeserializeColor);
        PhotonPeer.RegisterType(typeof(Vector2Int), 2, SerializeVector2Int, DeserializeVector2Int);
    }

    // 省略

    private static short SerializeVector2Int(StreamBuffer outStream, object customObject) 
    {
        Vector2Int v = (Vector2Int)customObject;
        int index = 0;
        lock (bufferVector2Int) 
        {
            Protocol.Serialize(v.x, bufferVector2Int, ref index);
            Protocol.Serialize(v.y, bufferVector2Int, ref index);
            outStream.Write(bufferVector2Int, 0, index);
        }
        return (short)index;
    }

    private static object DeserializeVector2Int(StreamBuffer inStream, short length)
    {
        int x, y;
        int index = 0;
        lock (bufferVector2Int) 
        {
            inStream.Read(bufferVector2Int, 0, length);
            Protocol.Deserialize(out x, bufferVector2Int, ref index);
            Protocol.Deserialize(out y, bufferVector2Int, ref index);
        }
        return new Vector2Int(x, y);
    }
}

public static partial class MyProtocol
{
    public static void Serialize(byte value, byte[] target, ref int offset)
    {
        target[offset] = value;
        offset++;
    }

    public static void Deserialize(out byte value, byte[] source, ref int offset)
    {
        value = source[offset];
        offset++;
    }
}

using System;
using System.Net;

public static partial class MyProtocol
{
    private const int SizeDouble = sizeof(double);

    public static void Serialize(double value, byte[] target, ref int offset)
    {
        long host = BitConverter.DoubleToInt64Bits(value);
        long network = IPAddress.HostToNetworkOrder(host);
        byte[] bytes = BitConverter.GetBytes(network);
        Buffer.BlockCopy(bytes, 0, target, offset, SizeDouble);
        offset += SizeDouble;
    }

    public static void Deserialize(out double value, byte[] source, ref int offset)
    {
        long host = BitConverter.ToInt64(source, offset);
        long network = IPAddress.NetworkToHostOrder(host);
        value = BitConverter.Int64BitsToDouble(network);
        offset += SizeDouble;
    }
}

using System.Text;
using UnityEngine;

public static partial class MyProtocol
{
    // UTF-8でエンコード・デコードできない文字は空文字に置き換える設定にしておく
    private static readonly Encoding encoding = Encoding.GetEncoding(
        "utf-8",
        new EncoderReplacementFallback(string.Empty),
        new DecoderReplacementFallback(string.Empty)
    );

    public static void Serialize(string value, byte[] target, ref int offset)
    {
        int byteCount = encoding.GetBytes(value, 0, value.Length, target, offset + 1);
        byte size = (byte)Mathf.Min(byteCount, byte.MaxValue);
        target[offset] = size;
        offset += size + 1;
    }

    public static void Deserialize(out string value, byte[] source, ref int offset)
    {
        byte size = source[offset];
        value = encoding.GetString(source, offset + 1, size);
        offset += size + 1;
    }
}

using ExitGames.Client.Photon;
using Photon.Pun;
using Photon.Realtime;
using System.Collections.Generic;
using UnityEngine;
 
public class NetworkManager : MonoBehaviourPunCallbacks
{
 // Photonに接続した時
    public override void OnConnected()
    {
        Debug.Log("OnConnected");
 
        // ニックネームを付ける
        SetMyNickName("Knohhoso");
    }
 
    // Photonから切断された時
    public override void OnDisconnected(DisconnectCause cause)
    {
        Debug.Log("OnDisconnected");
    }
 
    // マスターサーバーに接続した時
    public override void OnConnectedToMaster()
    {
        Debug.Log("OnConnectedToMaster");
 
        // ロビーに入る
        JoinLobby();
    }
 
    // ロビーに入った時
    public override void OnJoinedLobby()
    {
        Debug.Log("OnJoinedLobby");
    }
 
    // ロビーから出た時
    public override void OnLeftLobby()
    {
        Debug.Log("OnLeftLobby");
    }
 
    // 部屋を作成した時
    public override void OnCreatedRoom()
    {
        Debug.Log("OnCreatedRoom");
    }
 
    // 部屋の作成に失敗した時
    public override void OnCreateRoomFailed(short returnCode, string message)
    {
        Debug.Log("OnCreateRoomFailed");
    }
 
    // 部屋に入室した時
    public override void OnJoinedRoom()
    {
        Debug.Log("OnJoinedRoom");
    }
 
    // 特定の部屋への入室に失敗した時
    public override void OnJoinRoomFailed(short returnCode, string message)
    {
        Debug.Log("OnJoinRoomFailed");
    }
 
    // ランダムな部屋への入室に失敗した時
    public override void OnJoinRandomFailed(short returnCode, string message)
    {
        Debug.Log("OnJoinRandomFailed");
    }
 
    // 部屋から退室した時
    public override void OnLeftRoom()
    {
        Debug.Log("OnLeftRoom");
    }
 
    // 他のプレイヤーが入室してきた時
    public override void OnPlayerEnteredRoom(Player newPlayer)
    {
        Debug.Log("OnPlayerEnteredRoom");
    }
 
    // 他のプレイヤーが退室した時
    public override void OnPlayerLeftRoom(Player otherPlayer)
    {
        Debug.Log("OnPlayerLeftRoom");
    }
 
    // マスタークライアントが変わった時
    public override void OnMasterClientSwitched(Player newMasterClient)
    {
        Debug.Log("OnMasterClientSwitched");
    }
 
    // ロビーに更新があった時
    public override void OnLobbyStatisticsUpdate(List<TypedLobbyInfo> lobbyStatistics)
    {
        Debug.Log("OnLobbyStatisticsUpdate");
    }
 
 
    // ルームリストに更新があった時
    public override void OnRoomListUpdate(List<RoomInfo> roomList)
    {
        Debug.Log("OnRoomListUpdate");
    }
 
    // ルームプロパティが更新された時
    public override void OnRoomPropertiesUpdate(ExitGames.Client.Photon.Hashtable propertiesThatChanged)
    {
        Debug.Log("OnRoomPropertiesUpdate");
    }
 
    // プレイヤープロパティが更新された時
    public override void OnPlayerPropertiesUpdate(Player target, ExitGames.Client.Photon.Hashtable changedProps)
    {
        Debug.Log("OnPlayerPropertiesUpdate");
    }
 
    // フレンドリストに更新があった時
    public override void OnFriendListUpdate(List<FriendInfo> friendList)
    {
        Debug.Log("OnFriendListUpdate");
    }
 
    // 地域リストを受け取った時
    public override void OnRegionListReceived(RegionHandler regionHandler)
    {
        Debug.Log("OnRegionListReceived");
    }
 
    // WebRpcのレスポンスがあった時
    public override void OnWebRpcResponse(OperationResponse response)
    {
        Debug.Log("OnWebRpcResponse");
    }
 
    // カスタム認証のレスポンスがあった時
    public override void OnCustomAuthenticationResponse(Dictionary<string, object> data)
    {
        Debug.Log("OnCustomAuthenticationResponse");
    }
 
    // カスタム認証が失敗した時
    public override void OnCustomAuthenticationFailed(string debugMessage)
    {
        Debug.Log("OnCustomAuthenticationFailed");
    }
}

// 入室時に呼ばれるコールバック
public override void OnJoinedRoom()
{
     //Mainシーンへ遷移
     PhotonNetwork.LoadLevel("Main");
}

//ルーム作成時の処理(作成者しか実行されない)
public override void OnCreatedRoom()
{
     //Mainシーンへ遷移
     PhotonNetwork.LoadLevel("Main");
}

int currentTime = PhotonNetwork.ServerTimestamp;

- if (PhotonNetwork.ServerTimestamp > endTime) {
+ if (unchecked(PhotonNetwork.ServerTimestamp - endTime) > 0) {
      Debug.Log("終了時刻を過ぎました");
  }