FieldDataInstaller.h

Go to the documentation of this file.

/*
 * 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 <vector>
#include <string>
#include <OgreMesh.h>
#include <tinyxml.h>
#include "data/VGearsFLevelFile.h"
#include "ScopedLgp.h"
#include "SpawnPointDb.h"
#include "ModelsAndAnimationsDb.h"
#include "FieldTextWriter.h"
#include "decompiler/field/FieldScriptFormatter.h"
#include "decompiler/field/FieldDecompiler.h"
#include "common/FinalFantasy7/FF7NameLookup.h"
 
typedef std::vector<std::string> MapList;
 
typedef std::map<u16, SpawnPointDb> FieldSpawnPointsMap;
 
typedef std::map<u16, float> FieldScaleFactorMap;
 
class BaseFF7FieldScriptFormatter : public FieldScriptFormatter{
 
    public:
 
        BaseFF7FieldScriptFormatter(
          const std::string& field_name, const std::vector<std::string>& field_id_to_name_lookup,
          FieldSpawnPointsMap& spawn_points
        ) :
          field_name_(field_name), field_id_to_name_lookup_(field_id_to_name_lookup),
          spawn_points_(spawn_points)
        {}
 
        virtual std::string GetSpawnPointName(
          unsigned int map_id, const std::string& entity,
          const std::string& function_name, unsigned int address
        ) override{
            return
              field_name_ + "_" + entity + "_" + function_name + "_addr_" + std::to_string(address);
        }
 
        virtual std::string GetMapName(unsigned int map_id) override{
            return field_id_to_name_lookup_[map_id];
        }
 
        virtual std::string GetFriendlyVarName(
          unsigned int bank, unsigned int addr
        ) override{
            return VGears::NameLookup::FieldScriptVarName(bank, addr);
        }
 
        virtual std::string GetFriendlyEntityName(const std::string& entity) override{
            return VGears::NameLookup::FieldScriptEntityName(entity);
        }
 
        virtual std::string GetFriendlyCharName(int char_id) override{
            return VGears::NameLookup::CharName(char_id);
        }
 
        virtual std::string GetFriendlyFunctionName(
          const std::string& entity, const std::string& function_name
        ) override{
            return VGears::NameLookup::FieldScriptFunctionName(
              field_name_, entity, function_name
            );
        }
 
        virtual std::string GetFunctionComment(
          const std::string& entity, const std::string& function_name
        ) override{
            return VGears::NameLookup::FieldScriptFunctionComment(
              field_name_, entity, function_name
            );
        }
 
    protected:
 
        std::string field_name_;
 
        FieldSpawnPointsMap& spawn_points_;
 
        const std::vector<std::string>& field_id_to_name_lookup_;
};
 
class FF7FieldScriptGatewayCollector : public BaseFF7FieldScriptFormatter{
 
    // TODO: Move declaration to a .h file.
 
    public:
 
        FF7FieldScriptGatewayCollector(
          const std::string& field_name, const std::vector<std::string>& field_id_to_name_lookup,
          FieldSpawnPointsMap& spawn_points, size_t this_field_id
        ) :
          BaseFF7FieldScriptFormatter(field_name,field_id_to_name_lookup, spawn_points),
          field_id_(this_field_id)
        {}
 
        virtual void AddSpawnPoint(
          unsigned int map_id, const std::string& entity, const std::string& function_name,
          unsigned int address, int x, int y, int z, int angle
        ) override {
            auto it = spawn_points_.find(map_id);
            VGears::TriggersFile::Gateway gw = {};
            gw.destination_field_id = map_id;
            gw.destination.x = x;
            gw.destination.y = y;
            gw.destination.z = z;
            gw.dir = angle;
            if (it != std::end(spawn_points_)){
                // Add to the list of gateways that link to destination_field_id.
                SpawnPointDb::Record rec;
                rec.from_script = true;
                rec.field_id = field_id_;
                rec.gateway = gw;
                rec.entity_name = entity;
                rec.script_function_name = function_name;
                rec.gateway_index_or_map_jump_address = address;
                it->second.gateways_to_this_field.push_back(rec);
            }
            else{
                // Create a new record for destination_field_id
                SpawnPointDb db;
                db.target_field_id = map_id;
                SpawnPointDb::Record rec;
                rec.from_script = true;
                rec.field_id = field_id_;
                rec.gateway = gw;
                rec.entity_name = entity;
                rec.script_function_name = function_name;
                rec.gateway_index_or_map_jump_address = address;
                db.gateways_to_this_field.push_back(rec);
                spawn_points_.insert(std::make_pair(db.target_field_id, db));
            }
        }
 
    private:
 
        size_t field_id_;
 
};
 
class FF7FieldScriptFormatter : public BaseFF7FieldScriptFormatter{
 
    public:
 
        FF7FieldScriptFormatter(
          const std::string& field_name, const VGears::ModelListFilePtr& models,
          const std::vector<std::string>& field_id_to_name_lookup,
          FieldSpawnPointsMap& spawn_points
        ) :
          BaseFF7FieldScriptFormatter(field_name, field_id_to_name_lookup, spawn_points),
          model_loader_(models)
        {}
 
        // Names an animation, can't return empty
        virtual std::string GetFriendlyAnimationName(int char_id, int id) override{
            // Get the animation file name, then look up the friendly name of
            // the "raw" animation.
            if (static_cast<unsigned int>(char_id) >= model_loader_->GetModels().size()){
                std::cerr << "FF7FieldScriptFormatter::AnimationName ERROR:"
                  << "Char ID " << char_id << " out of bounds" << std::endl;
                return std::to_string(id);
            }
            const auto& model_info = model_loader_->GetModels().at(char_id);
            if (static_cast<unsigned int>(id) >= model_info.animations.size()){
                std::cerr << "FF7FieldScriptFormatter::AnimationName ERROR:"
                  << "In field " << field_name_ << " the model " << model_info.name
                  << " animation with ID " << id << " is out of bounds ("
                  << model_info.animations.size() << ")" << std::endl;
                return std::to_string(id);
            }
            const auto raw_name = model_info.animations.at(id).name;
            // Trim off ".yos" or whatever extension the model loader adds in.
            Ogre::String base_name;
            VGears::StringUtil::splitBase(raw_name, base_name);
            VGears::StringUtil::toLowerCase(base_name);
            return VGears::NameLookup::Animation(base_name);
        }
 
    private:
 
        const VGears::ModelListFilePtr& model_loader_;
};
 
class FieldDataInstaller{
 
    public:
 
        FieldDataInstaller(const std::string input_dir, const std::string output_dir);
 
        ~FieldDataInstaller();
 
        int CollectSpawnAndScaleFactorsInit(Ogre::ResourceGroupManager* res_mgr);
 
        void CollectSpawnAndScaleFactors(int field_index);
 
        void Convert(int field_index);
 
        int WriteInit();
 
        void Write(int field_index);
 
        void WriteEnd();
 
        std::vector<std::string> ConvertModelsInit();
 
        void ConvertModels(std::string model_name);
 
    private:
 
        static std::string CreateGateWayScript(
          const std::string& gateway_entity_name, const std::string& target_map_name,
          const std::string& source_spawn_point_name
        );
 
        static size_t GetFieldId(
          const std::string& name, const std::vector<std::string>& field_id_to_name_lookup
        );
 
        static bool IsAFieldFile(const Ogre::String& resource_name);
 
        static bool WillCrash(const Ogre::String& resource_name);
 
        static bool IsTestField(const Ogre::String& resource_name);
 
        static void CollectFieldScaleFactors(
          VGears::FLevelFilePtr& field, FieldScaleFactorMap& scale_factors,
          const std::vector<std::string>& field_id_to_name_lookup
        );
 
        static void CollectSpawnPoints(
          VGears::FLevelFilePtr& field, const std::vector<std::string>& field_id_to_name_lookup,
          FieldSpawnPointsMap& spawn_points
        );
 
        static float LINE_SCALE_FACTOR;
 
        static std::string FIELD_MODELS_DIR;
 
        static std::string FIELD_MAPS_DIR;
 
        static int INACTIVE_GATEWAY_ID;
 
        void ExportMesh(const std::string outdir, const Ogre::MeshPtr &mesh);
 
        std::vector<int> ExtractMusicTrackIds(VGears::FLevelFilePtr& field);
 
        void PcFieldToVGearsField(VGears::FLevelFilePtr& field);
 
        float GetFieldScaleFactor(size_t field_id);
 
        void CreateDir(const std::string& dir);
 
        std::string input_dir_;
 
        std::string output_dir_;
 
        size_t conversion_step_;
 
        size_t progress_step_num_elements_;
 
        size_t iterator_counter_;
 
        std::unique_ptr<ScopedLgp> fields_lgp_;
 
        std::unique_ptr<ScopedLgp> textures_lgp_;
 
        std::unique_ptr<ScopedLgp> field_models_lgp_;
 
 
        Ogre::StringVectorPtr flevel_file_list_;
 
        std::vector<std::string> map_list_;
 
        FieldSpawnPointsMap spawn_points_;
 
        FieldScaleFactorMap scale_factors_;
 
        ModelsAndAnimationsDb used_models_and_anims_;
 
        MapList converted_map_list_;
 
        MapList::iterator converted_map_list_iterator_;
 
        VGears::FLevelFilePtr field_;
 
        Ogre::StringVectorPtr field_model_file_list_;
 
        std::unique_ptr<TiXmlDocument> doc_;
 
        std::unique_ptr<TiXmlElement> element_;
 
        ModelAnimationMap::iterator model_animation_map_iterator_;
 
        std::function<void(std::string)> write_output_line_;
 
        std::function<void(std::string)> set_progress_label_;
 
        FieldTextWriter field_text_writer_;
 
        std::vector<std::string> materials_;
};