ParseScriptsCommand.hpp

Go to the documentation of this file.

#pragma once
 
#include <regex>
#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 ParseScriptsCommand : public ToolCommand
{
    bool parse_debug = 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] == "-parse-debug")
            {
                parse_debug = true;
            }
            else
            {
                processed_args.push_back(args[i]);
            }
        }
 
        return processed_args;
    }
 
public:
    ParseScriptsCommand()
    {
        command = "parse-scripts";
        syntax = "parse-scripts [project filename] [-parse-debug]";
        description = "preprocess scripts, ensures that scripts can be referenced by the game engine and editing kit";
    }
 
    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::vector<std::string> sources = GetSourceFilesFromVcx(project_info->GetVcxprojPath());
        std::vector<std::string> sources_raw = GetSourceFilesFromVcx(project_info->GetVcxprojPath(), true);
        std::vector<std::string> script_names = std::vector<std::string>();
 
        for (std::string file_path : sources)
        {
            std::string file_contents = BlamStrings::Utils::IO::GetFileContentsAsString(file_path);
            BlamStrings::Logger::LogEvent("analyzing '" + file_path + "'...");
            
            while (str_contains(file_contents, "/*", true))
            {
                int start = file_contents.find("/*");
 
                if (start == std::string::npos)
                {
                    break;
                }
 
                int end = file_contents.find("*/", start);
 
                if (end == std::string::npos)
                {
                    break;
                }
 
                file_contents = file_contents.erase(start, end - start);
            }
 
            file_contents = str_replace(file_contents, "public", "");
            file_contents = str_replace(file_contents, "protected", "");
            file_contents = str_replace(file_contents, "private", "");
            file_contents = str_replace(file_contents, "class", "class:");
            file_contents = str_replace(file_contents, " ", "");
            file_contents = str_replace(file_contents, "\r", "");
            file_contents = str_replace(file_contents, "\n", "");
            file_contents = str_replace(file_contents, "\t", "");
 
            if (parse_debug)
            {
                BlamStrings::Utils::IO::CreateNewFile(file_path + ".PARSED", file_contents);
            }
 
            int offset = 0;
            while (true)
            {
                int pos = file_contents.find("BSCRIPTclass:", offset);
 
                if (pos == std::string::npos)
                {
                    break;
                }
 
                pos = pos + sizeof("BSCRIPTclass:") - 1;
 
                int end_pos = pos + 1;
                bool is_script = false;
 
                while (end_pos != std::string::npos && end_pos < file_contents.length())
                {
                    if (file_contents.at(end_pos) == ':')
                    {
                        is_script = true;
                        break;
                    }
 
                    end_pos++;
                }
                
                if (is_script)
                {
                    std::string script_name = file_contents.substr(pos, end_pos - pos);
 
                    if (!BlamStrings::Utils::List::Contains(script_names, script_name))
                    {
                        script_names.push_back(script_name);
                    }
                }
 
                offset = end_pos;
            }
        }
 
        // Create scripts.db file
        {
            std::string db_contents = "";
 
            for (std::string script_name : script_names)
            {
                db_contents += script_name + "\n";
            }
 
            BlamStrings::Utils::IO::CreateNewFile(project_root + "/_build/scripts.db", db_contents);
        }
 
        // Generate gamescripts.cpp file
        {
            std::string template_file = BlamStrings::Utils::IO::GetFileContentsAsString("./content/blam/default_stub_project/gamescripts.cpp.template");
 
            std::string includes = "";
            std::string creation_functions = "";
            std::string registry_lines = "";
 
            for (std::string source_file : sources_raw)
            {
                if (!source_file.ends_with(".h"))
                {
                    continue;
                }
 
                includes += "#include <" + source_file + ">\n";
            }
 
            for (std::string script_name : script_names)
            {
                std::string function_name = "__blam_create_script__" + script_name;
                creation_functions += script_name + "* " + function_name + "() { return new " + script_name + "(); }\n";
                registry_lines += "    BlamAPI::Scripts::RegisterScriptType(\"" + script_name + "\", &" + function_name + ");\n";
            }
 
            template_file = str_replace(template_file, "%%FUNCTIONS%%", creation_functions);
            template_file = str_replace(template_file, "%%REGISTRATIONS%%", registry_lines);
            template_file = str_replace(template_file, "%%INCLUDES%%", includes);
 
            BlamStrings::Utils::IO::CreateNewFile(project_root + "_build/_internal/game/gamescripts.cpp", template_file);
        }
 
        BlamStrings::Logger::LogEvent("finished");
 
        delete project_info;
        return 0;
    }
 
    std::vector<std::string> GetSourceFilesFromVcx(std::string vcxproj_path, bool preserve_relative_paths = false)
    {
        std::vector<std::string> files = std::vector<std::string>();
        std::string vcxproj_dir = BlamStrings::Utils::IO::GetContainingFolder(vcxproj_path);
 
        char* data = nullptr;
        int64_t data_size = 0;
 
        if (!BlamStrings::Utils::IO::ReadFile(vcxproj_path, (void**)&data, &data_size))
        {
            BlamStrings::Logger::LogEvent("cannot load vcxproj: ReadFile() returned false", WSV_WARNING);
            return files;
        }
 
        rapidxml::xml_document<char>* document = new rapidxml::xml_document();
        document->parse<0>(data);
 
        rapidxml::xml_node<>* root = document->first_node();
 
        for (rapidxml::xml_node<>* node = root->first_node(); node; node = node->next_sibling())
        {
            if (str_tolower(node->name()) != "itemgroup")
            {
                continue;
            }
 
            for (rapidxml::xml_node<>* child_node = node->first_node(); child_node; child_node = child_node->next_sibling())
            {
                if (str_tolower(child_node->name()) == "clinclude" || str_tolower(child_node->name()) == "clcompile")
                {
                    if (preserve_relative_paths)
                    {
                        files.push_back(child_node->first_attribute("Include")->value());
                    }
                    else
                    {
                        files.push_back(BlamStrings::Utils::IO::NormalizePath(vcxproj_dir + "/"
                            + child_node->first_attribute("Include")->value()));
                    }
                }
            }
        }
 
        delete document;
        free(data);
 
        return files;
    }
};