private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => $"Player {Controller.Owner.Name} Climbing Component");
     _debugMenuNode.RenderContentsAction = () => {
         _breakOnFall = GUILayout.Toggle(_breakOnFall, "Break on fall");
     };
 }
Beispiel #2
0
        private void InitDebugMenu()
        {
            _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssjAug2018.MailboxManager");
            _debugMenuNode.RenderContentsAction = () => {
                if (NetworkServer.active)
                {
                    if (GUIUtils.LayoutButton("Force Complete"))
                    {
                        CompleteAllMailboxes();
                    }

                    GUILayout.Label($"Current seed position: {_seedPosition}");
                    if (null != _seedBox)
                    {
                        GUILayout.Label($"Current seed mailbox: {_seedBox.name} {_seedBox.transform.position}");
                    }
                    GUILayout.Label($"Current set size: {CurrentSetSize}");
                    GUILayout.BeginVertical("Active mailboxes", GUI.skin.box);
                    foreach (Mailbox mailbox in _activeMailboxes)
                    {
                        GUILayout.Label($"{mailbox.name} {mailbox.transform.position}");
                    }
                    GUILayout.EndVertical();
                    GUILayout.Label($"Completed mailboxes: {CompletedMailboxes}");
                }
            };
        }
Beispiel #3
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => $"Character {Behavior.Owner.Id} Climbing Component");
     _debugMenuNode.RenderContentsAction = () => {
         _breakOnFall = GUILayout.Toggle(_breakOnFall, "Break on fall");
     };
 }
Beispiel #4
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Game.HighScoreManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("High Scores", GUI.skin.box);
                StringBuilder builder = new StringBuilder("Rank\tName\tScore\tPlayers");
                foreach (string extra in _extras)
                {
                    builder.Append($"\t{extra}");
                }
                GUILayout.Label(builder.ToString());

                int i = 1;
                foreach (HighScoreEntry highScore in HighScores)
                {
                    builder.Clear();

                    builder.Append($"{i}\t");
                    builder.Append($"{highScore.playerName}\t");
                    builder.Append($"{highScore.score}\t");
                    builder.Append($"{highScore.playerCount}");

                    foreach (string extra in _extras)
                    {
                        builder.Append($"\t{highScore.extra.GetOrDefault(extra)}");
                    }

                    GUILayout.Label(builder.ToString());

                    i++;
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #5
0
        private void InitDebugMenu()
        {
            _debugMenuNode = DebugMenuManager.Instance.AddNode(() => $"Game.Player {Player.Id} Input");
            _debugMenuNode.RenderContentsAction = () => {
                /*GUILayout.BeginHorizontal();
                 *  GUILayout.Label("Mouse Sensitivity:");
                 *  _mouseSensitivity = GUIUtils.FloatField(_mouseSensitivity);
                 * GUILayout.EndHorizontal();*/

                if (Application.isEditor)
                {
                    EnableMouseLook = GUILayout.Toggle(EnableMouseLook, "Enable Mouse Look");
                }

                GUILayout.BeginVertical("Move Buffer", GUI.skin.box);
                foreach (var move in _moveBuffer)
                {
                    GUILayout.Label(move.ToString());
                }
                GUILayout.EndVertical();

                GUILayout.BeginVertical("Look Buffer", GUI.skin.box);
                foreach (var look in _lookBuffer)
                {
                    GUILayout.Label(look.ToString());
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #6
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssj2019.NPCManager");
     _debugMenuNode.RenderContentsAction = () => {
         _dumbBrawlers = GUILayout.Toggle(_dumbBrawlers, "Dumb Brawlers");
     };
 }
Beispiel #7
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "GameStateManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.Label($"Current Game State: {CurrentState.name}");
            };
        }
Beispiel #8
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ggj2019.Home.Hive");
     _debugMenuNode.RenderContentsAction = () => {
         _immune      = GUILayout.Toggle(_immune, "Immune");
         _logBeeSpawn = GUILayout.Toggle(_logBeeSpawn, "Log Bee Spawn");
     };
 }
Beispiel #9
0
 private void DestroyDebugMenu()
 {
     if (DebugMenuManager.HasInstance)
     {
         DebugMenuManager.Instance.RemoveNode(_debugMenuNode);
     }
     _debugMenuNode = null;
 }
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssjAug2018.GameStateManager");

            debugMenuNode.RenderContentsAction = () => {
                if (null != NetworkClient)
                {
                    GUILayout.BeginVertical("Client Stats", GUI.skin.box);
                    GUILayout.Label($"Ping: {NetworkClient.GetRTT()}ms");

                    int numMsgs, numBytes;
                    NetworkClient.GetStatsIn(out numMsgs, out numBytes);
                    GUILayout.Label($"Messages received: {numMsgs}");
                    GUILayout.Label($"Bytes received: {numBytes}");

                    int numBufferedMsgs, lastBufferedPerSecond;
                    NetworkClient.GetStatsOut(out numMsgs, out numBufferedMsgs, out numBytes, out lastBufferedPerSecond);
                    GUILayout.Label($"Messages sent: {numMsgs}");
                    GUILayout.Label($"Messages buffered: {numBufferedMsgs}");
                    GUILayout.Label($"Bytes sent: {numBytes}");
                    GUILayout.Label($"Messages buffered per second: {lastBufferedPerSecond}");
                    GUILayout.EndVertical();
                }

                if (NetworkServer.active)
                {
                    GUILayout.BeginVertical("Server Stats", GUI.skin.box);
                    int numMsgs, numBytes;
                    NetworkServer.GetStatsIn(out numMsgs, out numBytes);
                    GUILayout.Label($"Messages received: {numMsgs}");
                    GUILayout.Label($"Bytes received: {numBytes}");

                    int numBufferedMsgs, lastBufferedPerSecond;
                    NetworkServer.GetStatsOut(out numMsgs, out numBufferedMsgs, out numBytes, out lastBufferedPerSecond);
                    GUILayout.Label($"Messages sent: {numMsgs}");
                    GUILayout.Label($"Messages buffered: {numBufferedMsgs}");
                    GUILayout.Label($"Bytes sent: {numBytes}");
                    GUILayout.Label($"Messages buffered per second: {lastBufferedPerSecond}");
                    GUILayout.EndVertical();
                }

                foreach (string sceneName in _sceneTesterStatePrefab.TestScenes)
                {
                    if (GUIUtils.LayoutButton($"Load Test Scene {sceneName}"))
                    {
                        TransitionToInitialState(null, () => {
                            PushSubState(_networkConnectStatePrefab, connectState => {
                                connectState.Initialize(NetworkConnect.ConnectType.SinglePlayer, _sceneTesterStatePrefab, state => {
                                    SceneTester sceneTester = (SceneTester)state;
                                    sceneTester.SetScene(sceneName);
                                });
                            });
                        });
                        break;
                    }
                }
            };
        }
Beispiel #11
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "TimeManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.Label($"Current Unix Seconds: {CurrentUnixSeconds}");
                GUILayout.Label($"Current Unix Milliseconds: {CurrentUnixMs}");
            };
        }
Beispiel #12
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => $"ggj2021.ShephardBehavior {Owner.Id}");
     _debugMenuNode.RenderContentsAction = () => {
         GUILayout.Label($"Carrying sheep: {CarryingSheep}");
         GUILayout.Label($"Has capacity: {HasCapacity}");
         GUILayout.Label($"Can grab sheep: {CanGrab}");
         GUILayout.Label($"Can launch sheep: {CanLaunch}");
     };
 }
Beispiel #13
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssj2019.Level");
     _debugMenuNode.RenderContentsAction = () => {
         if (GUIUtils.LayoutButton("Spawn Training Dummy"))
         {
             SpawnTrainingDummy();
         }
     };
 }
Beispiel #14
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ViewerManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("Viewers", GUI.skin.box);
                GUILayout.Label($"Total Viewers: {_viewers.Count}");
                GUILayout.Label($"Assigned Viewers: {_assignedViewers.Count}");
                GUILayout.Label($"Unassigned Viewers: {_unassignedViewers.Count}");
                GUILayout.EndVertical();
            };
        }
Beispiel #15
0
 private void InitDebugMenu()
 {
     _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssjAug2018.PlayerManager");
     _debugMenuNode.RenderContentsAction = () => {
         GUILayout.BeginVertical("Players", GUI.skin.box);
         foreach (Player player in Actors)
         {
             GUILayout.Label($"{player.name} {player.transform.position}");
         }
         GUILayout.EndVertical();
     };
 }
Beispiel #16
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "SceneManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("Loaded Scenes", GUI.skin.box);
                foreach (string loadedScene in _loadedScenes)
                {
                    GUILayout.Label(loadedScene);
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #17
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.TimeManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.Label($"Current Unix Seconds: {CurrentUnixSeconds}");
                GUILayout.Label($"Current Unix Milliseconds: {CurrentUnixMs}");

                // TODO: print timers

                // TODO: print stopwatches
            };
        }
Beispiel #18
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Game.HighScoreManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("High Scores", GUI.skin.box);
                foreach (HighScore highScore in HighScores)
                {
                    GUILayout.Label($"{highScore.playerName} {highScore.playerCount} {highScore.score}");
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #19
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Game.GameStateManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.Label($"Current Game State: {CurrentState?.Name}");

                if (GUIUtils.LayoutButton("Reset"))
                {
                    TransitionToInitialState();
                }
            };
        }
Beispiel #20
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "ssjAug2018.UIManager");

            debugMenuNode.RenderContentsAction = () => {
                if (null != PlayerUI)
                {
                    if (GUIUtils.LayoutButton("Toggle HUD"))
                    {
                        PlayerUI.ToggleHUD();
                    }
                }
            };
        }
Beispiel #21
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "AudioManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("SFX", GUI.skin.box);
                GUILayout.Label("TODO");
                GUILayout.EndVertical();

                GUILayout.BeginVertical("Music", GUI.skin.box);
                GUILayout.Label($"Music Crossfade: {MusicCrossFade}");
                GUILayout.EndVertical();
            };
        }
Beispiel #22
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "InputManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("Joysticks", GUI.skin.box);
                var gamepads = GetGamepads();
                foreach (Gamepad gamepad in gamepads)
                {
                    GUILayout.Label(gamepad.name);
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #23
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.UIManager");

            debugMenuNode.RenderContentsAction = () => {
                _enableDebug = GUILayout.Toggle(_enableDebug, "Enable Debug");

                GUILayout.BeginVertical("UI Objects:", GUI.skin.box);
                foreach (var kvp in _uiObjects)
                {
                    GUILayout.Label(kvp.Key);
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #24
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.EffectsManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical();
                _enableAnimation     = GUILayout.Toggle(_enableAnimation, "Enable Animation");
                _enableAudio         = GUILayout.Toggle(_enableAudio, "Enable Audio");
                _enableVFX           = GUILayout.Toggle(_enableVFX, "Enable VFX");
                _enableShakePosition = GUILayout.Toggle(_enableShakePosition, "Enable Shake Position");
                _enableViewerShake   = GUILayout.Toggle(_enableViewerShake, "Enable Viewer Shake");
                _enableRumble        = GUILayout.Toggle(_enableRumble, "Enable Rumble");
                GUILayout.EndVertical();
            };
        }
Beispiel #25
0
        private void InitDebugMenu()
        {
            _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Game.NPCManager");
            _debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("NPCs", GUI.skin.box);
                foreach (INPC npc in _npcs)
                {
                    GUILayout.Label($"{npc.Id} {npc.Movement.Position}");
                }
                GUILayout.EndVertical();

                _npcsImmune       = GUILayout.Toggle(_npcsImmune, "NPCs Immune");
                _debugNPCBehavior = GUILayout.Toggle(_debugNPCBehavior, "Debug Behavior");
            };
        }
Beispiel #26
0
        private void InitDebugMenu()
        {
            _debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Game.PlayerManager");
            _debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("Players", GUI.skin.box);
                foreach (IPlayer player in _players)
                {
                    GUILayout.Label($"{player.Id} {player.Behavior.Movement.Position}");
                }
                GUILayout.EndVertical();

                _playersImmune = GUILayout.Toggle(_playersImmune, "Players Immune");
                _debugInput    = GUILayout.Toggle(_debugInput, "Debug Input");
            };
        }
Beispiel #27
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.ActorManager");

            debugMenuNode.RenderContentsAction = () => {
                foreach (var kvp in _actors)
                {
                    GUILayout.BeginVertical($"{kvp.Key}", GUI.skin.box);
                    foreach (Actor actor in kvp.Value)
                    {
                        GUILayout.Label($"{actor.Id} {actor.Behavior.Movement.Position}");
                    }
                    GUILayout.EndVertical();
                }
            };
        }
Beispiel #28
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.ViewerManager");

            debugMenuNode.RenderContentsAction = () => {
                foreach (var kvp in _viewers)
                {
                    ViewerSet viewerSet = kvp.Value;
                    GUILayout.BeginVertical($"{kvp.Key} Viewers", GUI.skin.box);
                    GUILayout.Label($"Total Viewers: {viewerSet.Viewers.Count}");
                    GUILayout.Label($"Assigned Viewers: {viewerSet.AssignedViewers.Count}");
                    GUILayout.Label($"Unassigned Viewers: {viewerSet.UnassignedViewers.Count}");
                    GUILayout.EndVertical();
                }
            };
        }
Beispiel #29
0
        private void InitDebugMenu()
        {
            DebugMenuNode debugMenuNode = DebugMenuManager.Instance.AddNode(() => "Core.ObjectPoolManager");

            debugMenuNode.RenderContentsAction = () => {
                GUILayout.BeginVertical("Object Pools:", GUI.skin.box);
                foreach (var kvp in _objectPools)
                {
                    GUILayout.BeginVertical(kvp.Key, GUI.skin.box);
                    GUILayout.Label($"Expandable: {kvp.Value.AllowExpand}");
                    GUILayout.Label($"Networked: {kvp.Value.IsNetwork}");
                    GUILayout.Label($"Size: {kvp.Value.Count} / {kvp.Value.Size} / {kvp.Value.TargetSize}");
                    GUILayout.EndVertical();
                }
                GUILayout.EndVertical();
            };
        }
Beispiel #30
0
        private void InitDebugMenu()
        {
            _debugMenuNode = DebugMenuManager.Instance.AddNode(() => $"Player {Player.name} Driver");
            _debugMenuNode.RenderContentsAction = () => {
                InvertLookY = GUILayout.Toggle(InvertLookY, "Invert Look Y");

                /*GUILayout.BeginHorizontal();
                 *  GUILayout.Label("Mouse Sensitivity:");
                 *  _mouseSensitivity = GUIUtils.FloatField(_mouseSensitivity);
                 * GUILayout.EndHorizontal();*/

                if (Application.isEditor)
                {
                    _enableMouseLook = GUILayout.Toggle(_enableMouseLook, "Enable Mouse Look");
                }
            };
        }