示例#1
0
        public void Start()
        {
            _debugUiIcon = Tools.LoadTexture(DebugIconPath);

            _mode        = EDebugMode.Other;
            _gameControl = this.GetComponent <GameControl>();
        }
示例#2
0
        private void OnGuiDebugMenu()
        {
            // DEBUG BUTTONS
            if (_showDebugGui)
            {
                GUI.BeginGroup(new Rect(0, toggleIconSize, guiMenuWidth, guiMenuHeight));

                if (GUI.Button(new Rect(0, 0 * buttonHeight, guiMenuWidth, buttonHeight), ActionSpawnAgentName))
                {
                    _mode = EDebugMode.SpawnAgent;
                }

                if (GUI.Button(new Rect(0, 1 * buttonHeight, guiMenuWidth, buttonHeight), ActionApplyDamageName))
                {
                    _mode = EDebugMode.ApplyDamage;
                }

                if (GUI.Button(new Rect(0, 2 * buttonHeight, guiMenuWidth, buttonHeight), Menu1ToggleName))
                {
                    _gameControl.SetMenu(1);
                }

                if (GUI.Button(new Rect(0, 3 * buttonHeight, guiMenuWidth, buttonHeight), Menu2ToggleName))
                {
                    _gameControl.SetMenu(2);
                }

                if (GUI.Button(new Rect(0, 4 * buttonHeight, guiMenuWidth, buttonHeight), Menu3ToggleName))
                {
                    _gameControl.SetMenu(3);
                }

                GUI.EndGroup();
            }

            // DEBUG ICON
            GUI.Box(new Rect(0, 0, toggleIconSize, toggleIconSize), _debugUiIcon);
            if (GUI.Button(new Rect(0, 0, toggleIconSize, toggleIconSize), new GUIContent("", ToggleDebugButtonName)))
            {
                if (_showDebugGui)
                {
                    _gameControl.DefaultMode();
                }
                else
                {
                    _gameControl.SetDebugMenu();
                }

                _showDebugGui = !_showDebugGui;
            }

            GUI.Label(new Rect(toggleIconSize + 5, 5, guiMenuWidth, guiMenuHeight), GUI.tooltip);
        }
示例#3
0
 public void ResetMode()
 {
     _mode         = EDebugMode.Other;
     _showDebugGui = false;
 }
示例#4
0
        private void WriteLaunchFile()
        {
            JsonFile   OutFile   = new JsonFile();
            EDebugMode DebugMode = (HostPlatform == UnrealTargetPlatform.Win64) ? EDebugMode.VS : EDebugMode.GDB;

            OutFile.BeginRootObject();
            {
                OutFile.AddField("version", "0.2.0");
                OutFile.BeginArray("configurations");
                {
                    List <ProjectFile> Projects = new List <ProjectFile>(GeneratedProjectFiles);
                    Projects.Sort((A, B) => { return(A.ProjectFilePath.GetFileNameWithoutExtension().CompareTo(B.ProjectFilePath.GetFileNameWithoutExtension())); });

                    foreach (ProjectFile Project in AllProjectFiles)
                    {
                        if (Project.ProjectFilePath.GetExtension() == ProjectFileExtension)
                        {
                            foreach (ProjectTarget Target in Project.ProjectTargets)
                            {
                                List <UnrealTargetConfiguration> Configs = new List <UnrealTargetConfiguration>();
                                Target.TargetRules.GetSupportedConfigurations(ref Configs, true);

                                foreach (UnrealTargetConfiguration Config in Configs)
                                {
                                    if (SupportedConfigurations.Contains(Config))
                                    {
                                        FileReference Executable = GetExecutableFilename(Project, Target, HostPlatform, Config);
                                        string        Name       = Target.TargetRules == null?Project.ProjectFilePath.GetFileNameWithoutExtension() : Target.TargetRules.Name;

                                        string LaunchTaskName      = $"{Name} {HostPlatform} {Config} Build";
                                        string ExecutableDirectory = "${workspaceRoot}/" + Executable.Directory.MakeRelativeTo(UnrealBuildTool.RootDirectory).ToString().Replace("\\", "/");

                                        OutFile.BeginObject();
                                        {
                                            OutFile.AddField("name", Target.TargetRules.Name + " (" + Config.ToString() + ")");
                                            OutFile.AddField("request", "launch");
                                            OutFile.AddField("preLaunchTask", LaunchTaskName);
                                            OutFile.AddField("program", ExecutableDirectory + "/" + Executable.GetFileName());

                                            OutFile.BeginArray("args");
                                            {
                                            }
                                            OutFile.EndArray();
                                            OutFile.AddField("stopAtEntry", true);
                                            OutFile.AddField("cwd", ExecutableDirectory);
                                            OutFile.BeginArray("environment");
                                            {
                                            }
                                            OutFile.EndArray();
                                            OutFile.AddField("externalConsole", true);

                                            switch (DebugMode)
                                            {
                                            case EDebugMode.VS:
                                            {
                                                OutFile.AddField("type", "cppvsdbg");
                                                break;
                                            }

                                            case EDebugMode.GDB:
                                            {
                                                OutFile.AddField("type", "cppdbg");
                                                OutFile.AddField("MIMode", "lldb");
                                                break;
                                            }
                                            }
                                        }
                                        OutFile.EndObject();
                                    }
                                }
                            }
                        }
                        else if (Project.ProjectFilePath.GetExtension() == ".csproj")
                        {
                            /*
                             * foreach (ProjectTarget Target in Project.ProjectTargets)
                             * {
                             *      foreach (UnrealTargetConfiguration Config in Target.ExtraSupportedConfigurations)
                             *      {
                             *              string TaskName = $"{Project.ProjectFilePath.GetFileNameWithoutExtension()} ({Config})";
                             *              string BuildTaskName = $"{Project.ProjectFilePath.GetFileNameWithoutExtension()} {HostPlatform} {Config} Build";
                             *              FileReference Executable = GetExecutableFilename(Project, Target, HostPlatform, Config);
                             *
                             *              OutFile.BeginObject();
                             *              {
                             *                      OutFile.AddField("name", TaskName);
                             *                      OutFile.AddField("type", "coreclr");
                             *                      OutFile.AddField("request", "launch");
                             *                      OutFile.AddField("preLaunchTask", BuildTaskName);
                             *                      OutFile.AddField("program", Executable.ToString());
                             *                      OutFile.BeginArray("args");
                             *                      {
                             *
                             *                      }
                             *                      OutFile.EndArray();
                             *              }
                             *              OutFile.EndObject();
                             *      }
                             * }
                             */
                        }
                    }
                }
                OutFile.EndArray();
            }
            OutFile.EndRootObject();

            OutFile.Write(FileReference.Combine(VSCodeDir, "launch.json"));
        }