未発表パーティゲーム MultiplayerMenu.cs

using UnityEngine;

using Fusion;

using TMPro;

using System.Collections;

using System.Collections.Generic;

using System.Threading.Tasks;

using UnityEngine.EventSystems;

using PartyGame.UI;

using PartyGame.GameManagement;

using Zenject;

using PartyGame.Audio;

using UnityEngine.SceneManagement;

using PartyGame.Config;

using Fusion.Sockets;

using System;

namespace PartyGame.Multiplayer

{

    public class MultiplayerMenu : MonoBehaviour, INetworkRunnerCallbacks

    {

        private const string TOURNAMENT_SCENE_NAME = "TournamentScene";

        private const int ROOM_CODE_LENGTH = 6;

        private const int PLAYER_COUNT = 4;

        [SerializeField] private NetworkRunner _networkRunnerPrefab;

        [SerializeField] private GameObject _loadingObject;

        [SerializeField] private GameObject _panel;

        [SerializeField] private TMP_InputField _inputField;

        [SerializeField] private TMP_Text _errorText;

        [SerializeField] private TMP_Text _searchText;

        [Header("Buttons")]

        [SerializeField] private LTSButton _defaultSelectedButton;

        [SerializeField] private LTSButton _achievementsButton;

        [SerializeField] private LTSButton _hostButton;

        [SerializeField] private LTSButton _joinButton;

        [SerializeField] private LTSButton _localPlayButton;

        [SerializeField] private LTSButton _settingsButton;

        [SerializeField] private LTSButton _storeButton;

        [SerializeField] private LTSButton _quitButton;

        [SerializeField] private LTSButton _joinCancelButton;

        [Header("Submenus")]

        [SerializeField] private SettingsMenuUI _settingsMenuUI;

        [SerializeField] private GameObject _tutorialScreen;

        [Inject] private SceneLoader _sceneLoader;

        private NetworkRunner _networkRunner;

        private EventSystem _eventSystem;

        private bool _isStarting = false;

        private void Start()

        {

            Application.targetFrameRate = ApplicationConfig.Instance.GameConfig.settings.targetFPS;

            _panel.SetActive(true);

            _loadingObject.SetActive(false);

            _inputField.characterValidation = TMP_InputField.CharacterValidation.Alphanumeric;

            _inputField.onValidateInput += ValidateJoinCode;

            _eventSystem = EventSystem.current;

            _eventSystem.SetSelectedGameObject(_defaultSelectedButton.gameObject);

            _localPlayButton.Initialize(StartOffline);

            _hostButton.Initialize(StartHost);

            _joinButton.Initialize(StartClient);

            _settingsButton.Initialize(OpenSettings);

            _quitButton.Initialize(Application.Quit);

            _storeButton.Initialize(OpenStore);

            _achievementsButton.Initialize(OpenAchievements);

            AudioManager.Instance.PlayMusic(MusicType.MainMenu_BackgroundMusic);

        }

        private void StartHost()

        {

            string roomCode = RoomCode.Create(ROOM_CODE_LENGTH);

            _searchText.text = "Starting game...";

            _joinCancelButton.gameObject.SetActive(false);

            StartGame(GameMode.Host, roomCode);

        }

        private void StartClient()

        {

            string _roomCode = _inputField.text;

            if (_roomCode == null || _roomCode.Length <= 0)

            {

                StartCoroutine(StartRandom());

                return;

            }

            if (_roomCode.Length != ROOM_CODE_LENGTH)

            {

                _errorText.text = "Please enter a room code of length: " + ROOM_CODE_LENGTH;

                return;

            }

            _searchText.text = "Searching for game...";

            _joinCancelButton.gameObject.SetActive(true);

            StartGame(GameMode.Client, _roomCode, true);

        }

        private void StartOffline()

        {

            string roomCode = RoomCode.Create(ROOM_CODE_LENGTH);

            _searchText.text = "Starting game...";

            _joinCancelButton.gameObject.SetActive(false);

            StartGame(GameMode.Single, roomCode);

        }

        private IEnumerator StartRandom()

        {

            _networkRunner = FindObjectOfType<NetworkRunner>();

            if (_networkRunner == null)

            {

                _networkRunner = Instantiate(_networkRunnerPrefab);

            }

            _networkRunner.AddCallbacks(this);

            // Let the Fusion Runner know that we will be providing user input

            _networkRunner.ProvideInput = true;

            _searchText.text = "Searching for game...";

            _panel.SetActive(false);

            _loadingObject.SetActive(true);

            Task<StartGameResult> task = _networkRunner.JoinSessionLobby(SessionLobby.ClientServer);

            while (!task.IsCompleted)

            {

                yield return null;

            }

            StartGameResult result = task.Result;

            if (result.Ok)

            {

                Debug.Log("Successfully joined lobby");

            }

            else

            {

                //error message

                _errorText.text = result.ShutdownReason.ToString();

                _panel.SetActive(true);

                _loadingObject.SetActive(false);

            }

        }

        public void OnSessionListUpdated(NetworkRunner runner, List<SessionInfo> sessionList)

        {

            Debug.Log($"Session List Updated with {sessionList.Count} session(s)");

            if (sessionList.Count == 0)

            {

                return;

            }

            bool isSessionFound = false;

            string session = "";

            string version = Application.version.ToString();

            int i = 0;

            while (!isSessionFound)

            {

                if (sessionList[i].IsOpen && sessionList[i].Properties["Version"] == version)

                {

                    session = sessionList[i].Name;

                    isSessionFound = true;

                }

                else

                {

                    i++;

                    isSessionFound = i >= sessionList.Count;

                }

            }

            if (session == "")

            {

                return;

            }

            _searchText.text = "Joining game...";

            StartGame(GameMode.Client, session, true);

        }

        public void CancelJoin()

        {

            if (_isStarting)

            {

                //things might get messed up if we try to cancel while joining

                return;

            }

            //error message

            _errorText.text = "No games to join";

            _panel.SetActive(true);

            _loadingObject.SetActive(false);

            _networkRunner.RemoveCallbacks(this);

            Destroy(_networkRunner.gameObject);

        }

        /// <summary>

        /// GameMode.Host = Start a session with a specific name

        /// GameMode.Client = Join a session with a specific name

        /// GameMode.Single = Local play only

        /// </summary>

        /// <param name="gameMode"></param>

        private void StartGame(GameMode gameMode, string roomCode, bool disableClientSessionCreation = false)

        {

            _isStarting = true;

            _joinCancelButton.gameObject.SetActive(false);

            //need a runner to do anything with fusion, so if 

            //there isn't one, make one

            _networkRunner = FindObjectOfType<NetworkRunner>();

            if (_networkRunner == null)

            {

                _networkRunner = Instantiate(_networkRunnerPrefab);

            }

            // Let the Fusion Runner know that we will be providing user input

            _networkRunner.ProvideInput = true;

            _networkRunner.RemoveCallbacks(this);

            Dictionary<string, SessionProperty> properties = new();

            properties.Add("Version", Application.version.ToString());

            StartGameArgs startGameArgs = new StartGameArgs()

            {

                GameMode = gameMode,

                SessionName = roomCode,

                PlayerCount = PLAYER_COUNT,

                DisableClientSessionCreation = disableClientSessionCreation,

                SessionProperties = properties

            };

            //need something to explain unable to connect

            StartCoroutine(AttemptStartGame(startGameArgs));

        }

        private IEnumerator AttemptStartGame(StartGameArgs startGameArgs)

        {

            _panel.SetActive(false);

            _loadingObject.SetActive(true);

            Task<StartGameResult> task = _networkRunner.StartGame(startGameArgs);

            while (!task.IsCompleted)

            {

                yield return null;

            }

            StartGameResult result = task.Result;

            if (result.Ok)

            {

                yield return ShowTutoritalScreen(5.0f);

                int tournamentSceneIndex = FindSceneBuildIndex(TOURNAMENT_SCENE_NAME);

                _networkRunner.SetActiveScene(tournamentSceneIndex);

            }

            else

            {

                //error message

                _errorText.text = result.ShutdownReason.ToString();

                _panel.SetActive(true);

                _loadingObject.SetActive(false);

                Destroy(_networkRunner.gameObject);

            }

        }

        private IEnumerator ShowTutoritalScreen(float time)

        {

            _tutorialScreen.SetActive(true);

            yield return new WaitForSeconds(time);

        }

        private void OpenSettings()

        {

            _settingsMenuUI.Show();

        }

        private void OpenStore()

        {

            throw new System.Exception("Not implemented");

        }

        private void OpenAchievements()

        {

            throw new System.Exception("Not implemented");

        }

        private char ValidateJoinCode(string text, int charIndex, char character)

        {

            if (text.Length >= ROOM_CODE_LENGTH)

            {

                return '\0';

            }

            character = char.IsLetter(character) ? char.ToUpper(character) : character;

            return character;

        }

        private int FindSceneBuildIndex(string sceneName)

        {

            int sceneCount = SceneManager.sceneCountInBuildSettings;

            for (int i = 0; i < sceneCount; i++)

            {

                string path = SceneUtility.GetScenePathByBuildIndex(i);

                if (path.Contains(sceneName))

                {

                    return i;

                }

            }

            return -1;

        }

        public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)

        {

            throw new NotImplementedException();

        }

        public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)

        {

            throw new NotImplementedException();

        }

        public void OnInput(NetworkRunner runner, NetworkInput input)

        {

            throw new NotImplementedException();

        }

        public void OnInputMissing(NetworkRunner runner, PlayerRef player, NetworkInput input)

        {

            throw new NotImplementedException();

        }

        public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason)

        {

            Debug.Log("Shutting down network Runner.");

        }

        public void OnConnectedToServer(NetworkRunner runner)

        {

            throw new NotImplementedException();

        }

        public void OnDisconnectedFromServer(NetworkRunner runner)

        {

            throw new NotImplementedException();

        }

        public void OnConnectRequest(NetworkRunner runner, NetworkRunnerCallbackArgs.ConnectRequest request, byte[] token)

        {

            throw new NotImplementedException();

        }

        public void OnConnectFailed(NetworkRunner runner, NetAddress remoteAddress, NetConnectFailedReason reason)

        {

            throw new NotImplementedException();

        }

        public void OnUserSimulationMessage(NetworkRunner runner, SimulationMessagePtr message)

        {

            throw new NotImplementedException();

        }

        public void OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data)

        {

            throw new NotImplementedException();

        }

        public void OnHostMigration(NetworkRunner runner, HostMigrationToken hostMigrationToken)

        {

            throw new NotImplementedException();

        }

        public void OnReliableDataReceived(NetworkRunner runner, PlayerRef player, ArraySegment<byte> data)

        {

            throw new NotImplementedException();

        }

        public void OnSceneLoadDone(NetworkRunner runner)

        {

            throw new NotImplementedException();

        }

        public void OnSceneLoadStart(NetworkRunner runner)

        {

            throw new NotImplementedException();

        }

    }

}