V-Gears/V-Gears-Installer/include/decompiler/sudm.h

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#pragma once

#include <map>
#include <vector>
#include <string>
#include "unknown_opcode_exception.h"

namespace SUDM{

    class IScriptFormatter{

        public:

            virtual ~IScriptFormatter() = default;

            /**
             * Adds an spawn point.
             *
             * If the spawn is new, a new record will be added to the spawn
             * point database. If it was already there, update the record to
             * add the origin.
             *
             * @param map_id[in] The target map ID.
             * @param entity[in] The entity that acts as the spawn point.
             * @param function_name[in] The spawn function name.
             * @param address[in] @todo Understand and document.
             * @param x[in] X coordinate of the field at which to spawn.
             * @param y[in] Y coordinate of the field at which to spawn.
             * @param z[in] Z coordinate of the field at which to spawn.
             * @param angle[in] Orientation at which to spawn.
             */
            virtual void AddSpawnPoint(
              unsigned int map_id, const std::string& entity, const std::string& function_name,
              unsigned int address, int x, int y, int triangle_id, int angle
            ){}

            /**
             * Retrieves the name of a spawn point.
             *
             * @param map_id[in] The target map ID.
             * @param entity[in] The entity that acts as the spawn point.
             * @param function_name[in] The spawn function name.
             * @param address[in] @todo Understand and document.
             * @return The name of the spawn point.
             */
            virtual std::string SpawnPointName(
              unsigned int map_id, const std::string& entity,
              const std::string& function_name, unsigned int address
            ){
                return MapName(map_id)
                  + "_" + entity + "_" + function_name + "_" + std::to_string(address);
            }

            /**
             * Retrieves the name of a map.
             *
             * The name of a map is usually it's ID.
             *
             * @param map_id[in] The map ID.
             * @return The map name.
             */
            virtual std::string MapName(unsigned int map_id) { return std::to_string(map_id);}

            /**
             * Retrieves a friendly name for a variable.
             *
             * @param bank[in] Variable memory bank.
             * @param address[in] Variable memory address.
             * @return Friendly name assigned to the variable, or an empty
             * string if there is none.
             */
            virtual std::string VarName(unsigned int bank, unsigned int addr){return "";}

            /**
             * Retrieves a friendly name for an entity.
             *
             * @param entity_name[in] Name of the entity.
             * @return Friendly name assigned to the entity, or <entity_name>
             * if there is none.
             */
            virtual std::string EntityName(const std::string& entity_name){return entity_name;}

            /**
             * Retrieves a friendly name for an animation.
             *
             * @param animation_id[in] ID of the animation.
             * @return Friendly name assigned to the animation. If there is
             * no one, the ID in string format.
             */
            virtual std::string AnimationName(int animation_id, int id){
                return std::to_string(animation_id);
            }

            /**
             * Retrieves a friendly name for a character.
             *
             * @param char_id[in] ID of the character.
             * @return Friendly name assigned to the character. If there is
             * no one, the ID in string format.
             */
            virtual std::string CharName(int char_id){return std::to_string(char_id);}

            /**
             * Retrieves a friendly name for a function.
             *
             * @param entity_name[in] Name of the entity.
             * @param function_name[in] Name of the function.
             * @return Friendly name assigned to the entity, or
             * <function_name> if there is none.
             */
            virtual std::string FunctionName(
              const std::string& entity_name, const std::string& function_name
            ){return function_name;}

            /**
             * Retrieves the header comment for a function in an entity.
             *
             * @param entity_name[in] Name of the entity.
             * @param function_name[in] Name of the function.
             * @return The function comment. An empty string if the entity or
             * the function don't exist.
             */
            virtual std::string FunctionComment(
              const std::string& entity_name, const std::string& function_name
            ){return "";}
        };



    namespace Field{

        /**
         * A line.
         */
        struct Line{

            /**
             * Name of the line entity.
             */
            std::string name;

            /**
             * First point of the line.
             */
            std::vector<float> point_a;

            /**
             * Second point of the line.
             */
            std::vector<float> point_b;
        };

        /**
         * An entity.
         */
        struct FieldEntity{

            /**
             * Character identifier of the entity.
             */
            uint char_id;

            /**
             * Index of the entity in the field.
             */
            uint index;

            /**
             * Name of the entity.
             */
            std::string name;
        };

        /**
         * The field decompiled script.
         */
        struct DecompiledScript{

            /**
             * The LUA script for the field.
             */
            std::string luaScript;

            /**
             * The field entities.
             *
             * Lines are not included.
             */
            std::vector<FieldEntity> entities;

            /**
             * Lines in the field.
             */
            std::vector<Line> lines;
        };

        /**
         * Retrieves the scale factor of a field.
         *
         * @param script_bytes[in] Vector of raw byte data that makes up
         * the script.
         * @return The scale fctor.
         */
        float ScaleFactor(const std::vector<unsigned char>& script_bytes);

        /**
         * Decompiles a field script.
         *
         * @param script_name[in] Name of the script to be converted,
         * should match file name.
         * @param script_bytes[in] Vector of raw byte data that makes up
         * the script.
         * @param formatter[in] Formatter used to rename variables, drop
         * functions...
         * @param text_after[in] Raw text that is added at to the end of
         * the decompiled output.
         * @param text_before[in] Raw text that is added at to the start of
         * the decompiled output.
         * @return A string with the decompiled script.
         * @throws InternalDecompilerError on failure.
         */
        DecompiledScript Decompile(
          std::string script_name, const std::vector<unsigned char>& script_bytes,
          IScriptFormatter& formatter, std::string text_after = "", std::string text_before = ""
        );
    }
}