BuildCommand.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 <Strings/components/classes/map/map.h>
#include <Strings/components/utils/converters/converters.h>
#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
 
class TOOL_LIB_API BuildCommand : public ToolCommand
{
private:
    bool verbose = false;
    bool rebuild_scripts = false;
    bool package = 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] == "-rebuild-scripts")
            {
                rebuild_scripts = true;
            }
            else if (args[i] == "-package")
            {
                package = true;
            }
            else
            {
                processed_args.push_back(args[i]);
            }
        }
 
        return processed_args;
    }
 
public:
    BuildCommand()
    {
        command = "build";
        syntax = "build <configuration> <platform> [project filename] [game vcxproj filepath] [-verbose] [-rebuild-scripts] [-package]";
        description = "builds the current project into a playable game executable";
    }
 
    int execute(std::vector<std::string> args)
    {
        args = PreprocessArgs(args);
 
        if (args.size() < 2)
        {
            BlamStrings::Logger::LogEvent("failed to build executable: you must supply a configuration and platform", WSV_ERROR);
            BlamStrings::Logger::LogEvent("syntax: " + syntax, WSV_ERROR);
            return -1;
        }
 
        std::string project_root = BlamTool::Utils::GetProjectRoot();
        std::string project_filename = BlamStrings::Utils::IO::GetFileNameWithoutExtension(project_root) + ".blam";
 
        if (args.size() > 2)
        {
            project_filename = args[2];
        }
 
        BlamProject* project_info = Guerilla::Projects::LoadProject(project_root + project_filename);
 
        if (!project_info->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_info;
            return -1;
        }
 
        std::string game_vcx_dir = project_root + "_build/_internal/game/";
        std::string game_vcx_path = game_vcx_dir + "game.vcxproj";
 
        if (args.size() > 3)
        {
            game_vcx_path = args[3];
        }
 
        if (project_info->cpp_script_info.pre_build_commands.length() > 0)
        {
            BlamStrings::Logger::LogEvent("running pre-build commands");
 
            std::string input = str_replace(project_info->cpp_script_info.pre_build_commands, "\r\n", "\n");
 
            for (std::string line : BlamStrings::Utils::String::Split(input, "\n"))
            {
                system(line.c_str());
            }
        }
 
        int build_result = 0;
 
        // Build game library
        if (rebuild_scripts)
        {
            std::string msbuild_path_base = "\"" + project_info->GetMSBuildPath() + "\" \"" + project_info->GetVcxprojPath() + "\" ";
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"" + args[0] + "\" /p:Platform=\"" + args[1] + "\"" + "\"";
 
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            build_result = system(cmd.c_str());
        }
 
        // Build game executable
        if (build_result >= 0)
        {
            if (!GenerateProjectInfoSourceFile(project_info, game_vcx_dir + "gameinfo.cpp", !package,
                BlamStrings::Utils::IO::GetAbsolutePathFromRelative(project_root)))
            {
                BlamStrings::Logger::LogEvent("failed to generate embedded game info file - CreateNewFile returned false", WSV_ERROR);
                delete project_info;
                return -1;
            }
 
            std::string msbuild_path_base = "\"" + project_info->GetMSBuildPath() + "\" \"" + game_vcx_path + "\" ";
            std::string cmd = "\"" + msbuild_path_base + "/p:Configuration=\"" + args[0] + "\" /p:Platform=\"" + args[1] + "\"" + "\"";
 
            if (verbose) BlamStrings::Logger::LogEvent("running system command :: " + cmd);
            build_result = system(cmd.c_str());
        }
 
        if (build_result < 0)
        {
            BlamStrings::Logger::LogEvent("build failed with code " + std::to_string(build_result) +  " - see log for details", WSV_ERROR);
            delete project_info;
            return build_result;
        }
 
        if (project_info->cpp_script_info.post_build_commands.length() > 0)
        {
            BlamStrings::Logger::LogEvent("running post-build commands");
 
            std::string input = str_replace(project_info->cpp_script_info.post_build_commands, "\r\n", "\n");
 
            for (std::string line : BlamStrings::Utils::String::Split(input, "\n"))
            {
                system(line.c_str());
            }
        }
 
        BlamStrings::Logger::LogEvent("finished");
 
        delete project_info;
        return 0;
    }
 
    bool GenerateProjectInfoSourceFile(BlamProject* project_info, std::string output_file, bool use_project_dirs, std::string project_root)
    {
        std::string template_file = BlamStrings::Utils::IO::GetFileContentsAsString("./content/blam/default_stub_project/gameinfo.cpp.template");
 
        BlamMap<std::string, std::string> replacements = BlamMap<std::string, std::string>();
        {
            replacements.Add("{project_name}", project_info->project_name);
            //replacements.Add("{project_root}", project_info->project_root);
            replacements.Add("{game_info.title}", project_info->game_info.title);
            replacements.Add("{game_info.codename}", project_info->game_info.codename);
            replacements.Add("{game_info.publisher}", project_info->game_info.publisher);
            replacements.Add("{game_info.developer}", project_info->game_info.developer);
            replacements.Add("{game_info.affiliates}", project_info->game_info.affiliates);
            replacements.Add("{game_info.copyright}", project_info->game_info.copyright);
            replacements.Add("{game_info.website}", project_info->game_info.website);
            replacements.Add("{game_info.version}", project_info->game_info.version);
            replacements.Add("{game_info.icon}", project_info->game_info.icon);
            replacements.Add("{cpp_script_info.uses_cpp_script}", BlamStrings::Converters::BoolToString(project_info->cpp_script_info.uses_cpp_script));
            replacements.Add("{cpp_script_info.vcxproj_path}", project_info->cpp_script_info.vcxproj_path);
            replacements.Add("{cpp_script_info.engine_dependencies_path}", project_info->cpp_script_info.engine_dependencies_path);
            replacements.Add("{cpp_script_info.msbuild_path}", project_info->cpp_script_info.msbuild_path);
            replacements.Add("{cpp_script_info.msbuild_extra_args}", project_info->cpp_script_info.msbuild_extra_args);
            replacements.Add("{cpp_script_info.pre_build_commands}", project_info->cpp_script_info.pre_build_commands);
            replacements.Add("{cpp_script_info.post_build_commands}", project_info->cpp_script_info.post_build_commands);
            replacements.Add("{engine_settings.user_data_folder}", project_info->engine_settings.user_data_folder);
            replacements.Add("{engine_settings.default_cache}", project_info->engine_settings.default_cache);
            replacements.Add("{engine_settings.campaign_info}", project_info->engine_settings.campaign_info);
            replacements.Add("{engine_settings.startup_movie}", project_info->engine_settings.startup_movie);
            replacements.Add("{engine_settings.content_root}", project_info->engine_settings.content_root);
            replacements.Add("{engine_settings.tags_dir}", project_info->engine_settings.tags_dir);
            replacements.Add("{engine_settings.movies_dir}", project_info->engine_settings.movies_dir);
            replacements.Add("{engine_settings.data_dir}", project_info->engine_settings.data_dir);
            replacements.Add("{engine_settings.cache_dir}", project_info->engine_settings.cache_dir);
            replacements.Add("{engine_settings.plugins_dir}", project_info->engine_settings.plugins_dir);
            replacements.Add("{engine_settings.fonts_dir}", project_info->engine_settings.fonts_dir);
            replacements.Add("{engine_settings.allow_user_tag_overrides}", BlamStrings::Converters::BoolToString(project_info->engine_settings.allow_user_tag_overrides));
        }
 
        if (use_project_dirs)
        {
            if (!project_root.ends_with("/"))
            {
                project_root += "/";
            }
 
            replacements.Add("{engine_settings.tags_dir}", project_root + project_info->engine_settings.tags_dir);
            replacements.Add("{engine_settings.movies_dir}", project_root + project_info->engine_settings.movies_dir);
            replacements.Add("{engine_settings.plugins_dir}", project_root + project_info->engine_settings.plugins_dir);
            replacements.Add("{engine_settings.fonts_dir}", project_root + project_info->engine_settings.fonts_dir);
        }
 
        for (std::string key : replacements.KeySet())
        {
            std::string value = replacements.At(key);
 
            value = str_replace(value, "\\", "\\\\");
            value = str_replace(value, "\r\n", "\n");
            value = str_replace(value, "\n", "\\n");
            value = str_replace(value, "\"", "\\\"");
 
            template_file = str_replace(template_file, key, value);
        }
 
        return BlamStrings::Utils::IO::CreateNewFile(output_file, template_file);
    }
};