GenerateGameStubProjectCommand.hpp

Go to the documentation of this file.

#pragma once
 
#include <Strings/components/logger/logger.h>
#include <Strings/components/utils/io/io.h>
#include <Strings/components/utils/string/string.h>
#include <Strings/components/utils/list/list.h>
#include <Strings/components/3rdparty/rapidxml/rapidxml.hpp>
#include <HEKGuerilla/components/projects/projects.h>
 
#include "../ToolCommand.hpp"
#include "../console.h"
#include "components/utils/utils.h"
 
#ifdef TOOL_LIB_EXPORTS
#define TOOL_LIB_API __declspec(dllexport) 
#else
#define TOOL_LIB_API __declspec(dllimport) 
#endif
 
#define VC_DEBUG_WIN32 0
#define VC_DEBUG_WIN64 1
#define VC_RELEASE_WIN32 2
#define VC_RELEASE_WIN64 3
 
class TOOL_LIB_API GenerateGameStubProjectCommand : public ToolCommand
{
private:
    std::vector<std::string> reserved_lib_names = {
        "blam.lib",
        "Strings.lib",
        "HEKGuerilla.lib",
        "HEKTool.lib",
        "HEKSapien.lib",
        "HEKFoundry.lib",
        "keystone.lib"
    };
 
    std::string include_path_placeholders[4] = { 
        "{$__INCLUDE_DIRS_DW32__}", 
        "{$__INCLUDE_DIRS_DW64__}",
        "{$__INCLUDE_DIRS_RW32__}",
        "{$__INCLUDE_DIRS_RW64__}" 
    };
 
    std::string lib_name_placeholders[4] = {
        "{$__GAME_LIB_DW32__}",
        "{$__GAME_LIB_DW64__}",
        "{$__GAME_LIB_RW32__}",
        "{$__GAME_LIB_RW64__}"
    };
 
    std::string lib_path_placeholders[4] = {
        "{$__LIBRARY_DIRS_DW32__}",
        "{$__LIBRARY_DIRS_DW64__}",
        "{$__LIBRARY_DIRS_RW32__}",
        "{$__LIBRARY_DIRS_RW64__}"
    };
 
    std::string dep_dir_placeholders[4] = {
        "{$__DEP_DIR_DW32__}",
        "{$__DEP_DIR_DW64__}",
        "{$__DEP_DIR_RW32__}",
        "{$__DEP_DIR_RW64__}"
    };
 
    std::string engine_lib_dir_suffixes[4] = {
        "tag debug/Win32",
        "tag debug/x64",
        "cache release/Win32",
        "cache release/x64"
    };
 
    std::string vcx_library_paths[4] = { "", "", "", "" };
    std::string vcx_library_names[4] = { "", "", "", "" };
 
    std::string game_libs = "blam.lib;SDL2.lib;Strings.lib";
    std::string delay_load_dlls = "blam.dll;SDL2.dll;Strings.dll";
    std::string delay_load_dlls_placeholder = "{$__DELAY_DLLS__}";
 
    bool verbose = false;
    bool no_msbuild_warning = false;
    bool skip_path_gen = false;
 
    std::vector<std::string> PreprocessArgs(std::vector<std::string> args)
    {
        std::vector<std::string> processed_args = std::vector<std::string>();
 
        for (int i = 0; i < args.size(); i++)
        {
            if (args[i] == "-verbose")
            {
                verbose = true;
            }
            else if (args[i] == "-no-msbuild-warning")
            {
                no_msbuild_warning = true;
            }
            else if (args[i] == "-skip-path-gen")
            {
                skip_path_gen = true;
            }
            else
            {
                processed_args.push_back(args[i]);
            }
        }
 
        return processed_args;
    }
 
public:
    GenerateGameStubProjectCommand()
    {
        command = "generate-game-stub-project";
        syntax = "generate-game-stub-project [project filename] [-verbose] [-no-msbuild-warning] [-skip-path-gen]";
        description = "generates a stub vcxproj for the current game project";
    }
 
    int execute(std::vector<std::string> args)
    {
        args = PreprocessArgs(args);
 
        std::string project_root = BlamTool::Utils::GetProjectRoot();
        std::string project_filename = BlamStrings::Utils::IO::GetFileNameWithoutExtension(project_root) + ".blam";
 
        if (args.size() > 0)
        {
            project_filename = args[0];
        }
 
        BlamProject* project = Guerilla::Projects::LoadProject(project_root + project_filename);
 
        if (!project->IsLoaded())
        {
            BlamStrings::Logger::LogEvent("failed to create stub project: could not load project info (tried to "
                "read from file path: " + project_root + project_filename + ")", WSV_ERROR);
 
            if (args.size() == 0)
            {
                BlamStrings::Logger::LogEvent("project path was assumed from directory path - if your .blam file "
                    "has a different name, use " + syntax + " to specify the filename", WSV_WARNING);
            }
 
            delete project;
            return -1;
        }
 
        std::string source_path = "./content/blam/default_stub_project";
        std::string destination_path = project_root + "_build/_internal/game";
        
        std::string copy_cmd = "XCOPY \"" + source_path + "\" \"" + destination_path + "\" /S /I /Y";
        if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + copy_cmd);
        int copy_result = system(copy_cmd.c_str());
 
        if (copy_result < 0)
        {
            BlamStrings::Logger::LogEvent("failed to create stub project: xcopy returned " + std::to_string(copy_result)
                + " -- full xcopy command:", WSV_ERROR);
            BlamStrings::Logger::LogEvent(copy_cmd, WSV_ERROR);
            delete project;
            return copy_result;
        }
 
        if (!IdentifyVcxprojInfo(project->GetVcxprojPath(), project))
        {
            BlamStrings::Logger::LogEvent("failed to read data from vcxproj - see log for details", WSV_ERROR);
            delete project;
            return -1;
        }
 
        if (verbose) BlamStrings::Logger::LogEvent("configuring vcxproj: " + destination_path + "/game.vcxproj");
 
        std::string vcxproj_file_contents = BlamStrings::Utils::IO::GetFileContentsAsString(destination_path + "/game.vcxproj");
 
        for (int i = 0; i < 4; i++)
        {
            std::string engine_dep_path = project->GetEngineDependenciesPath() + "/" + engine_lib_dir_suffixes[i] + "/";
            std::string engine_include_path = project->GetEngineDependenciesPath() + "/include/";
            std::string project_include_root = BlamStrings::Utils::IO::GetAbsolutePathFromRelative(project_root);
 
            vcxproj_file_contents = str_replace(vcxproj_file_contents, include_path_placeholders[i], engine_include_path + ";" + project_include_root);
            vcxproj_file_contents = str_replace(vcxproj_file_contents, lib_name_placeholders[i], vcx_library_names[i] + ";" + game_libs);
            vcxproj_file_contents = str_replace(vcxproj_file_contents, lib_path_placeholders[i],
                vcx_library_paths[i] + ";" + engine_dep_path + "/lib");
            vcxproj_file_contents = str_replace(vcxproj_file_contents, dep_dir_placeholders[i], engine_dep_path + "/data");
        }
 
        vcxproj_file_contents = str_replace(vcxproj_file_contents, delay_load_dlls_placeholder, delay_load_dlls);
 
        BlamStrings::Utils::IO::CreateNewFile(destination_path + "/game.vcxproj", vcxproj_file_contents);
 
        if (verbose) BlamStrings::Logger::LogEvent("game project generated to " + destination_path);
        BlamStrings::Logger::LogEvent("finished");
 
        delete project;
        return 0;
    }
 
    bool IdentifyVcxprojInfo(std::string vcxproj_path, BlamProject* project)
    {
        std::string library_file_name = BlamStrings::Utils::IO::GetFileNameWithoutExtension(vcxproj_path);
 
        for (int i = 0; i < 4; i++)
        {
            vcx_library_names[i] = library_file_name + ".lib";
        }
 
        if (!no_msbuild_warning)
        {
            BlamStrings::Logger::LogEvent("##################################################################################", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("TOOL WILL NOW RUN MSBUILD AS NEEDED IN ORDER TO RUN PRE-BUILD STEPS", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("If you want to terminate this process, press Ctrl+C NOW (you have 8 seconds from this message)!", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("----------------------------------------------------------------------------------", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("Note that the build itself may produce errors or fail outright - this will", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("not affect the stub project generation process, as we only need the pre-build", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("step to run in order to generate library paths that we can read.", TerminalColor::Magenta);
            BlamStrings::Logger::LogEvent("##################################################################################", TerminalColor::Magenta);
            Sleep(8000);
        }
 
        std::string msbuild_path_base = "\"" + project->GetMSBuildPath() + "\" \"" + vcxproj_path + "\" ";
 
        if (!BlamStrings::Utils::IO::IsDirectory(project->project_root + "_build/_internal/paths/Debug_x64") || !skip_path_gen)
        {
            BlamStrings::Logger::LogEvent("running msbuild with Debug|x64 config to generate build path files...");
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"Debug\" /p:Platform=\"x64\"" + "\"";
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            system(cmd.c_str());
        }
        
        if (!BlamStrings::Utils::IO::IsDirectory(project->project_root + "_build/_internal/paths/Debug_Win32") || !skip_path_gen)
        {
            BlamStrings::Logger::LogEvent("running msbuild with Debug|Win32 config to generate build path files...");
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"Debug\" /p:Platform=\"Win32\"" + "\"";
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            system(cmd.c_str());
        }
 
        if (!BlamStrings::Utils::IO::IsDirectory(project->project_root + "_build/_internal/paths/Release_x64") || !skip_path_gen)
        {
            BlamStrings::Logger::LogEvent("running msbuild with Release|x64 config to generate build path files...");
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"Release\" /p:Platform=\"x64\"" + "\"";
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            system(cmd.c_str());
        }
 
        if (!BlamStrings::Utils::IO::IsDirectory(project->project_root + "_build/_internal/paths/Release_Win32") || !skip_path_gen)
        {
            BlamStrings::Logger::LogEvent("running msbuild with Release|Win32 config to generate build path files...");
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"Release\" /p:Platform=\"Win32\"" + "\"";
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            system(cmd.c_str());
        }
 
        std::string required_files[] = {
            project->project_root + "_build/_internal/paths/Debug_Win32/OUT_DIR",
            project->project_root + "_build/_internal/paths/Debug_Win32/TARGET_FILE_NAME",
            project->project_root + "_build/_internal/paths/Debug_x64/OUT_DIR",
            project->project_root + "_build/_internal/paths/Debug_x64/TARGET_FILE_NAME",
            project->project_root + "_build/_internal/paths/Release_Win32/OUT_DIR",
            project->project_root + "_build/_internal/paths/Release_Win32/TARGET_FILE_NAME",
            project->project_root + "_build/_internal/paths/Release_x64/OUT_DIR",
            project->project_root + "_build/_internal/paths/Release_x64/TARGET_FILE_NAME",
        };
 
        for (int i = 0; i < 8; i++)
        {
            if (!BlamStrings::Utils::IO::FileExists(required_files[i]))
            {
                BlamStrings::Logger::LogEvent("cannot read detected vcxproj file paths: file "
                    "does not exist -- " + required_files[i], WSV_ERROR);
                return false;
            }
        }
 
        vcx_library_paths[VC_DEBUG_WIN32] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[0]);
        vcx_library_names[VC_DEBUG_WIN32] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[1]);
 
        vcx_library_paths[VC_DEBUG_WIN64] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[2]);
        vcx_library_names[VC_DEBUG_WIN64] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[3]);
 
        vcx_library_paths[VC_RELEASE_WIN32] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[4]);
        vcx_library_names[VC_RELEASE_WIN32] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[5]);
 
        vcx_library_paths[VC_RELEASE_WIN64] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[6]);
        vcx_library_names[VC_RELEASE_WIN64] = BlamStrings::Utils::IO::GetFileContentsAsString(required_files[7]);
 
        for (int i = 0; i < 4; i++)
        {
            if (vcx_library_paths[i].ends_with(" \n"))
            {
                vcx_library_paths[i] = vcx_library_paths[i].substr(0, vcx_library_paths[i].length() - 2);
            }
 
            if (vcx_library_names[i].ends_with(" \n"))
            {
                vcx_library_names[i] = vcx_library_names[i].substr(0, vcx_library_names[i].length() - 2);
            }
 
            if (BlamStrings::Utils::List::Contains<std::string>(reserved_lib_names, vcx_library_names[i]))
            {
                BlamStrings::Logger::LogEvent("game script library name '" + vcx_library_names[i] + "' matches "
                    "an internal library used by blamite, this may cause build errors.", WSV_WARNING);
                BlamStrings::Logger::LogEvent("you can resolve this by changing the target name in Visual Studio.", WSV_WARNING);
            }
        }
 
        return true;
    }
};