Lobby機能を使ってマルチプレイゲームへの参加準備をする[Unigy]

using UnityEngine;
using Unity.Services.Core;
using Unity.Services.Authentication;

public class LobbyManager : MonoBehaviour
{
    private string playerName;
    private async void Start()
    {
        playerName = "PlayerName" + Random.Range(0, 1000).ToString();
        InitializationOptions initializationOptions = new InitializationOptions();
        initializationOptions.SetProfile(playerName);

        await UnityServices.InitializeAsync(initializationOptions);

        AuthenticationService.Instance.SignedIn += () =>
        {
            Debug.Log("Signed in:" + AuthenticationService.Instance.PlayerId);
        };
        await AuthenticationService.Instance.SignInAnonymouslyAsync();
    }
}

using Unity.Services.Lobbies;
using Unity.Services.Lobbies.Models;

public class LobbyManager : MonoBehaviour
{
    private Lobby hostLobby;
    public async void CreateLobby()
    {
        try
        {
            string lobbyName = "TestLobby";
            int maxPlayers = 4;
            CreateLobbyOptions createLobbyOptions = new CreateLobbyOptions(){
                IsPrivate = false,
                Player = new Player(AuthenticationService.Instance.PlayerId){
                    Data = new Dictionary<string, PlayerDataObject>(){
                        {"PlayerName", new PlayerDataObject(PlayerDataObject.VisibilityOptions.Public,playerName)}
                    }
                }
            };

            hostLobby = await LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers ,createLobbyOptions );
            Debug.Log("Lobby created:" + hostLobby.LobbyCode);
        }
        catch (LobbyServiceException e)
        {
            Debug.Log("Exception:" + e.Message);
        }
    }
}

    private void Update()
    {
        if(Input.GetKeyDown(KeyCode.C))
        {
            if(hostLobby == null){
                CreateLobby();
            }
        }
    }

public class LobbyManager : MonoBehaviour
{
    private float heartbeatTimer;
    private float heatbeatInterval = 15f;

    private void Update()
    {
         RefreshLobbyHeatbeat();
    }

    private async void RefreshLobbyHeatbeat(){
        if (hostLobby != null)
        {
            heartbeatTimer += Time.deltaTime;
            if (heartbeatTimer > heatbeatInterval)
            {
                heartbeatTimer = 0.0f;
                await LobbyService.Instance.SendHeartbeatPingAsync(hostLobby.Id);
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Unity.Services.Lobbies.Models;
using System;

public class LobbyBanner : MonoBehaviour
{
    [SerializeField] private TextMeshProUGUI lobbyNameText;
    [SerializeField] private TextMeshProUGUI playerCountText;
    [SerializeField] private Button joinButton;

    public Lobby myLobby { get; private set; }
    public static EventHandler<Lobby> OnJoinLobby;

    public void Init(Lobby lobby){
        myLobby = lobby;
        lobbyNameText.text = lobby.Name;
        playerCountText.text = lobby.Players.Count.ToString() + "/" + lobby.MaxPlayers.ToString();
        joinButton.onClick.AddListener(() => {
            OnJoinLobby?.Invoke(this, myLobby);
            Debug.Log("JoinLobby LobbyID="+ myLobby.Id.ToString());
        });
    }
}

using System.Collections.Generic;
using Unity.Services.Lobbies.Models;
using UnityEngine;
using UnityEngine.UI;
using System;

public class LobbyListView : MonoBehaviour
{
    [SerializeField] private GameObject lobbyBannerPrefab;
    [SerializeField] private Transform lobbyListContent;
    [SerializeField] private Button refreshButton;

    public static EventHandler OnRefreshLobbyListRequest;

    private void Start()
    {
        refreshButton.onClick.AddListener(() => {
            OnRefreshLobbyListRequest?.Invoke(this, EventArgs.Empty);
        });
    }
    public void Refresh(List<Lobby> lobbyList)
    {
        foreach (Transform child in lobbyListContent)
        {
            Destroy(child.gameObject);
        }

        foreach (var lobby in lobbyList)
        {
            GameObject lobbyBanner = Instantiate(lobbyBannerPrefab, lobbyListContent);
            lobbyBanner.GetComponent<LobbyBanner>().Init(lobby);
        }
    }
}

public class LobbyManager : MonoBehaviour
{
    [SerializeField] private LobbyListView lobbyListView;
    private async void Start()
    {
        LobbyListView.OnRefreshLobbyListRequest += (sender, e) => {
            RefreshLobbies();
        };
    }

    private async void RefreshLobbies()
    {
        try
        {
            QueryResponse queryResponse = await Lobbies.Instance.QueryLobbiesAsync();
            Debug.Log("Lobbies Count:" + queryResponse.Results.Count);
            foreach (var lobby in queryResponse.Results)
            {
                Debug.Log($"Lobby:name {lobby.Name} id {lobby.Id} code {lobby.LobbyCode} maxPlayers {lobby.MaxPlayers}");
            }
            lobbyListView.Refresh(queryResponse.Results);
        }
        catch (LobbyServiceException e)
        {
            Debug.Log("Exception:" + e.Message);
        }
    }
}

public class LobbyManager : MonoBehaviour
{
    private async void Start()
    {
        LobbyBanner.OnJoinLobby += (sender, lobby) => {
            Debug.Log("JoinLobby LobbyID="+ lobby.Id.ToString());
            JoinLobby(lobby);
        };
    }

    private async void JoinLobby(Lobby lobby)
    {
        try
        {
            JoinLobbyByIdOptions options = new JoinLobbyByIdOptions(){
                Player = new Player(AuthenticationService.Instance.PlayerId){
                    Data = new Dictionary<string, PlayerDataObject>(){
                        {"PlayerName", new PlayerDataObject(PlayerDataObject.VisibilityOptions.Public,playerName)}
                    }
                },
            };
            hostLobby = await LobbyService.Instance.JoinLobbyByIdAsync(lobby.Id,options);
            Debug.Log("Lobby joined:" + hostLobby.Id);
        }
        catch (LobbyServiceException e)
        {
            Debug.Log("Exception:" + e.Message);
        }
    }
}