GenerateScriptProjectCommand.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
 
class TOOL_LIB_API GenerateScriptProjectCommand : public ToolCommand
{
private:
    std::string include_path_placeholders[4] = {
        "{$__INCLUDE_DIRS_DW32__}",
        "{$__INCLUDE_DIRS_DW64__}",
        "{$__INCLUDE_DIRS_RW32__}",
        "{$__INCLUDE_DIRS_RW64__}"
    };
 
    std::string lib_path_placeholders[4] = {
        "{$__LIBRARY_DIRS_DW32__}",
        "{$__LIBRARY_DIRS_DW64__}",
        "{$__LIBRARY_DIRS_RW32__}",
        "{$__LIBRARY_DIRS_RW64__}"
    };
 
    std::string engine_lib_dir_suffixes[4] = {
        "tag debug/Win32",
        "tag debug/x64",
        "cache release/Win32",
        "cache release/x64"
    };
 
    std::string default_deps = "blam.lib;Strings.lib";
    std::string default_deps_placeholder = "{$__DEPS__}";
 
    std::string hek_root_placeholder = "{$__HEK_ROOT__}";
 
    bool verbose = false;
    bool overwrite = 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] == "-overwrite")
            {
                overwrite = true;
            }
            else
            {
                processed_args.push_back(args[i]);
            }
        }
 
        return processed_args;
    }
 
public:
    GenerateScriptProjectCommand()
    {
        command = "generate-script-project";
        syntax = "generate-script-project [-verbose] [-overwrite]";
        description = "generates a preconfigured visual studio project for the current 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_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 script_project_base_dir = "./content/blam/default_script_project/";
 
        // Copy .sln file
        {
            std::string source_sln_path = script_project_base_dir + "BLAM_GAME_TITLE.sln";
            std::string destination_sln_path = project_root + project_info->project_name + ".sln";
 
            if (!CopyTextFile(source_sln_path, destination_sln_path, "visual studio solution"))
            {
                delete project_info;
                return -1;
            }
        }
 
        // Copy .vcxproj.user file
        {
            std::string source_path = script_project_base_dir + "BLAM_GAME_TITLE.vcxproj.user";
            std::string destination_path = project_root + project_info->project_name + ".vcxproj.user";
 
            if (!CopyTextFile(source_path, destination_path, ".vcxproj.user"))
            {
                delete project_info;
                return -1;
            }
        }
 
        std::string destination_vcxproj_path = project_root + project_info->project_name + ".vcxproj";
        std::string hek_root = BlamStrings::Utils::IO::GetApplicationDir();
 
        if (!BlamStrings::Utils::IO::FileExists(destination_vcxproj_path) || overwrite)
        {
            std::string vcxproj_file_contents = BlamStrings::Utils::IO::GetFileContentsAsString(script_project_base_dir + "BLAM_GAME_TITLE.vcxproj");
 
            for (int i = 0; i < 4; i++)
            {
                std::string engine_dep_path = project_info->GetEngineDependenciesPath() + "/" + engine_lib_dir_suffixes[i] + "/";
                std::string engine_include_path = project_info->GetEngineDependenciesPath() + "/include/";
 
                vcxproj_file_contents = str_replace(vcxproj_file_contents, include_path_placeholders[i], engine_include_path);
                vcxproj_file_contents = str_replace(vcxproj_file_contents, lib_path_placeholders[i], engine_dep_path + "/lib");
 
                vcxproj_file_contents = str_replace(vcxproj_file_contents, default_deps_placeholder, default_deps);
                vcxproj_file_contents = str_replace(vcxproj_file_contents, hek_root_placeholder, hek_root);
            }
 
            if (!BlamStrings::Utils::IO::CreateNewFile(destination_vcxproj_path, vcxproj_file_contents))
            {
                BlamStrings::Logger::LogEvent("failed to create new vcxproj: CreateNewFile returned false", WSV_ERROR);
                return -1;
            }
        }
        else
        {
            BlamStrings::Logger::LogEvent("not copying default vcxproj: file already exists", WSV_WARNING);
            BlamStrings::Logger::LogEvent("hint: use -overwrite argument to overwrite your current .vcxproj if "
                "desired, but this will cause data loss!", WSV_WARNING);
        }
 
        BlamStrings::Logger::LogEvent("script project created");
 
        delete project_info;
        return 0;
    }
 
    bool CopyTextFile(std::string source, std::string destination, std::string debug_file_title)
    {
        if (!BlamStrings::Utils::IO::FileExists(destination) || overwrite)
        {
            std::string contents = BlamStrings::Utils::IO::GetFileContentsAsString(source);
 
            if (!BlamStrings::Utils::IO::CreateNewFile(destination, contents))
            {
                BlamStrings::Logger::LogEvent("failed to create new " + debug_file_title + ": CreateNewFile returned false", WSV_ERROR);
                return false;
            }
        }
        else
        {
            BlamStrings::Logger::LogEvent("not copying default " + debug_file_title + ": file already exists", WSV_WARNING);
            BlamStrings::Logger::LogEvent("hint: use -overwrite argument to overwrite the existing file if "
                "desired, but this will cause data loss!", WSV_WARNING);
        }
 
        return true;
    }
};