public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            DrawTitleBar(
                "Track Connection Status",
                "This component requires to have a \"UICoreLogic\" somewhere in your scene.\n\n" +
                "This component will change the targeted Text to match whatever the connection " +
                "status is, from the NetworkManager.",
                E_Core.h_uiIcon
                );
            #endregion

            #region Properties
            EditorGUILayout.PropertyField(texts, true);
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            EditorGUILayout.HelpBox("Call when you successfully connect to the Photon Lobby.", MessageType.Info);
            EditorGUILayout.PropertyField(OnConnectedToLobby);
            EditorGUILayout.HelpBox("Call when you successfully connect to a Photon Room.", MessageType.Info);
            EditorGUILayout.PropertyField(OnConnectedToRoom);
            GUI.skin = _skin;
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            #endregion

            #region Core
            EndInspectorGUI(typeof(TrackConnectionStatus));
            #endregion
        }
Beispiel #2
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            DrawTitleBar(
                "Generic Event Caller",
                "This component will simply execute this UnityEvent on the given events.",
                E_Core.h_uiIcon
                );
            #endregion

            #region Properties
            EditorGUILayout.PropertyField(onAwake);
            EditorGUILayout.PropertyField(onStart);
            EditorGUILayout.PropertyField(onEnable);
            EditorGUILayout.PropertyField(onDisable);
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            EditorGUILayout.PropertyField(EventsToCall);
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            GUI.skin = _skin;
            #endregion

            #region Core
            EndInspectorGUI(typeof(GenericEventCaller));
            #endregion
        }
Beispiel #3
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            GenericCountDown countdown = (GenericCountDown)target;
            DrawTitleBar(
                "Generic Count Down",
                "This component will execute a series of UnityEvents based on the countdown time.",
                E_Core.h_uiIcon
                );
            #endregion

            #region Properties
            EditorGUILayout.PropertyField(useRoomOwnerShip);
            if (useRoomOwnerShip.boolValue == true)
            {
                EditorGUILayout.PropertyField(ifIsOwner);
            }
            EditorGUILayout.PropertyField(startType);
            EditorGUILayout.Space();
            EditorGUILayout.PropertyField(startTime);
            EditorGUILayout.PropertyField(syncWithPhotonServer);
            if (syncWithPhotonServer.boolValue == false)
            {
                EditorGUILayout.PropertyField(countSpeed);
            }
            EditorGUILayout.PropertyField(numberType);
            EditorGUILayout.Space();
            EditorGUILayout.PropertyField(texts, true);
            EditorGUILayout.Space();
            EditorGUILayout.PropertyField(soundSource);
            EditorGUILayout.PropertyField(tickClip);
            GUI.enabled = false;
            EditorGUILayout.PropertyField(_time);
            GUI.enabled = true;
            EditorGUILayout.PropertyField(debugging);
            EditorGUILayout.Space();
            countdown.showUnityEvents = EditorGUILayout.Foldout(countdown.showUnityEvents, "Unity Events");
            if (countdown.showUnityEvents)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(OnStartCounting);
                EditorGUILayout.PropertyField(OnStopCounting);
                EditorGUILayout.PropertyField(OnNumberChange);
                EditorGUILayout.PropertyField(OnZero);
                GUI.skin = _skin;
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            }
            #endregion

            #region Core
            EndInspectorGUI(typeof(GenericCountDown));
            #endregion
        }
Beispiel #4
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            DrawTitleBar(
                "Death Camera",
                "Call \"EnableSwitching\" function to turn on/off " +
                "the functionality to allow the player to switch between other players. " +
                "A helper function \"DeadEnableDeathCamera\" function is availabe in the \"SyncPlayer\" " +
                "component that can be tied to the \"vThirdPersonController\" component.\n\n" +
                "vThirdPersonController (OnDead) -> SyncPlayer(DeadEnableDeathCamera) -> DeathCamera(EnableSwitching)",
                E_Core.h_deathCameraIcon
                );
            #endregion

            #region Properties
            int pre_index = availableInputs.IndexOf(keyToSwitchPrevious.stringValue);
            if (pre_index == -1)
            {
                EditorGUILayout.PropertyField(keyToSwitchPrevious, new GUIContent("Previous Player Key"));
                EditorGUILayout.HelpBox("This key doesn't exist in your project. Be sure to add it before you final build!", MessageType.Error);
            }
            else
            {
                prevInt = pre_index;
                prevInt = EditorGUILayout.Popup("Previous Player Key", prevInt, availableInputs.ToArray());
                keyToSwitchPrevious.stringValue = availableInputs[prevInt];
            }

            int next_index = availableInputs.IndexOf(keyToSwitchNext.stringValue);
            if (next_index == -1)
            {
                EditorGUILayout.PropertyField(keyToSwitchNext, new GUIContent("Next Player Key"));
                EditorGUILayout.HelpBox("This key doesn't exist in your project. Be sure to add it before you final build!", MessageType.Error);
            }
            else
            {
                nextInt = next_index;
                nextInt = EditorGUILayout.Popup("Next Player Key", nextInt, availableInputs.ToArray());
                keyToSwitchNext.stringValue = availableInputs[nextInt];
            }
            EditorGUILayout.PropertyField(deathVisual);
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            EditorGUILayout.PropertyField(OnEnableSwitching);
            EditorGUILayout.PropertyField(OnDisableSwitching);
            GUI.skin = _skin;
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            #endregion

            #region Core
            EndInspectorGUI(typeof(DeathCamera));
            #endregion
        }
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            DrawTitleBar(
                "Track Player Count",
                "This component requires to have a \"UICoreLogic\" somewhere in your scene.\n\n" +
                "This component will modify the targets Text components to display what the " +
                "current player count is.",
                E_Core.h_uiIcon
                );
            #endregion

            #region Properties
            EditorGUILayout.PropertyField(texts, true);
            EditorGUILayout.PropertyField(teamName);
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            EditorGUILayout.PropertyField(OnCountChanged);
            GUI.skin = _skin;
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            EditorGUILayout.PropertyField(executeEventAtPlayerCount);
            if (executeEventAtPlayerCount.boolValue == true)
            {
                EditorGUILayout.PropertyField(useRoomOwnerShip);
                if (useRoomOwnerShip.boolValue == true)
                {
                    EditorGUILayout.PropertyField(isOwner);
                }
                EditorGUILayout.PropertyField(reachPlayerCount);
                EditorGUILayout.PropertyField(fallBelowCount);
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(ReachedPlayerCount);
                EditorGUILayout.PropertyField(ReachedFallPlayerCount);
                GUI.skin = _skin;
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            }
            #endregion

            #region Core
            EndInspectorGUI(typeof(TrackPlayerCount));
            #endregion
        }
Beispiel #6
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            PreviewCamera pc = (PreviewCamera)target;
            DrawTitleBar(
                "Preview Camera",
                "Component thats used to make a target camera follow a series of points. " +
                "This is designed specifically for a lobby preview camera however this does " +
                "contain a start/stop function for outside components to call.",
                E_Core.h_cameraPath
                );
            #endregion

            #region Properties
            GUILayout.BeginHorizontal();
            GUILayout.BeginVertical();
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            EditorGUILayout.PropertyField(moveImmediatly);
            EditorGUILayout.PropertyField(stopOnJoinRoom);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            _cameraPointsList.DoLayoutList();
            GUI.skin = _skin;
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            EditorGUILayout.PropertyField(cameraMoveSpeed);
            EditorGUILayout.PropertyField(cameraCloseEnough);
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Optional Fields", _skin.textArea);
            EditorGUILayout.PropertyField(targetCam);
            EditorGUILayout.PropertyField(networkManager);
            #endregion

            #region Core
            EndInspectorGUI(typeof(PreviewCamera));
            #endregion
        }
Beispiel #7
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            ChatBox sp = (ChatBox)target;

            DrawTitleBar(
                "Text Chat Box",
                "Component that is used for all text chat logic. Your chatbox should have all needed logic included in this component.",
                E_Core.h_textChatIcon
                );
            #endregion

            #region Properties
            #region Sound Options
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Sound Options", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showSoundSettings.boolValue = !showSoundSettings.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showSoundSettings.boolValue == true)
            {
                EditorGUILayout.PropertyField(source);
                EditorGUILayout.PropertyField(chatNotification);
                EditorGUILayout.PropertyField(notificationVolume);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region Animation Options
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Animation Options", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showAnimSettings.boolValue = !showAnimSettings.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showAnimSettings.boolValue == true)
            {
                EditorGUILayout.PropertyField(chatAnim);
                EditorGUILayout.PropertyField(slideIn);
                EditorGUILayout.PropertyField(slideOut);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region ChatBox GameObjects
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("ChatBox GameObject Parts", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showChatBoxObjs.boolValue = !showChatBoxObjs.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showChatBoxObjs.boolValue == true)
            {
                EditorGUILayout.PropertyField(parentChatObj);
                EditorGUILayout.PropertyField(msgInput);
                EditorGUILayout.PropertyField(connectionStatus);
                EditorGUILayout.PropertyField(messagesObj);
                EditorGUILayout.PropertyField(scrollRect);
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(newMessageIcon);
                EditorGUILayout.PropertyField(onlyWhenWindowClose);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region Generated Objects
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Dynamically Generated Objects", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showDynamicGenObj.boolValue = !showDynamicGenObj.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showDynamicGenObj.boolValue == true)
            {
                EditorGUILayout.PropertyField(otherChatMessage);
                EditorGUILayout.PropertyField(yourChatMessage);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region External Objects References
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("External Object References", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showExternalObjectRef.boolValue = !showExternalObjectRef.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showExternalObjectRef.boolValue == true)
            {
                EditorGUILayout.PropertyField(nm);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region Connection Settings
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Connection Settings", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showConnectionSettings.boolValue = !showConnectionSettings.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showConnectionSettings.boolValue)
            {
                EditorGUILayout.PropertyField(protocol);
                EditorGUILayout.PropertyField(region);
                EditorGUILayout.PropertyField(authType);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region Input Settings
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Input Settings", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showInputSettings.boolValue = !showInputSettings.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showInputSettings.boolValue == true)
            {
                EditorGUILayout.HelpBox("You will only be able to select inputs that are currently" +
                                        " available in your input settings. If you wish to add more open Project Settings > Inputs " +
                                        "and add your desired input.", MessageType.None);

                #region Open Chat Window On Press
                EditorGUILayout.LabelField("Open Chat Window On Press");
                List <string> open     = (List <string>)target.GetType().GetField("openChatWindowOnPress", E_Helpers.allBindings).GetValue(target);
                int[]         openInts = new int[open.Count];
                for (int i = 0; i < open.Count; i++)
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.Space();
                    openInts[i] = availableInputs.IndexOf(open[i]);
                    if (openInts[i] == -1)
                    {
                        EditorGUILayout.HelpBox("Button: \"" + open[i] + "\" doesn't exist", MessageType.Error);
                    }
                    else
                    {
                        openInts[i] = EditorGUILayout.Popup(openInts[i], availableInputs.ToArray());
                        open[i]     = availableInputs[openInts[i]];
                    }
                    if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Minus"), _skin.label, GUILayout.Width(30), GUILayout.Height(15)))
                    {
                        open.RemoveAt(i);
                        break;
                    }
                    EditorGUILayout.EndHorizontal();
                }
                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Plus"), _skin.label, GUILayout.Width(30), GUILayout.Height(25)))
                {
                    open.Add(availableInputs[0]);
                }
                EditorGUILayout.EndHorizontal();
                #endregion

                #region Close Chat Window On Press
                EditorGUILayout.LabelField("Close Chat Window On Press");
                List <string> close     = (List <string>)target.GetType().GetField("closeWindowOnPress", E_Helpers.allBindings).GetValue(target);
                int[]         closeInts = new int[close.Count];
                for (int i = 0; i < close.Count; i++)
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.Space();
                    closeInts[i] = availableInputs.IndexOf(close[i]);
                    if (closeInts[i] == -1)
                    {
                        EditorGUILayout.HelpBox("Button: \"" + close[i] + "\" doesn't exist", MessageType.Error);
                    }
                    else
                    {
                        closeInts[i] = EditorGUILayout.Popup(closeInts[i], availableInputs.ToArray());
                        close[i]     = availableInputs[closeInts[i]];
                    }
                    if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Minus"), _skin.label, GUILayout.Width(30), GUILayout.Height(15)))
                    {
                        close.RemoveAt(i);
                        break;
                    }
                    EditorGUILayout.EndHorizontal();
                }
                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Plus"), _skin.label, GUILayout.Width(30), GUILayout.Height(25)))
                {
                    close.Add(availableInputs[0]);
                }
                EditorGUILayout.EndHorizontal();
                #endregion

                #region Send Chat On Press
                EditorGUILayout.LabelField("Send Chat On Press");
                List <string> send     = (List <string>)target.GetType().GetField("sendChatOnPress", E_Helpers.allBindings).GetValue(target);
                int[]         sendInts = new int[send.Count];
                for (int i = 0; i < send.Count; i++)
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.Space();
                    sendInts[i] = availableInputs.IndexOf(send[i]);
                    if (sendInts[i] == -1)
                    {
                        EditorGUILayout.HelpBox("Button: \"" + send[i] + "\" doesn't exist", MessageType.Error);
                    }
                    else
                    {
                        sendInts[i] = EditorGUILayout.Popup(sendInts[i], availableInputs.ToArray());
                        send[i]     = availableInputs[sendInts[i]];
                    }

                    if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Minus"), _skin.label, GUILayout.Width(30), GUILayout.Height(15)))
                    {
                        send.RemoveAt(i);
                        break;
                    }
                    EditorGUILayout.EndHorizontal();
                }
                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button(EditorGUIUtility.FindTexture("d_Toolbar Plus"), _skin.label, GUILayout.Width(30), GUILayout.Height(25)))
                {
                    send.Add(availableInputs[0]);
                }
                EditorGUILayout.EndHorizontal();
                #endregion
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region Helpful ChatBox Actions
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Helpful ChatBox Actions", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                showHelpFullChatActions.boolValue = !showHelpFullChatActions.boolValue;
            }
            GUILayout.EndHorizontal();
            if (showHelpFullChatActions.boolValue == true)
            {
                EditorGUILayout.PropertyField(autoScroll);
                EditorGUILayout.PropertyField(startEnabled);
                EditorGUILayout.PropertyField(enableOnConnect);
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(debugging);
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region UnityEvents
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            GUILayout.Space(5);
            GUILayout.BeginHorizontal(_skin.customStyles[1], GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Events", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label))
            {
                eventSettings.boolValue = !eventSettings.boolValue;
            }
            GUILayout.EndHorizontal();
            if (eventSettings.boolValue == true)
            {
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("Data"))
                {
                    dataEvents.boolValue      = true;
                    subscribeEvents.boolValue = false;
                    messageEvents.boolValue   = false;
                    enableEvents.boolValue    = false;
                }
                if (GUILayout.Button("Subscribe"))
                {
                    dataEvents.boolValue      = false;
                    subscribeEvents.boolValue = true;
                    messageEvents.boolValue   = false;
                    enableEvents.boolValue    = false;
                }
                if (GUILayout.Button("Messages"))
                {
                    dataEvents.boolValue      = false;
                    subscribeEvents.boolValue = false;
                    messageEvents.boolValue   = true;
                    enableEvents.boolValue    = false;
                }
                if (GUILayout.Button("Enabled"))
                {
                    dataEvents.boolValue      = false;
                    subscribeEvents.boolValue = false;
                    messageEvents.boolValue   = false;
                    enableEvents.boolValue    = true;
                }
                EditorGUILayout.EndHorizontal();

                if (dataEvents.boolValue == true)
                {
                    EditorGUILayout.HelpBox("When you receive a message that is intended for everyone in the session.", MessageType.None);
                    GUI.skin = _original;
                    EditorGUILayout.PropertyField(OnReceiveBroadcastMessage);
                    EditorGUILayout.HelpBox("When you subscribe to the data channel.", MessageType.None);
                    EditorGUILayout.PropertyField(OnYouSubscribeToDataChannel);
                    GUI.skin = _skin;
                    EditorGUILayout.HelpBox("Called whenever another player joins/leaves the data channel. ", MessageType.None);
                    GUI.skin = _original;
                    EditorGUILayout.PropertyField(OnUserSubscribedToDataChannel);
                    EditorGUILayout.PropertyField(OnUserUnSubscribedToDataChannel);
                }
                if (subscribeEvents.boolValue == true)
                {
                    GUI.skin = _skin;
                    EditorGUILayout.HelpBox("Called whenever you subscribe/unsubscribe from any chat channel.", MessageType.None);
                    GUI.skin = _original;
                    EditorGUILayout.PropertyField(OnYouSubscribeToAnyChannel);
                    EditorGUILayout.PropertyField(OnYouUnSubscribeFromAnyChannel);
                }
                if (messageEvents.boolValue == true)
                {
                    GUI.skin = _skin;
                    EditorGUILayout.HelpBox("Called when you receive chat messages.", MessageType.None);
                    GUI.skin = _original;
                    EditorGUILayout.PropertyField(ReceivedAnyChatMessage);
                    EditorGUILayout.PropertyField(ReceivedOtherPlayerChatMessage);
                }
                if (enableEvents.boolValue == true)
                {
                    GUI.skin = _skin;
                    EditorGUILayout.HelpBox("Called when you enable or disable the chatbox.", MessageType.None);
                    GUI.skin = _original;
                    EditorGUILayout.PropertyField(ChatEnabled);
                    EditorGUILayout.PropertyField(ChatDisabled);
                }
                GUI.skin = _skin;
            }
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion
            #endregion

            EndInspectorGUI(typeof(ChatBox));
        }
Beispiel #8
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            CallNetworkEvents nevents = (CallNetworkEvents)target;
            DrawTitleBar(
                "Call Network Events",
                "Anything inside the NetworkInvoke events will be invoked across the network. " +
                "From another component call the \"CallNetworkInvoke(#)\" function to " +
                "trigger that set of events across the network.",
                E_Core.h_genericIcon
                );
            #endregion

            #region Properties
            GUILayout.BeginHorizontal(GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            EditorGUILayout.PropertyField(syncCrossScenes);
            if (syncCrossScenes.boolValue == true)
            {
                EditorGUILayout.PropertyField(holder, new GUIContent("Track Position"));
            }
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();

            GUILayout.BeginHorizontal("box", GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));

            #region No Input Invokes
            EditorGUILayout.HelpBox("Events that don't take any inputs. Can be called by calling the function CallNetworkInvoke(#).", MessageType.None);
            showNetworkInvoke1.boolValue = EditorGUILayout.Foldout(showNetworkInvoke1.boolValue, "Network Invoke 1");
            if (showNetworkInvoke1.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkInvoke1);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showNetworkInvoke2.boolValue = EditorGUILayout.Foldout(showNetworkInvoke2.boolValue, "Network Invoke 2");
            if (showNetworkInvoke2.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkInvoke2);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showNetworkInvoke3.boolValue = EditorGUILayout.Foldout(showNetworkInvoke3.boolValue, "Network Invoke 3");
            if (showNetworkInvoke3.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkInvoke3);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showNetworkInvoke4.boolValue = EditorGUILayout.Foldout(showNetworkInvoke4.boolValue, "Network Invoke 4");
            if (showNetworkInvoke4.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkInvoke4);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showNetworkInvoke5.boolValue = EditorGUILayout.Foldout(showNetworkInvoke5.boolValue, "Network Invoke 5");
            if (showNetworkInvoke5.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkInvoke5);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            #endregion

            #region GameObject Invokes
            EditorGUILayout.Space();
            EditorGUILayout.HelpBox("The gameobject that is past into these events is " +
                                    "derived from finding the photon id from the player that originally trigger these events.", MessageType.None);
            showGameObjectInvoke1.boolValue = EditorGUILayout.Foldout(showGameObjectInvoke1.boolValue, "Network GameObject Invoke 1");
            if (showGameObjectInvoke1.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkGameObjectInvoke1);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showGameObjectInvoke2.boolValue = EditorGUILayout.Foldout(showGameObjectInvoke2.boolValue, "Network GameObject Invoke 2");
            if (showGameObjectInvoke2.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkGameObjectInvoke2);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showGameObjectInvoke3.boolValue = EditorGUILayout.Foldout(showGameObjectInvoke3.boolValue, "Network GameObject Invoke 3");
            if (showGameObjectInvoke3.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkGameObjectInvoke3);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            showGameObjectInvoke4.boolValue = EditorGUILayout.Foldout(showGameObjectInvoke4.boolValue, "Network GameObject Invoke 4");
            if (showGameObjectInvoke4.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkGameObjectInvoke4);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            #endregion

            #region Single Invokes
            EditorGUILayout.Space();
            EditorGUILayout.HelpBox("Unity events that take a float as an input value. " +
                                    "Can be invoked over the network by calling CallFloatInvoke(#).", MessageType.None);
            showSingleInvoke1.boolValue = EditorGUILayout.Foldout(showSingleInvoke1.boolValue, "Network Float Invoke 1");
            if (showSingleInvoke1.boolValue == true)
            {
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.PropertyField(NetworkSingleInvoke1);
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUI.skin = _skin;
            }
            #endregion

            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            #region End Core
            EndInspectorGUI(typeof(CallNetworkEvents));
            #endregion
        }
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            SceneTransition sic = (SceneTransition)target;
            DrawTitleBar(
                "Scene Exit",
                "This is used to travel to another scene. It will load the " +
                "\"LoadSceneName\" and drop your player at the \"SpawnAtPoint\" within that scene." +
                "This data is all stored within the SceneDatabase. Run \"Scene Transition Manager " +
                "> Update Scene Database\" to build this, then place that built database into the " +
                "\"Database\" variable slot.",
                E_Core.h_sceneExitIcon
                );
            #endregion

            #region Properties
            EditorGUILayout.PropertyField(inspectorDatabase);
            if (!(SceneDatabase)inspectorDatabase.objectReferenceValue)
            {
                EditorGUILayout.HelpBox("No \"Database\" is present. Please add a \"Database\" before continuing.", MessageType.Error);
                serializedObject.ApplyModifiedProperties();
                if ((SceneDatabase)inspectorDatabase.objectReferenceValue)
                {
                    OnEnable();
                }
            }
            else if (!database)
            {
                OnEnable();
            }
            else
            {
                EditorGUILayout.PropertyField(autoTravel);
                if (autoTravel.boolValue == false)
                {
                    selectedButton             = (availableInputs.Contains(buttonToTravel.stringValue)) ? availableInputs.IndexOf(buttonToTravel.stringValue) : 0;
                    selectedButton             = EditorGUILayout.Popup("Button To Travel", selectedButton, availableInputs.ToArray());
                    buttonToTravel.stringValue = availableInputs[selectedButton];
                    EditorGUILayout.PropertyField(activeOnEnter, true);
                }
                selectedDatabaseIndex = EditorGUILayout.Popup("Load Scene Name", selectedDatabaseIndex, sceneNames.ToArray());
                if (selectedDatabaseIndex == -1)
                {
                    selectedDatabaseIndex = 0;
                    OnEnable();
                }
                LoadSceneName.stringValue = sceneNames[selectedDatabaseIndex];
                if (previous_selectedDatabaseIndex != selectedDatabaseIndex)
                {
                    previous_selectedDatabaseIndex = selectedDatabaseIndex;
                    selectedEntrancePointIndex     = 0;
                }

                EditorGUILayout.BeginHorizontal();
                if (database.storedScenesData[selectedDatabaseIndex].entrancePoints.Count > 0)
                {
                    selectedEntrancePointIndex = EditorGUILayout.Popup("Spawn At Point", selectedEntrancePointIndex, database.storedScenesData[selectedDatabaseIndex].entrancePoints.ToArray());
                    if (selectedEntrancePointIndex == -1)
                    {
                        SpawnAtPoint.stringValue = null;
                        EditorGUILayout.LabelField("** Select A Spawn Point");
                    }
                    else
                    {
                        SpawnAtPoint.stringValue = database.storedScenesData[selectedDatabaseIndex].entrancePoints[selectedEntrancePointIndex];
                    }
                }
                else
                {
                    SpawnAtPoint.stringValue = null;
                    EditorGUILayout.HelpBox("There are no available entry points in this scene. Either " +
                                            "they haven't been created or the \"Database\" is out of date. You can update the" +
                                            " database by running \"CB Games > Scene Transition Manager > Update Scenes Database\".", MessageType.Error);
                    EditorGUILayout.LabelField("Spawn At Point", GUILayout.MinWidth(0));
                    EditorGUILayout.LabelField("No Points Found In Database.");
                }

                EditorGUILayout.EndHorizontal();
                EditorGUILayout.PropertyField(sendAllTogether);
                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.HelpBox("This event is called right before traveling to the new scene. It will be invoked on each client if the 'Send All Together' is true.", MessageType.None);
                EditorGUILayout.PropertyField(BeforeTravel, true);
                EditorGUILayout.HelpBox("These events are called for ANY player that enters this trigger.", MessageType.None);
                EditorGUILayout.PropertyField(OnAnyPlayerEnterTrigger, true);
                EditorGUILayout.PropertyField(OnAnyPlayerExitTrigger, true);
                EditorGUILayout.HelpBox("These events are only called for the network player that you are controlling. This isn't called for other network players entering/exiting this trigger.", MessageType.None);
                EditorGUILayout.PropertyField(OnOwnerEnterTrigger, true);
                EditorGUILayout.PropertyField(OnOwnerExitTrigger, true);
                GUI.skin = _skin;
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            }
            #endregion

            #region End Core
            EndInspectorGUI(typeof(SceneTransition));
            #endregion
        }
Beispiel #10
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            VoiceChat vc = (VoiceChat)target;
            DrawTitleBar(
                "Voice Chat",
                "If this component is... " +
                "\n" +
                "...not for a player...\n" +
                "This is for a peristant object. This should be made a child object of the \"NetworkManager\" gameobject." +
                " This needs to have a \"Recorder\" & \"PhotonVoiceNetwork\" components attached. This is designed to " +
                "record the owner and send that voice recording over the network. This will display special icons and " +
                "invoke other things based on the state of the voice connection.\n" +
                "\n" +
                "...for a player...\n" +
                "This requires a \"Speaker\" & \"PhotonVoiceView\" components attached. This will display an icon when " +
                "voice from another player is playing through the \"Speaker\" component. Adjust the generated \"AudioSource\" " +
                "component to 2D if you want global room chat or 3D for proximity based chat. The \"Recorder In Use\" field " +
                "on the \"PhotonVoiceView\" will be auto populate by finding the \"Recorder\" component in the scene.",
                E_Core.h_voiceIcon
                );
            #endregion

            EditorGUILayout.BeginHorizontal(_skin.box);
            EditorGUILayout.PropertyField(isPlayer);
            EditorGUILayout.EndHorizontal();
            if (isPlayer.boolValue == true)
            {
                EditorGUILayout.PropertyField(ifOnTeam);
                EditorGUILayout.PropertyField(speakerImage);
            }
            else
            {
                EditorGUILayout.PropertyField(debugging);
                EditorGUILayout.PropertyField(recordingImage);
                EditorGUILayout.PropertyField(pushToTalk);
                if (!availableInputs.Contains(buttonToPress.stringValue))
                {
                    EditorGUILayout.PropertyField(buttonToPress);
                    EditorGUILayout.HelpBox("The Button To Press value: \"" + buttonToPress.stringValue + "\" doesn't exist. " +
                                            "To fix this go to your Project Settings > Input and add this key name.", MessageType.Error);
                }
                else
                {
                    selectedButton            = availableInputs.IndexOf(buttonToPress.stringValue);
                    selectedButton            = EditorGUILayout.Popup("Button To Hold", selectedButton, availableInputs.ToArray());
                    buttonToPress.stringValue = availableInputs[selectedButton];
                }

                GUI.skin = _original;
                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                EditorGUILayout.HelpBox("Called when successfully connected/disconnected from the master voice server.", MessageType.None);
                EditorGUILayout.PropertyField(OnConnectedToServer, true);
                EditorGUILayout.PropertyField(OnDisconnect, true);
                EditorGUILayout.HelpBox("Called when successfully joined ANY chat room.", MessageType.None);
                EditorGUILayout.PropertyField(OnJoinRoom, true);
                EditorGUILayout.HelpBox("Called once when this component is first loaded in a scene.", MessageType.None);
                EditorGUILayout.PropertyField(OnStart, true);
                GUI.skin = _skin;
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                EditorGUILayout.Space();
            }

            EndInspectorGUI(typeof(VoiceChat));
        }
Beispiel #11
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            UICoreLogic cl = (UICoreLogic)target;
            DrawTitleBar(
                "UI Core Logic",
                "This component is what almost everything in the UI calls. This is " +
                "also open enough that it exposes enough functions for you to use in your own UIs (hopefully).\n" +
                "Only one of these components should ever be in the scene at a time. If more than one \"UICoreLogic\" component " +
                "is found it could cause errors.",
                E_Core.h_uiIcon
                );
            #endregion

            #region Session/Core Settings
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Core Options", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                cl.e_show_core = !cl.e_show_core;
            }
            EditorGUILayout.EndHorizontal();

            if (cl.e_show_core == true)
            {
                EditorGUILayout.PropertyField(defaultLevelIndex);
                EditorGUILayout.PropertyField(selectablePlayers, true);
                EditorGUILayout.PropertyField(sceneList, true);
                EditorGUILayout.PropertyField(debugging);
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(5);
            #endregion

            #region Audio
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Sound Options", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                cl.e_show_audio = !cl.e_show_audio;
            }
            EditorGUILayout.EndHorizontal();

            if (cl.e_show_audio == true)
            {
                EditorGUILayout.PropertyField(musicSource);
                EditorGUILayout.PropertyField(soundSource);
                EditorGUILayout.PropertyField(mouseEnter);
                EditorGUILayout.PropertyField(mouseEnterVolume);
                EditorGUILayout.PropertyField(mouseExit);
                EditorGUILayout.PropertyField(mouseExitVolume);
                EditorGUILayout.PropertyField(mouseClick);
                EditorGUILayout.PropertyField(mouseClickVolume);
                EditorGUILayout.PropertyField(finalClick);
                EditorGUILayout.PropertyField(startVolume);
                EditorGUILayout.PropertyField(fadeInAudio);
                EditorGUILayout.PropertyField(fadeInSpeed);
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(5);
            #endregion

            #region Loading Page
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.BeginVertical();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Loading Page Options", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                cl.e_show_loading = !cl.e_show_loading;
            }
            EditorGUILayout.EndHorizontal();

            if (cl.e_show_loading == true)
            {
                EditorGUILayout.PropertyField(loadingParent);
                EditorGUILayout.PropertyField(loadingImages, true);
                EditorGUILayout.PropertyField(loadingImageDisplayTime);
                EditorGUILayout.PropertyField(loadingPageFadeSpeed);
                EditorGUILayout.PropertyField(loadingTitle);
                EditorGUILayout.PropertyField(loadingDesc, true);
                EditorGUILayout.PropertyField(mainLoadingImage);
                EditorGUILayout.PropertyField(loadingTitleText);
                EditorGUILayout.PropertyField(loadingDescText);
                EditorGUILayout.PropertyField(loadingBar);
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(5);
            #endregion

            #region UnityEvents
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.BeginVertical();
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("UI Events", _skin.textField);
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                cl.e_show_events = !cl.e_show_events;
            }
            EditorGUILayout.EndHorizontal();

            if (cl.e_show_events == true)
            {
                GUILayout.BeginHorizontal();
                if (GUILayout.Button("Start"))
                {
                    cl.e_events_oneTime = true;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = false;
                }
                if (GUILayout.Button("Loading"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = true;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = false;
                }
                if (GUILayout.Button("Naming"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = true;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = false;
                }
                if (GUILayout.Button("Errors"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = true;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = false;
                }
                GUILayout.EndHorizontal();
                GUILayout.BeginHorizontal();
                if (GUILayout.Button("Room"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = true;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = false;
                }
                if (GUILayout.Button("Countdown"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = true;
                    cl.e_show_misc      = false;
                }
                if (GUILayout.Button("Misc"))
                {
                    cl.e_events_oneTime = false;
                    cl.e_events_loading = false;
                    cl.e_events_naming  = false;
                    cl.e_events_errors  = false;
                    cl.e_events_room    = false;
                    cl.e_show_countdown = false;
                    cl.e_show_misc      = true;
                }
                EditorGUILayout.EndHorizontal();

                GUI.skin = _original;
                if (cl.e_events_oneTime == true)
                {
                    EditorGUILayout.HelpBox("This event is triggered only once when this object is first enabled. Called after OnAwake functions.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnStart);
                }
                else if (cl.e_events_loading == true)
                {
                    EditorGUILayout.HelpBox("Called right after a new Unity scene has successfully loaded.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnSceneLoaded);
                    EditorGUILayout.HelpBox("Called right when loading has started for the loading bar ui.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnStartLoading);
                    EditorGUILayout.HelpBox("Called right when the loading bar, in the loading ui, indicates that " +
                                            "the loading of the new scene has completed.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnCompleteLevelLoading);
                }
                else if (cl.e_events_naming == true)
                {
                    EditorGUILayout.HelpBox("When the user tries to enter an invalid name this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnNameEnterFailed);
                    EditorGUILayout.HelpBox("When the user enter a valid name this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnNameEnterSuccess);
                }
                else if (cl.e_events_errors == true)
                {
                    EditorGUILayout.HelpBox("Works only if you have enabled 'reconnect' in the NetworkManager. Called" +
                                            "whenever you're attempting to reconnect to your last room after having been disconnected.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnReconnecting);
                    EditorGUILayout.HelpBox("When any sort of network error happens this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnNetworkError);
                }
                else if (cl.e_events_room == true)
                {
                    EditorGUILayout.HelpBox("When you attempt to host a room and that room creation fails, this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnCreateRoomFailed);
                    EditorGUILayout.HelpBox("When you attempt to host a room and that room creation succeeds, this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnCreateRoomSuccess);
                    EditorGUILayout.HelpBox("As soon as you attempt to join a PhotonRoom from the UI, this is called.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnWaitToJoinPhotonRoomsLobby);
                }
                else if (cl.e_show_countdown == true)
                {
                    EditorGUILayout.HelpBox("When you recieve a STARTCOUNTDOWN event with a start timer of true, this is called with the countdown number you recieved.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnCountdownStarted);
                    EditorGUILayout.HelpBox("When you recieve a STARTCOUNTDOWN event with a start timer of false, this is called with the countdown number you recieved.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnCountdownStopped);
                }
                else if (cl.e_show_misc == true)
                {
                    EditorGUILayout.HelpBox("When you as the host start the session this is called. (Fired if calling the SendStartSession function).", MessageType.Info);
                    EditorGUILayout.PropertyField(OnStartSession);
                    EditorGUILayout.HelpBox("When you recieve a ROUNDTIME event with a time to set the round to. You can decide what to do with this time.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnReceiveRoundTime);
                    EditorGUILayout.HelpBox("When the \"ResetEverything\" function is called, this is executed.", MessageType.Info);
                    EditorGUILayout.PropertyField(OnResetEverything);
                }
                GUI.skin = _skin;
            }
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();
            GUILayout.Space(5);
            #endregion

            EndInspectorGUI(typeof(UICoreLogic));
        }
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            SyncItemCollection sic = (SyncItemCollection)target;
            DrawTitleBar(
                "Sync Item Collection",
                "Used to sync events from collecting this item across the network. \n\n" +
                "Required Setup Actions:\n" +
                "1. Copy the settings on the following fields from \"vItemCollection\" to this component:\n" +
                " * \"OnPressActionDelay\"\n" +
                " * \"OnPressActionInput\"\n" +
                " * \"OnPressActionInputWithTarget\"\n\n" +
                "2. On \"vItemCollection\" do the following:\n" +
                " * Set \"OnPressActionDelay\" to zero\n" +
                " * Remove all events from \"OnPressActionInput\"\n" +
                " * Remove all events from \"OnPressActionInputWithTarget\"\n",
                E_Core.h_genericIcon
                );
            #endregion

            #region Properties
            GUILayout.BeginHorizontal(GUI.skin.box, GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            EditorGUILayout.PropertyField(syncCrossScenes);
            if (syncCrossScenes.boolValue == true)
            {
                EditorGUILayout.PropertyField(holder, new GUIContent("Track Position"));
                EditorGUILayout.PropertyField(syncCreateDestroy, new GUIContent("Is Dynamic Obj"));
                if (syncCreateDestroy.boolValue == true)
                {
                    EditorGUILayout.PropertyField(resourcesPrefab);
                }
            }
            EditorGUILayout.PropertyField(skipStartCheck, new GUIContent("Items In ItemCollection"));
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();

            GUILayout.BeginHorizontal(GUI.skin.box, GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            EditorGUILayout.PropertyField(onPressActionDelay);
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();

            GUILayout.BeginHorizontal(GUI.skin.box, GUILayout.ExpandHeight(false));
            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
            GUI.skin = _original;
            CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
            EditorGUILayout.HelpBox("These should be copied exactly from the vItemColletion component.", MessageType.None);
            EditorGUILayout.PropertyField(OnPressActionInput);
            EditorGUILayout.PropertyField(onPressActionInputWithTarget);

            EditorGUILayout.HelpBox("This is called when this object was actived by another player " +
                                    "when previously in another scene. When you enter this scene this is called.", MessageType.None);
            EditorGUILayout.PropertyField(OnSceneEnterUpdate);

            GUI.skin = _skin;
            CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
            GUILayout.EndHorizontal();
            GUILayout.EndVertical();
            #endregion

            EndInspectorGUI(typeof(SyncItemCollection));
        }
Beispiel #13
0
        public override void OnInspectorGUI()
        {
            #region Core
            base.OnInspectorGUI();
            NetworkManager nm = (NetworkManager)target;
            DrawTitleBar(
                "Network Manager",
                "Persistant component that is used to control network events like players joining, disconnects, lobby management, etc.",
                E_Core.h_networkIcon
                );
            #endregion

            #region Universal Settings
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.Label(EditorGUIUtility.FindTexture("BuildSettings.Web.Small"), GUILayout.ExpandWidth(false));
            GUILayout.BeginVertical();
            GUILayout.Space(9);
            GUILayout.Label("Universal Settings", _skin.textField);
            GUILayout.EndVertical();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                nm.e_show_unv = !nm.e_show_unv;
            }
            GUILayout.EndHorizontal();
            if (nm.e_show_unv)
            {
                GUILayout.BeginHorizontal(_skin.customStyles[1]);
                GUILayout.BeginVertical();
                EditorGUILayout.PropertyField(gameVersion, new GUIContent("Game Version"));
                GUILayout.BeginHorizontal();
                if (maxPlayerPerRoom.intValue < 2)
                {
                    GUILayout.Label(EditorGUIUtility.FindTexture("CollabError"), GUILayout.ExpandWidth(false), GUILayout.Height(15));
                }
                EditorGUILayout.IntSlider(maxPlayerPerRoom, 0, 255, new GUIContent("Players Per Room"));
                GUILayout.EndHorizontal();
                EditorGUILayout.PropertyField(syncScenes);
                EditorGUILayout.PropertyField(replayScenes);
                EditorGUILayout.PropertyField(database);
                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
            }
            EditorGUILayout.Space();
            #endregion

            #region Player Settings
            EditorGUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.Label(EditorGUIUtility.FindTexture("SoftlockInline"), GUILayout.ExpandWidth(false));
            GUILayout.BeginVertical();
            GUILayout.Space(10);
            GUILayout.Label("Player Settings", _skin.GetStyle("TextField"));
            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                nm.e_show_player = !nm.e_show_player;
            }
            EditorGUILayout.EndHorizontal();

            if (nm.e_show_player)
            {
                EditorGUILayout.BeginHorizontal(_skin.customStyles[1]);
                GUILayout.BeginVertical();
                EditorGUILayout.PropertyField(playerPrefab);
                EditorGUILayout.PropertyField(voiceRecorder);
                EditorGUILayout.PropertyField(allowTeamDamaging);
                EditorGUILayout.HelpBox("Read the tooltip before setting the team name.", MessageType.Info);
                EditorGUILayout.PropertyField(teamName);

                GUI.skin = _original;
                GUIStyle foldoutStyle = CBEditor.GetEditorStyle(_skin.textArea, EditorStyles.foldout);
                _displayTeams = EditorGUILayout.Foldout(_displayTeams, "Initial Team Spawn Point Names", foldoutStyle);
                GUI.skin      = _skin;
                if (_displayTeams == true)
                {
                    EditorGUILayout.BeginHorizontal(_skin.box);
                    EditorGUILayout.BeginVertical();

                    EditorGUILayout.BeginHorizontal();
                    //EditorGUILayout.Space();
                    //EditorGUILayout.Space();
                    //EditorGUILayout.Space();
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = _skin.textArea.normal.textColor;
                    EditorGUILayout.LabelField("Team Name", GUI.skin.label, GUILayout.Width(73));
                    GUILayout.FlexibleSpace();
                    EditorGUILayout.LabelField("Starting Spawn Name", GUI.skin.label, GUILayout.Width(130));
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.BeginHorizontal();
                    if (GUILayout.Button(new GUIContent("+")))
                    {
                        _addNewTeam = true;
                    }
                    GUI.skin      = _skin;
                    _newTeamName  = EditorGUILayout.TextField(_newTeamName);
                    _newTeamSpawn = EditorGUILayout.TextField(_newTeamSpawn);
                    EditorGUILayout.EndHorizontal();

                    if (_addNewTeam == true)
                    {
                        _addNewTeam = false;

                        nm.initalTeamSpawnPointNames.Add(_newTeamName, _newTeamSpawn);
                        _newTeamName  = "";
                        _newTeamSpawn = "";
                    }

                    EditorGUILayout.BeginHorizontal(_skin.box);
                    EditorGUILayout.BeginVertical();
                    EditorGUILayout.LabelField("Initial Team Spawn Names", _skin.label);
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = _skin.textArea.normal.textColor;
                    foreach (KeyValuePair <string, string> item in nm.initalTeamSpawnPointNames)
                    {
                        EditorGUILayout.BeginHorizontal();
                        if (GUILayout.Button(new GUIContent("-"), GUILayout.Width(20)))
                        {
                            nm.initalTeamSpawnPointNames.Remove(item.Key);
                            break;
                        }
                        EditorGUILayout.LabelField(item.Key, GUI.skin.label, GUILayout.MinWidth(73));
                        EditorGUILayout.LabelField(item.Value, GUI.skin.label, GUILayout.MinWidth(110));
                        EditorGUILayout.EndHorizontal();
                    }
                    GUI.skin = _skin;
                    EditorGUILayout.EndVertical();
                    EditorGUILayout.EndHorizontal();

                    EditorGUILayout.EndVertical();
                    EditorGUILayout.EndHorizontal();
                }

                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
            }
            EditorGUILayout.Space();
            #endregion

            #region Spawn Settings
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.Label(EditorGUIUtility.FindTexture("AvatarPivot"), GUILayout.ExpandWidth(false));
            GUILayout.BeginVertical();
            GUILayout.Space(10);
            GUILayout.Label("Spawning Settings", _skin.GetStyle("TextField"));
            GUILayout.EndVertical();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                nm.e_show_spawn = !nm.e_show_spawn;
            }
            GUILayout.EndHorizontal();

            if (nm.e_show_spawn)
            {
                GUILayout.BeginHorizontal(_skin.customStyles[1]);
                GUILayout.BeginVertical();
                EditorGUILayout.PropertyField(autoSpawnPlayer);
                GUILayout.BeginHorizontal();
                if (nm.defaultSpawnPoint == null && nm.spawnPointsTag == "")
                {
                    GUILayout.Label(EditorGUIUtility.FindTexture("CollabError"), GUILayout.ExpandWidth(false), GUILayout.Height(15));
                }
                else if (nm.defaultSpawnPoint == null && nm.spawnPointsTag != "")
                {
                    GUILayout.Label(EditorGUIUtility.FindTexture("d_console.warnicon.sml"), GUILayout.ExpandWidth(false), GUILayout.Height(19));
                }
                EditorGUILayout.PropertyField(defaultSpawnPoint, new GUIContent("Default Spawn Point"));
                GUILayout.EndHorizontal();

                GUILayout.BeginHorizontal();
                if (nm.spawnPointsTag == "" && nm.defaultSpawnPoint != null)
                {
                    GUILayout.Label(EditorGUIUtility.FindTexture("d_console.warnicon.sml"), GUILayout.ExpandWidth(false), GUILayout.Height(19));
                }
                else if (nm.spawnPointsTag == "" && nm.defaultSpawnPoint == null)
                {
                    GUILayout.Label(EditorGUIUtility.FindTexture("CollabError"), GUILayout.ExpandWidth(false), GUILayout.Height(15));
                }
                EditorGUILayout.PropertyField(spawnPointsTag, new GUIContent("Available Spawn Tag"));
                GUILayout.EndHorizontal();
                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
            }
            EditorGUILayout.Space();
            #endregion

            #region Debug Settings
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.Label(EditorGUIUtility.FindTexture("d_Settings"), GUILayout.ExpandWidth(false));
            GUILayout.BeginVertical();
            GUILayout.Space(9);
            GUILayout.Label("Debug Settings", _skin.GetStyle("TextField"));
            GUILayout.EndVertical();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                nm.e_show_debug = !nm.e_show_debug;
            }
            GUILayout.EndHorizontal();
            if (nm.e_show_debug)
            {
                GUILayout.BeginHorizontal(_skin.customStyles[1]);
                GUILayout.BeginVertical();
                EditorGUILayout.PropertyField(debugging, new GUIContent("Verbose Console Logging"));
                EditorGUILayout.PropertyField(connectStatus, new GUIContent("Connection Status"));
                EditorGUILayout.PropertyField(displayDebugWindow);
                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
                EditorGUILayout.Space();
            }
            EditorGUILayout.Space();
            #endregion

            #region Network Settings
            GUILayout.BeginHorizontal(_skin.customStyles[1]);
            GUILayout.Label(EditorGUIUtility.FindTexture("vcs_branch"), GUILayout.ExpandWidth(false));
            GUILayout.BeginVertical();
            GUILayout.Space(9);
            GUILayout.Label("Network Events", _skin.textField);
            GUILayout.EndVertical();
            if (GUILayout.Button(EditorGUIUtility.FindTexture("d_AnimationWrapModeMenu"), _skin.label, GUILayout.Width(50)))
            {
                nm.e_show_network = !nm.e_show_network;
            }
            GUILayout.EndHorizontal();
            if (nm.e_show_network)
            {
                GUILayout.BeginHorizontal(_skin.customStyles[1]);
                GUILayout.BeginVertical();
                EditorGUILayout.PropertyField(reconnect);
                EditorGUILayout.PropertyField(connect_attempts);
                EditorGUILayout.PropertyField(spawnAtSaved);

                CBEditor.SetColorToEditorStyle(_originalHolder, _originalFoldout);
                GUILayout.BeginHorizontal();
                if (GUILayout.Button("Lobby", _skin.button))
                {
                    _displayLobbyEvents  = true;
                    _displayMiscEvents   = false;
                    _displayPlayerEvents = false;
                    _displayRoomEvents   = false;
                }
                if (GUILayout.Button("Room", _skin.button))
                {
                    _displayLobbyEvents  = false;
                    _displayMiscEvents   = false;
                    _displayPlayerEvents = false;
                    _displayRoomEvents   = true;
                }
                if (GUILayout.Button("Player", _skin.button))
                {
                    _displayLobbyEvents  = false;
                    _displayMiscEvents   = false;
                    _displayPlayerEvents = true;
                    _displayRoomEvents   = false;
                }
                if (GUILayout.Button("Misc", _skin.button))
                {
                    _displayLobbyEvents  = false;
                    _displayMiscEvents   = true;
                    _displayPlayerEvents = false;
                    _displayRoomEvents   = false;
                }
                GUILayout.EndHorizontal();
                if (_displayLobbyEvents == true)
                {
                    GUILayout.BeginVertical("window", GUILayout.ExpandHeight(false));
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = Color.black;
                    EditorGUILayout.PropertyField(onJoinedLobby);
                    EditorGUILayout.PropertyField(onLeftLobby);
                    GUI.skin = _skin;
                    GUILayout.EndHorizontal();
                }
                if (_displayRoomEvents == true)
                {
                    GUILayout.BeginVertical("window");
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = Color.black;
                    EditorGUILayout.PropertyField(onJoinedRoom);
                    EditorGUILayout.PropertyField(onLeftRoom);
                    EditorGUILayout.PropertyField(onCreatedRoom);
                    EditorGUILayout.PropertyField(onCreateRoomFailed);
                    EditorGUILayout.PropertyField(onJoinRoomFailed);
                    EditorGUILayout.PropertyField(onReconnecting);
                    GUI.skin = _skin;
                    GUILayout.EndVertical();
                }
                if (_displayPlayerEvents == true)
                {
                    GUILayout.BeginVertical("window");
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = Color.black;
                    EditorGUILayout.PropertyField(onPlayerEnteredRoom);
                    EditorGUILayout.PropertyField(onPlayerLeftRoom);
                    GUI.skin = _skin;
                    GUILayout.EndVertical();
                }
                if (_displayMiscEvents == true)
                {
                    GUILayout.BeginVertical("window");
                    GUI.skin = _original;
                    GUI.skin.label.normal.textColor = Color.black;
                    EditorGUILayout.PropertyField(onMasterClientSwitched);
                    EditorGUILayout.PropertyField(onDisconnected);
                    EditorGUILayout.PropertyField(onConnectedToMaster);
                    EditorGUILayout.PropertyField(onFailedToConnectToPhoton);
                    EditorGUILayout.PropertyField(onConnectionFail);
                    GUI.skin = _skin;
                    GUILayout.EndVertical();
                }
                CBEditor.SetColorToEditorStyle(_skinHolder, _skinHolder);
                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
            }
            EditorGUILayout.Space();
            #endregion

            EndInspectorGUI(typeof(NetworkManager));
        }