Google Play 앱 링크

https://play.google.com/store/apps/details?id=com.TORI_COMPANY.MonochromeBall

QR CODE

플레이 영상

Google Play 앱 업데이트

앱이 시작되면 Google Play 앱에 최신 버전의 유무를 확인하여 업데이트를 확인

Google Play Games를 이용하여 리더보드 적용

게임이 종료되면 자동으로 리더보드를 업데이트

The post MonochromeBall(Android) appeared first on 어제와 내일의 나 그 사이의 이야기.

Version : Unity 2021.3.5f1

Photon Chat은 PUN2 에 포함되어 있다.

처음 접속을 하면 로비로 이동하여 Room목록을 확인

Room에 접속하면 자동으로 채팅 및 음성이 연결되는 구조

포톤 기능 RND 목적으로 간단하게 만든 앱이라서 발생할 수 있는 모든 문제를 해결하지 않음

(예를 들어 채팅중 네트워크 오류, 입장 불가 등… )

무료 라이센스라서 20명 이상 동시 접속 시 터질 수 있음

Photon PUN2 + Chat

APP.CS

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.IO;
using Newtonsoft.Json;


namespace Com.Lycos7560
{
    public struct PlayerData
    {
        public string NickName;
        public string UserGuid;
        public PlayerData(string _nicknName, string _userGuid = null)
        {
            NickName = _nicknName;
            UserGuid = _userGuid;
        }
    }

    public class APP : SingletonMonobehaviour<APP>
    {

        protected override void Awake()
        {
            base.Awake();
            if (CheckPlayerData()) {
                PlayerPrefs.DeleteAll();
                LoadPlayerNickName();
            }
            else {
                PlayerPrefs.DeleteAll();
                PlayerPrefs.SetString("NickName", string.Empty);
                PlayerPrefs.SetString("UserGuid", Guid.NewGuid().ToString());
                SavePlayerNickName();
            }
        }

        // 로컬에 데이터가 존재하는지 확인 
        private bool CheckPlayerData()
        {
            bool exists = File.Exists(Application.persistentDataPath + "/PlayerInfo.json");
            if (exists) Debug.Log("Existing User");
            else Debug.Log("NewUser");
            return exists;
        }

        // 플레이어의 정보를 로컬에 저장
        public void SavePlayerNickName()
        {
            PlayerData _PlayerData = new (PlayerPrefs.GetString("NickName"), PlayerPrefs.GetString("UserGuid"));
            var json = JsonConvert.SerializeObject(_PlayerData);
            File.WriteAllText(Application.persistentDataPath + "/PlayerInfo.json", json);
        }

        // 로컬에 저장된 플레이어의 정보를 불러온다.
        public void LoadPlayerNickName()
        {
            var _Json = File.ReadAllText(Application.persistentDataPath + "/PlayerInfo.json");
            var _Info = JsonConvert.DeserializeObject<PlayerData>(_Json);
            PlayerPrefs.SetString("NickName", _Info.NickName);
            PlayerPrefs.SetString("UserGuid", _Info.UserGuid);
        }
    }
}

Connection.CS

using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Photon.Pun;
using Photon.Realtime;

namespace Com.Lycos7560
{
    public class Connection : MonoBehaviourPunCallbacks
    {
        public GameObject _ConnetMain;

        public TMP_InputField _InputFieldName;

        public CanvasGroup ConnetGroup;
        public Button ConnetBTN;

        public TMP_Text ConnectionStatusText;

        public override void OnEnable()
        {
            if (PlayerPrefs.GetString("NickName") != string.Empty)
                _InputFieldName.text = PlayerPrefs.GetString("NickName");
            else _InputFieldName.text = string.Empty;
            

        }


        private void Awake()
        {
            _InputFieldName.onValueChanged.AddListener((_value) =>
            {
                if (_value.Length > 0 || _value != string.Empty)
                {
                    ConnetGroup.alpha = 1f;
                    ConnetGroup.interactable = true;
                    ConnetGroup.blocksRaycasts = true;
                }
                else
                {
                    ConnetGroup.alpha = 0.3f;
                    ConnetGroup.interactable = false;
                    ConnetGroup.blocksRaycasts = false;
                }
            });

            ConnetBTN.onClick.AddListener(() => {
                ConnetGroup.alpha = 0.3f;
                ConnetGroup.interactable = false;
                ConnetGroup.blocksRaycasts = false;
                _InputFieldName.interactable = false;
                PlayerPrefs.SetString("NickName", _InputFieldName.text);
                APP.Instance.SavePlayerNickName();
                ConnectionStatusText.text = "Connecting . . .";
                NetworkManager.Instance.Connect();
            });

            _ConnetMain.SetActive(true);
        }

        private void Start()
        {
            NetworkManager.Instance.OnDisconnectedAction += ConnectionOnDisconnected;
            NetworkManager.Instance.OnJoinedLobbyAction += ConnectionOnJoinedLobby;
            NetworkManager.Instance.OnChangeNetworkClientState += OnChangeNetworkClientState;

            if (PlayerPrefs.GetString("NickName") != string.Empty)
                _InputFieldName.text = PlayerPrefs.GetString("NickName");
            else _InputFieldName.text = string.Empty;
        }

        // 액션 등록
        private void ConnectionOnJoinedLobby()
        {
            Debug.Log("Connet OnJoinedLobby()");
            _ConnetMain.SetActive(false);

        }

        // 액션 등록
        public void ConnectionOnDisconnected()
        {
            Debug.Log("연결 종료");
            _ConnetMain.SetActive(true);
            ConnetGroup.alpha = 1f;
            ConnetGroup.interactable = true;
            ConnetGroup.blocksRaycasts = true;
            _InputFieldName.interactable = true;
            _InputFieldName.text = PlayerPrefs.GetString("NickName");
        }


        private void OnChangeNetworkClientState(ClientState _clientState)
        {
            ConnectionStatusText.text = _clientState.ToString();
        }
    }
}

Lobby.CS

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Photon.Pun;
using Photon.Realtime;

namespace Com.Lycos7560
{
    public class Lobby : MonoBehaviourPunCallbacks
    {
        public GameObject _LobbyMain;
        public Button _ExitBtn;
        public Button _CreateRoomBtn;
        public TMP_Text LobbyPeopleCountText;

        public Transform _Content;

        public List<TypedLobbyInfo> _LobbyInfoList;

        public GameObject RoomItemPrefab;
        private List<RoomItem> _RoomItemList = new();

        private TypedLobby _CntLobby => PhotonNetwork.CurrentLobby;
        private List<RoomInfo> _CntRoomList;

        private Dictionary<string, RoomInfo> _SachedRoomList = new();
        private Coroutine _LobbyCoroutine;

        public GameObject _RoomJoinPopUp;
        public Button _PopUpCloseBtn;
        public TMP_Text _RoomJoinFailText;

        private void Awake()
        {
          
            _ExitBtn.onClick.AddListener(() => {
                NetworkManager.Instance.DisconnectMainServer();
            });

            _CreateRoomBtn.onClick.AddListener(() => {
                _RoomJoinPopUp.SetActive(true);
                NetworkManager.Instance.CreateRoomWithNickName(false); 
            });

            _PopUpCloseBtn.onClick.AddListener(() => {
                _RoomJoinPopUp.SetActive(false);
            });

            for (int i = 0; i < 20; i++)
            {
                RoomItem _RoomItem = Instantiate<GameObject>(RoomItemPrefab, _Content).GetComponent<RoomItem>();
                _RoomItem.ChangeRoomInfo("Defalut", 0, 0);
                _RoomItemList.Add(_RoomItem);
                _RoomItemList[i].gameObject.SetActive(false);
                _RoomItem.JoinRoomBtn.onClick.AddListener(() => {
                    _RoomJoinPopUp.SetActive(true);
                    _RoomJoinFailText.text = "Try to access the chat room.";
                    _PopUpCloseBtn.gameObject.SetActive(false);
                    NetworkManager.Instance.JoinRoom(_RoomItem.RoomName.text);
                });
            }

            _LobbyMain.SetActive(false);
        }

        private void Start()
        {
            // 액션 등록
            NetworkManager.Instance.OnDisconnectedAction += LobbyOnDisconnected;
            NetworkManager.Instance.OnJoinedLobbyAction += LobbyOnJoinedLobby;
            NetworkManager.Instance.OnJoinRoomFailedAction += LobbyOnJoinRoomFailed;
            NetworkManager.Instance.OnJoinedRoomAction += LobbyOnJoinedRoom;
            NetworkManager.Instance.OnLeftRoomAction += LobbyOnLeftRoom;
        }



        #region ActionFuctions

        private void LobbyOnJoinedLobby()
        {
            _LobbyMain.SetActive(true);

            _RoomJoinFailText.text = "Attempt to connect . . .";
            _PopUpCloseBtn.gameObject.SetActive(false);
            _SachedRoomList.Clear();

            if (_LobbyCoroutine != null)
            {
                StopCoroutine(_LobbyCoroutine);
                _LobbyCoroutine = null;
            }
            _LobbyCoroutine = StartCoroutine(UpdateLobbyCoroutine());

            LobbyPeopleCountText.text = string.Format($"Lobby People Count : {PhotonNetwork.CountOfPlayersOnMaster}");
        }

        private void LobbyOnDisconnected()
        {
            if (_LobbyCoroutine != null)
                StopCoroutine(_LobbyCoroutine);
            _LobbyCoroutine = null;
            _LobbyMain.SetActive(false);
        }

        private void LobbyOnJoinedRoom()
        {
            _RoomJoinPopUp.SetActive(true);
            _RoomJoinFailText.text = "Attempt to connect . . .";
            _PopUpCloseBtn.gameObject.SetActive(false);
            _LobbyMain.SetActive(false);

            if (_LobbyCoroutine != null) 
                StopCoroutine(_LobbyCoroutine);
            _LobbyCoroutine = null;
        }

        private void LobbyOnLeftRoom()
        {
            _LobbyMain.SetActive(true);
            _RoomJoinFailText.text = "Attempt to connect . . .";
            _PopUpCloseBtn.gameObject.SetActive(false);
            _SachedRoomList.Clear();

            if (_LobbyCoroutine != null) {
                StopCoroutine(_LobbyCoroutine);
                _LobbyCoroutine = null;
            }
            _LobbyCoroutine = StartCoroutine(UpdateLobbyCoroutine());
            UpdateLobbyRoomList();
        }

        private void LobbyOnJoinRoomFailed(short returnCode, string message)
        {
            PhotonNetwork.JoinLobby(_CntLobby);
            _RoomJoinPopUp.SetActive(true);
            _PopUpCloseBtn.gameObject.SetActive(true);
            _RoomJoinFailText.text = string.Format($"returnCode : {returnCode} ,  {message}");
            UpdateLobbyRoomList();
        }

        #endregion


        #region  MonoBehaviourPunCallbacks
        public override void OnRoomListUpdate(List<RoomInfo> roomList)
        {
            _CntRoomList = roomList;
            UpdateLobbyRoomList();
        }

        public override void OnCreatedRoom()
        {
            // 카운트 리셋
            NetworkManager.Instance.CreateRoomWithNickName(true);
        }


        public override void OnCreateRoomFailed(short returnCode, string message)
        {
            NetworkManager.Instance.CreateRoomWithNickName(false);
        }


        #endregion



        /// <summary>
        /// 일정 시간마다 로비에 Room과 있는 로비 인원을 업데이트
        /// 목적이 Chatting을 사용 가능할 때까지 대기 
        /// </summary>
        private IEnumerator UpdateLobbyCoroutine()
        {
            yield return new WaitUntil(() => NetworkManager.Instance._ChatClient != null && NetworkManager.Instance._ChatClient.CanChat);
            _RoomJoinPopUp.SetActive(false);
            _PopUpCloseBtn.gameObject.SetActive(true);

            WaitForSeconds _Delay = new WaitForSeconds(10f);
            yield return _Delay;

            while (true)
            {
                LobbyPeopleCountText.text = string.Format($"Lobby People Count : {PhotonNetwork.CountOfPlayersOnMaster}");
                PhotonNetwork.JoinLobby(_CntLobby);
                UpdateLobbyRoomList();
                yield return _Delay;
                if (_LobbyMain.activeSelf == false) break;
            }

            _LobbyCoroutine = null;
        }

        private void UpdateLobbyRoomList()
        {
            for (int i = 0; i < _CntRoomList.Count; i++)
            {
                RoomInfo info = _CntRoomList[i];
                if (info.RemovedFromList) _SachedRoomList.Remove(info.Name);
                else _SachedRoomList[info.Name] = info;
            }

            for (int j = 0; j < _RoomItemList.Count; j++)
            {
                _RoomItemList[j].gameObject.SetActive(false);
                _RoomItemList[j].ChangeRoomInfo("Defalut", 0, 0);
            }

            for (int j = 0; j < _CntRoomList.Count; j++)
            {
                RoomInfo info = _CntRoomList[j];
                if (info.PlayerCount == 0) continue;
                _RoomItemList[j].gameObject.SetActive(true);
                _RoomItemList[j].ChangeRoomInfo(info.Name, info.PlayerCount, info.MaxPlayers);
            }
        }


    }
}

Chatting.CS

using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Photon.Pun;
using Photon.Chat;
using ExitGames.Client.Photon;

namespace Com.Lycos7560
{
    public class Chatting : MonoBehaviourPunCallbacks, IChatClientListener
    {
        public ChatClient _ChatClient;

        public GameObject ChattingMain;

        public Button _CloseChattingMainBtn;

        public TMP_Text _ServerStateText;

        public TMP_InputField _ChatInputField;

        public Button _ChatSendBtn;

        public TMP_Text _ChattingContentText;
        public TMP_Text SubscribeUsersText;

        public ChatChannel _CntChatChannel;

        #region IChatClientListener CallBacks

        public void OnGetMessages(string channelName, string[] senders, object[] messages)
        {
            for (int i = 0; i < senders.Length; i++)
            {
                string sender = senders[i];
                string message = messages[i].ToString();

                string chatMessage = $"[{sender}]: {message}";

                // 채팅 메시지 추가
                _ChattingContentText.text += chatMessage + "\n";
            }
        }

        // 개인 메시지(귓속말) 미구현
        public void OnPrivateMessage(string sender, object message, string channelName)
        {
            Debug.Log("Private message from [" + sender + "]: " + message);
        }

        // 접속한 Room의 이름과 관련된 채널 구독이 성공 CallBack
        public void OnSubscribed(string[] channels, bool[] results)
        {
            _ChattingContentText.text = string.Empty;
            // 채널을 캐싱해준다. (구독 완료된 시점)
            if (_ChatClient.TryGetChannel("Room_" + PhotonNetwork.CurrentRoom.Name, out _CntChatChannel))  

            // 나가기 버튼 활성화
            _CloseChattingMainBtn.gameObject.SetActive(true); 

            // 첫 화면 출력
            _ChattingContentText.text += " Welcome to Photon Chat. \n";
            UpdateSubscribeUsersText();
            /* 디버깅
            for (int i = 0; i < channels.Length; i++)
                Debug.Log("Subscribed to Channel: " + channels[i]); 
            */
        }

        // 접속한 Room의 이름과 관련된 채널 구독을 해제 CallBack
        public void OnUnsubscribed(string[] channels)
        {
            // 구독 해제와 동시에 Clear
            _ChattingContentText.text = string.Empty;
            _CntChatChannel = null;
            /* 디버깅
            for (int i = 0; i < channels.Length; i++)
                Debug.Log("Unsubscribed from Channel: " + channels[i]);
            */
        }

        // 디버그 CallBack 미구현
        public void DebugReturn(DebugLevel level, string message)
        {
            Debug.Log("Debug: " + level + " - " + message);
        }

        // 디버그 CallBack 미구현
        public void OnDisconnected()
        {
            Debug.Log("Disconnected from Chat Server");
        }

        // 디버그 CallBack 미구현
        public void OnChatStateChange(ChatState state)
        {
            _ServerStateText.text = string.Format($"Server State : {state}");
        }

        // 디버그 CallBack 미구현
        public void OnStatusUpdate(string user, int status, bool gotMessage, object message)
        {
            Debug.Log("Status Update - User: " + user + ", Status: " + status);
        }

        //  어떤 유저가 해당 채널을 구독 CallBack
        public void OnUserSubscribed(string channel, string user)
        {
            // 메시지 창에 어떤 유저가 구독했는지 출력
            string message = $"<color=#06FF00>'{user}' has joined '{channel}'</color>";
            _ChattingContentText.text += message + "\n";
            UpdateSubscribeUsersText();
        }

        //  어떤 유저가 해당 채널을 구독 해제 CallBack
        public void OnUserUnsubscribed(string channel, string user)
        {
            // 메시지 창에 어떤 유저가 구독을 해제했는지 출력
            string message = $"<color=#FF0000> '{user}' has left '{channel}'</color>";
            _ChattingContentText.text += message + "\n";
            UpdateSubscribeUsersText();
        }


        #endregion


        #region MonoBehaviour

        private void Awake()
        {         
            ChattingMain.SetActive(false);
            _CloseChattingMainBtn.onClick.AddListener(() => { 
                  PhotonNetwork.LeaveRoom();
            });
            _ChatSendBtn.onClick.AddListener(() => {
                if (_ChatInputField.text == string.Empty) return;
                else {
                    SendRoomMessage(_ChatInputField.text);
                    _ChatInputField.text = string.Empty;
                }
            });
        }

        private void Start()
        {
            // 액션 등록
            NetworkManager.Instance.OnJoinedRoomAction += ChattingOnJoinedRoom;
            NetworkManager.Instance.OnLeftRoomAction += ChattingOnLeftRoom;
            NetworkManager.Instance.OnJoinedLobbyAction += ChattingOnJoinedLobby;
        }

        private void Update()
        {
            // !!필수!!
            // ChatClient의 콜백 처리를 위해 주기적으로 호출
            if (_ChatClient != null)
                _ChatClient.Service();
        }

        #endregion



        #region ActionFuctions

        /// <summary>
        /// 로비에 접속하면 Chatting Server를 활성화 시킨다.
        /// </summary>
        private void ChattingOnJoinedLobby()
        {
            // 구독 전에 나가는 것을 방지
            _CloseChattingMainBtn.gameObject.SetActive(false); 

            if (_ChatClient == null) {
                // 로비에 접속한 후 ChatClient 초기화 및 연결
                _ChatClient = new ChatClient(this);
                _ChatClient.Connect(PhotonNetwork.PhotonServerSettings.AppSettings.AppIdChat, PhotonNetwork.AppVersion, new Photon.Chat.AuthenticationValues(PhotonNetwork.NickName));
                Debug.LogFormat($"Chatting Server 초기화 및 연결 시작");
            }
        }

        /// <summary>
        ///  Room에 접속하면 실행되는 함수
        ///  Room의 이름과 관련된 채팅 서버에 접속한다.
        /// </summary>
        private void ChattingOnJoinedRoom()
        {
            _ChattingContentText.text = string.Empty;
            ChattingMain.SetActive(true);
            string _Channel = "Room_" + PhotonNetwork.CurrentRoom.Name; // 가입할 채널 이름 배열
            _ChatClient.Subscribe(_Channel, 0, -1, new ChannelCreationOptions { PublishSubscribers = true } ); // 채널에 구독
            Debug.LogFormat($"{"Room_" + PhotonNetwork.CurrentRoom.Name} :: 구독");

        }

        /// <summary>
        /// Room에서 나갈 경우 실행되는 함수
        /// </summary>
        private void ChattingOnLeftRoom()
        {
            string[] _Channels = new string[] { _CntChatChannel.Name };
            _ChatClient.Unsubscribe(_Channels);
            _CntChatChannel = null;
            ChattingMain.SetActive(false);
        }

        #endregion

        /// <summary>
        /// 구독한 Channel에 메시지를 보냅니다.
        /// </summary>
        /// <param name="message"></param>
        private void SendRoomMessage(string message)
        {
            if (_ChatClient != null && _ChatClient.CanChat) {
                //  _ChatClient가 구독한 방에 메시지를 보냅니다.
                _ChatClient.PublishMessage("Room_" + PhotonNetwork.CurrentRoom.Name, message);
            }
        }

        /// <summary>
        /// 체널의 있는 유저들의 정보를 갱신합니다.
        /// </summary>
        private void UpdateSubscribeUsersText()
        {
            if (_ChatClient != null && _CntChatChannel != null) {
                var _Users = _CntChatChannel.Subscribers;
                SubscribeUsersText.text = string.Empty;
                foreach (var _user in _Users)
                    SubscribeUsersText.text += _user + "  ";               
            }
            else SubscribeUsersText.text = "There is a problem with the network.";
           
        }
    }






}

NetworkManager.CS

using UnityEngine;
using UnityEngine.Events;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using Photon.Chat;

namespace Com.Lycos7560
{
    public class NetworkManager : MonoBehaviourPunCallbacks
    {
        public static NetworkManager Instance;

        public Connection _Connection;
        public Chatting _Chatting;
        public Lobby _Lobby;


        public ChatClient _ChatClient { get { return _Chatting._ChatClient; } }

        #region Private Serializable Fields
        #endregion

        #region Private Fields

        /// <summary>
        /// 이 클라이언트의 버전 번호입니다.
        /// 사용자는 gameVersion에 의해 서로 분리되어 있습니다 
        /// (이를 통해 변경 사항을 변경할 수 있습니다).
        /// </summary>
        string gameVersion = "1";

        /// <summary>
        /// 룸당 최대 플레이어 수입니다. 
        /// 방이 꽉 차면 새로운 플레이어가 참여할 수 없기 때문에 새로운 방이 만들어집니다.
        /// </summary>
        [Tooltip("방이 꽉 차면 새로운 플레이어가 참여할 수 없기 때문에 새로운 방이 만들어집니다.")]
        [SerializeField]
        private byte maxPlayersPerRoom = 5;


        /// <summary>
        /// 현재 NetworkClientState의 상태를 나타냅니다.
        /// </summary>
        [Tooltip("현재 NetworkClientState의 상태를 나타냅니다. NetworkClientStateCheck 함수를 통하여 업데이트 됩니다")]
        [SerializeField]
        private ClientState _CntNetworkClientState = ClientState.PeerCreated;

        public ClientState CntNetworkClientState
        {
            get => _CntNetworkClientState;
            set
            {
                if (_CntNetworkClientState != value)
                    OnChangeNetworkClientState?.Invoke(value);
                _CntNetworkClientState = value;
            }
        }

        [Tooltip("방생성을 시도한 횟수입니다.")]
        [SerializeField]
        private int _CreateRoomCnt = 1;

        #endregion

        #region public Fields

        #endregion

        public UnityAction<ClientState> OnChangeNetworkClientState;

        public UnityAction OnDisconnectedAction;

        public UnityAction OnJoinedLobbyAction;

        public UnityAction OnJoinedRoomAction;

        public UnityAction<short, string> OnJoinRoomFailedAction;

        public UnityAction OnLeftRoomAction;



        #region MonoBehaviour CallBacks

        /// <summary>
        /// MonoBehavior 메서드는 초기 초기화 단계에서 Unity에 의해 GameObject에 호출되었습니다.
        /// </summary>
        void Awake()
        {
            Instance = this;
            // #Critical
            // 이렇게하면 PhotonNetwork를 사용할 수 있습니다.
            // 마스터 클라이언트의 LoadLevel()과 동일한 룸에 있는 모든 클라이언트의 LoadLevel이 자동으로 동기화됩니다
            PhotonNetwork.AutomaticallySyncScene = true;
            UpdateCntNetworkClientState();

        }

        /// <summary>
        /// 마스터 서버에 진입한 후에 바로 실행
        /// </summary>
        public override void OnConnectedToMaster()
        {
            UpdateCntNetworkClientState();
            PhotonNetwork.JoinLobby();
            PhotonNetwork.NickName = PlayerPrefs.GetString("NickName");
        }

        /// <summary>
        /// 접속이 종료되었을 경우 실행된다.
        /// </summary>
        /// <param name="cause"></param>
        public override void OnDisconnected(DisconnectCause cause)
        {

            if (cause == DisconnectCause.DisconnectByServerLogic)
            {
                // 로비 입장 실패
                Debug.LogFormat($"<color=red> Failed to enter lobby : {cause} </color>");
            }
            else
            {
                // 기타 연결 끊김 원인(예: 인터넷 연결 끊김)
                Debug.Log($"<color=red> Disconnected from server : {cause} </color>");
            }
            UpdateCntNetworkClientState();
            OnDisconnectedAction?.Invoke();
        }

        public override void OnJoinedLobby()
        {
            UpdateCntNetworkClientState();
            OnJoinedLobbyAction?.Invoke();
        }

        public override void OnJoinedRoom()
        {

            string userId = PhotonNetwork.LocalPlayer.UserId;
            Debug.Log("Joined Room - User ID: " + userId);

            OnJoinedRoomAction?.Invoke();

        }

        public override void OnJoinRoomFailed(short returnCode, string message)
        {
            
            OnJoinRoomFailedAction?.Invoke(returnCode, message);
        }


        public override void OnLeftRoom()
        {
            OnLeftRoomAction?.Invoke();
        }

        public void CreateRoomWithNickName(bool _CntReset)
        {
            if (!_CntReset)
            {
                string _RoomStringBase = PlayerPrefs.GetString("NickName");
                string _UserGuid = PlayerPrefs.GetString("UserGuid");
                if (_UserGuid.Length >= _CreateRoomCnt)
                    PhotonNetwork.CreateRoom(_RoomStringBase + "_#" + _UserGuid[.._CreateRoomCnt++], new RoomOptions { MaxPlayers = maxPlayersPerRoom, CleanupCacheOnLeave = true, PlayerTtl = 1000 });
                else Debug.Log("방생성 실패(너무 많은 생성 실패)");
                
            }
            else _CreateRoomCnt = 1;
            

        }

        #endregion



        #region Public Methods

        /// <summary>
        /// 연결 프로세스를 시작합니다.
        /// </summary>
        public void Connect()
        {
            // 연결되었다면 로비에 참여
            if (PhotonNetwork.IsConnected) PhotonNetwork.JoinLobby(new TypedLobby("MainLobby", LobbyType.Default));
            else
            {
                PhotonNetwork.GameVersion = gameVersion;
                PhotonNetwork.ConnectUsingSettings();
            }
        }

        public void JoinRoom(string _roomName)
        {
            PhotonNetwork.JoinRoom(_roomName);
        }

        public void DisconnectMainServer()
        {
            PhotonNetwork.Disconnect();
        }

        public void UpdateCntNetworkClientState()
        {
            CntNetworkClientState = PhotonNetwork.NetworkClientState;
        }

        #endregion

    }
}

RoomItem.CS

using UnityEngine;
using UnityEngine.UI;
using TMPro;

namespace Com.Lycos7560
{
    public class RoomItem : MonoBehaviour
    {
        public TMP_Text RoomName;
        public TMP_Text PeopleNumber;
        public Button JoinRoomBtn;

        public void ChangeRoomInfo(string _name, int _cnt, int _max)
        {
            RoomName.text = _name;
            PeopleNumber.text = string.Format($"{_cnt} / {_max}");
        }



    }
}

Photon PUN2 + Chat + Voice

Chatting.CS (수정)

using UnityEngine;
using UnityEngine.UI;
using TMPro;
using Photon.Pun;
using Photon.Chat;
using Photon.Voice.Unity;
using ExitGames.Client.Photon;

namespace Com.Lycos7560
{
    public class Chatting : MonoBehaviourPunCallbacks, IChatClientListener
    {
        public ChatClient _ChatClient;

        public GameObject ChattingMain;

        public Button _CloseChattingMainBtn;

        public TMP_Text _ServerStateText;

        public TMP_InputField _ChatInputField;

        public Button _ChatSendBtn;

        public TMP_Text _ChattingContentText;
        public TMP_Text SubscribeUsersText;

        public ChatChannel _CntChatChannel;

        public GameObject _PlayerSpeaker;

        #region IChatClientListener CallBacks

        public void OnGetMessages(string channelName, string[] senders, object[] messages)
        {
            for (int i = 0; i < senders.Length; i++)
            {
                string sender = senders[i];
                string message = messages[i].ToString();

                string chatMessage = $"[{sender}]: {message}";

                // 채팅 메시지 추가
                _ChattingContentText.text += chatMessage + "\n";
            }
        }

        // 개인 메시지(귓속말) 미구현
        public void OnPrivateMessage(string sender, object message, string channelName)
        {
            Debug.Log("Private message from [" + sender + "]: " + message);
        }

        // 접속한 Room의 이름과 관련된 채널 구독이 성공 CallBack
        public void OnSubscribed(string[] channels, bool[] results)
        {
            _ChattingContentText.text = string.Empty;
            // 채널을 캐싱해준다. (구독 완료된 시점)
            if (_ChatClient.TryGetChannel("Room_" + PhotonNetwork.CurrentRoom.Name, out _CntChatChannel))  

            //// 나가기 버튼 활성화
            //_CloseChattingMainBtn.gameObject.SetActive(true); 

            // 첫 화면 출력
            _ChattingContentText.text += " Welcome to Photon Chat. \n";
            UpdateSubscribeUsersText();
            /* 디버깅
            for (int i = 0; i < channels.Length; i++)
                Debug.Log("Subscribed to Channel: " + channels[i]); 
            */
        }

        // 접속한 Room의 이름과 관련된 채널 구독을 해제 CallBack
        public void OnUnsubscribed(string[] channels)
        {
            // 구독 해제와 동시에 Clear
            _ChattingContentText.text = string.Empty;
            /* 디버깅
            for (int i = 0; i < channels.Length; i++)
                Debug.Log("Unsubscribed from Channel: " + channels[i]);
            */
        }

        // 디버그 CallBack 미구현
        public void DebugReturn(DebugLevel level, string message)
        {
            Debug.Log("Debug: " + level + " - " + message);
        }

        // 디버그 CallBack 미구현
        public void OnDisconnected()
        {
            Debug.Log("Disconnected from Chat Server");
        }

        // 디버그 CallBack 미구현
        public void OnChatStateChange(ChatState state)
        {
            _ServerStateText.text = string.Format($"Server State : {state}");
        }

        // 디버그 CallBack 미구현
        public void OnStatusUpdate(string user, int status, bool gotMessage, object message)
        {
            Debug.Log("Status Update - User: " + user + ", Status: " + status);
        }

        //  어떤 유저가 해당 채널을 구독 CallBack
        public void OnUserSubscribed(string channel, string user)
        {
            // 메시지 창에 어떤 유저가 구독했는지 출력
            string message = $"<color=#06FF00>'{user}' has joined '{channel}'</color>";
            _ChattingContentText.text += message + "\n";
            UpdateSubscribeUsersText();
        }

        //  어떤 유저가 해당 채널을 구독 해제 CallBack
        public void OnUserUnsubscribed(string channel, string user)
        {
            // 메시지 창에 어떤 유저가 구독을 해제했는지 출력
            string message = $"<color=#FF0000> '{user}' has left '{channel}'</color>";
            _ChattingContentText.text += message + "\n";
            UpdateSubscribeUsersText();
        }


        #endregion


        #region MonoBehaviour

        private void Awake()
        {         
            ChattingMain.SetActive(false);
            _CloseChattingMainBtn.onClick.AddListener(() => {
                // 나가기 버튼 비활성화
                _CloseChattingMainBtn.gameObject.SetActive(false);
                PhotonNetwork.LeaveRoom();
            });
            _ChatSendBtn.onClick.AddListener(() => {
                if (_ChatInputField.text == string.Empty) return;
                else {
                    SendRoomMessage(_ChatInputField.text);
                    _ChatInputField.text = string.Empty;
                }
            });
        }

        private void Start()
        {
            // 액션 등록
            NetworkManager.Instance.OnJoinedRoomAction += ChattingOnJoinedRoom;
            NetworkManager.Instance.OnLeftRoomAction += ChattingOnLeftRoom;
            NetworkManager.Instance.OnJoinedLobbyAction += ChattingOnJoinedLobby;
        }

        private void Update()
        {
            // !!필수!!
            // ChatClient의 콜백 처리를 위해 주기적으로 호출
            if (_ChatClient != null)
                _ChatClient.Service();
        }

        #endregion



        #region ActionFuctions

        /// <summary>
        /// 로비에 접속하면 Chatting Server를 활성화 시킨다.
        /// </summary>
        private void ChattingOnJoinedLobby()
        {
            // 구독 전에 나가는 것을 방지
            _CloseChattingMainBtn.gameObject.SetActive(false); 

            if (_ChatClient == null) {
                // 로비에 접속한 후 ChatClient 초기화 및 연결
                _ChatClient = new ChatClient(this);
                _ChatClient.Connect(PhotonNetwork.PhotonServerSettings.AppSettings.AppIdChat, PhotonNetwork.AppVersion, new Photon.Chat.AuthenticationValues(PhotonNetwork.NickName));
                Debug.LogFormat($"Chatting Server 초기화 및 연결 시작");
            }
        }

        /// <summary>
        ///  Room에 접속하면 실행되는 함수
        ///  Room의 이름과 관련된 채팅 서버에 접속한다.
        /// </summary>
        private void ChattingOnJoinedRoom()
        {
            _ChattingContentText.text = string.Empty;
            ChattingMain.SetActive(true);
            string _Channel = "Room_" + PhotonNetwork.CurrentRoom.Name; // 가입할 채널 이름 배열
            _ChatClient.Subscribe(_Channel, 0, -1, new ChannelCreationOptions { PublishSubscribers = true } ); // 채널에 구독
            Debug.LogFormat($"{"Room_" + PhotonNetwork.CurrentRoom.Name} :: 구독");

            _PlayerSpeaker = PhotonNetwork.Instantiate("PlayerVoiceChatPrefab", Vector3.zero, Quaternion.identity);
            _PlayerSpeaker.GetComponent<Speaker>().enabled = false;
            _PlayerSpeaker.GetComponent<AudioSource>().enabled = false;
            // 나가기 버튼 활성화
            _CloseChattingMainBtn.gameObject.SetActive(true);
        }

        /// <summary>
        /// Room에서 나갈 경우 실행되는 함수
        /// </summary>
        private void ChattingOnLeftRoom()
        {
            PhotonNetwork.Destroy(_PlayerSpeaker.GetPhotonView());
            string[] _Channels = new string[] { _CntChatChannel.Name };
            _ChatClient.Unsubscribe(_Channels);
            _CntChatChannel = null;
            ChattingMain.SetActive(false);
        }

        #endregion

        /// <summary>
        /// 구독한 Channel에 메시지를 보냅니다.
        /// </summary>
        /// <param name="message"></param>
        private void SendRoomMessage(string message)
        {
            if (_ChatClient != null && _ChatClient.CanChat) {
                //  _ChatClient가 구독한 방에 메시지를 보냅니다.
                _ChatClient.PublishMessage("Room_" + PhotonNetwork.CurrentRoom.Name, message);
            }
        }

        /// <summary>
        /// 체널의 있는 유저들의 정보를 갱신합니다.
        /// </summary>
        private void UpdateSubscribeUsersText()
        {
            if (_ChatClient != null && _CntChatChannel != null) {
                var _Users = _CntChatChannel.Subscribers;
                SubscribeUsersText.text = string.Empty;
                foreach (var _user in _Users)
                    SubscribeUsersText.text += _user + "  ";               
            }
            else SubscribeUsersText.text = "There is a problem with the network.";
           
        }
    }






}

APK File

• 마이크 온오프 기능 추가

• 스피커 관련 오류 수정

The post Photon PUN2 + Chat + Voice2 (APK) appeared first on 어제와 내일의 나 그 사이의 이야기.

발표 심사 첨부 영상

초기 출품 영상

인디크래프트 발표심사 질문

Q1> 현재 게임의 버전이 전체적인 완성 버전에 비해서 어느 정도 개발이 진척되었나요?

Q2> 혼자서도 충분하게 적 함대를 막을 수 있을 것 같은 데 아군 함선을 추가한 목적이 있나요?

Q3> 게임의 주된 플레이는 이러한 함대전투 등을 통한 오브젝트를 지키는 디펜스 계열인가요?

Q4> 무료 게임으로 배포하는 것으로 되어있던데, 수익 모델은 없는 건가요?

결과는 1차는 합격했으나 2차 온라인 발표 심사에서 떨어졌다.

개인적인 생각으로는 게임의 전체적인 볼륨이 너무 적고

게임의 완성도 및 수익 모델에 대한 명쾌한 대답을 하지 못한 부분 불합격이 된 주 이유인 것 같다.

발표중에는 제작기간이 2개월 정도라고 했지만

인디 크래프트 모집 공고가 나오기 전에 Unity VR 을 공부하면서

R&D하던 시간을 포함을 한거라 실질적인 제작 기간은 더 짧았다.

개발하는 과정에서도 어려움이 많았다.

혼자서 짧은 기간에 개발을 진행하다보니 게임 내부의 캐릭터 및 스토리, 설정 등 다양한 부분은 생각도 할 수 없었고

게임의 테마 및 장르 등 다양한 부분을 결정하는데 큰 어려움을 겪었다.

성능의 문제도 있었는데 초기 게임의 장르는 아래의 그림과 같이 다수의 함선이 우주에서 전투하고

플레이어가 함선의 컨트롤하며 다른 세력의 행성을 점령하는 RTS 장르였지만

– 스텔라리스

함선 및 투사체, 이펙트 등 오브젝트가 증가할수록 프레임 드랍이 심해지며 플레이가 힘들어졌다.

원인은 오큘러스 퀘스트1의 AP(Application Processor) 성능 한계였고

이를 해결하기 위해서 장르를 변경하고 적 함선의 쉐이더를 변경(홀로그램으로 통일), 그림자 및 반사를 제거하는 등

최적화 및 테스트에 많은 시간을 소모했다.

위와 같은 이유로 1차도 통과하지 못할 거라고 생각했지만

운이 좋게 통과하여 2차 온라인 심사까지 경험하고 2023 인디크래프트를 마무리했다.

The post 2023 인디크래프트 HOLO SPACE appeared first on 어제와 내일의 나 그 사이의 이야기.

서울IT아카데미(홍대) 게임프로그래밍개발자양성과정 22기를 진행하면서 팀원들과 함께 출시까지 완료한 프로젝트 입니다.

팀원들의 열정과 노력 / 강사 님의 다양한 지원과 격려가 없었다면 불가능 했을 겁니다.


게임의 콘셉트/시스템/레벨 디자인 등 다양한 요소를 팀원들과 결정하다 보니 많은 의견 충돌이 있었지만 잘 해결되었고,

2개월이 조금 넘는 짧은 시간 안에 팀 프로젝트를 완성하기란 쉽지 않았지만 완성했습니다. (완벽하지는 않지만…완성입니다 ㅎㅎ)


프로젝트를 진행하면서 초반에 구현 싶었던 많은 기능들을 시간적인 이유로 포기한 것이 너무 마음에 아픕니다.

또 조금 더 열정적으로 했었다면 결과가 더 좋았을 거라는 아쉬움이 남습니다. (2개월은 넘 짧아요)


팀 프로젝트를 하면서 이 프로젝트를 하는 사람들이 나와 같은 생각을 가지고 있는가? 를 끊임없이 확인 해야 한다는 것을 느꼈습니다. (회의의 중요성)

당연한 것은 없습니다. 개개인은 모두 다르죠. 나는 당연하다고 느끼는 것이 남에게는 전혀 다른 방향으로 전달될 수 있습니다.

팀 프로젝트에서는 작은 일을 진행하더라도 회의 없이 개개인의 생각대로 진행하면 언젠가는 나비효과처럼 프로젝트에 태풍을 불러옵니다.

우리 팀은 이런 일이 매우 잦아 부족한 시간이 더 부족해져 더 큰 아쉬움이 남습니다.

생각해보면 이런 프로젝트를 해본 적이 없는 사람들을 모아 놓았으니 당연한 결과였다고는 생각합니다. (나중에 이 경험이 큰 도움이 될 겁니다.)


이후의 목표는 개인적으로 게임을 하나 출시해보는 걸 목표로 해보고 싶습니다.

아직 명확하게 결정된 사항은 아무것도 없지만 수료 후가 기대되네요.



제작 기간 : 2022.09.02 ~ 2022.11.18

서울IT아카데미(홍대) 게임프로그래밍개발자양성과정 22기

장상욱 강사 님의 수강생

– Team Troi –

유현우

최익호

최지혜

https://play.google.com/store/apps/details?id=com.teamtori.animalkingdom

홍보 영상

포스터

중간 과정들

ㅣ

The post TEAM TORI – ANIMAL KINGDOM POSTER appeared first on 어제와 내일의 나 그 사이의 이야기.