FF7NameLookup.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 "common/TypeDefine.h"
#include "common/VGearsStringUtil.h"
#include "core/XmlFile.h"
 
// TODO: Move implementations to cpp file.
 
namespace VGears{
 
 
    class FF7Metadata : public XmlFile{
 
        public:
 
            FF7Metadata(Ogre::String file) : XmlFile(file){
                TiXmlNode* node = file_.RootElement();
                if (node == nullptr || node->ValueStr() != "metadata"){
                    throw std::runtime_error(
                      "FF7Metadata: " + file_.ValueStr()
                      + " is not a valid metadata file! No <metadata> in root."
                    );
                }
 
                node = node->FirstChild();
                while (node){
                    if (node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "models")
                        ReadModels(node->FirstChild());
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT&& node->ValueStr() == "animations"
                    ){
                        ReadAnimations(node->FirstChild());
                    }
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "scripts"
                    ){
                        ReadScripts(node->FirstChild());
                    }
                    node = node->NextSibling();
                }
            }
 
            const String& Animation(const String &key) const{
                auto it = animations_.find(key);
                if (it != std::end(animations_)) return it->second;
                String base_name;
                StringUtil::splitBase(key, base_name);
                it = animations_.find(base_name);
                if (it != std::end(animations_)) return it->second;
                return key;
            }
 
            const String& Model(const String &key) const{
                auto it = models_.find(key);
                if (it != std::end(models_)) return it->second;
                String base_name;
                StringUtil::splitBase(key, base_name);
                it = models_.find(base_name);
                if (it != std::end(models_)) return it->second;
                return key;
            }
 
        private:
 
            void ReadModels(TiXmlNode* node){
                while (node){
                    const auto src = GetString(node, "name");
                    const auto dst = GetString(node, "target");
                    models_[src] = dst;
                    node = node->NextSibling();
                }
            }
 
            void ReadAnimations(TiXmlNode* node){
                while (node){
                    const auto src = GetString(node, "name");
                    const auto dst = GetString(node, "target");
                    animations_[src] = dst;
                    node = node->NextSibling();
                }
            }
 
 
            void ReadScripts(TiXmlNode* node){
                while (node){
                    if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT
                      && node->ValueStr() == "CharacterIds"
                    ){ReadCharacterIds(node->FirstChild());}
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "var_names"
                    ){ReadVarNames(node->FirstChild());}
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT
                      && node->ValueStr() == "entity_names"
                    ){ReadEntityNames(node->FirstChild());}
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "field"
                    ){
                        const auto name = GetString(node, "name");
                        ReadField(node->FirstChild(), name);
                    }
                    node = node->NextSibling();
                }
            }
 
            void ReadField(TiXmlNode* node, const std::string& name){
                while (node){
                    if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "function"
                    ){ReadFunction(node, name);}
                    else if (
                      node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "entity"
                    ){
                        const auto old_name = GetString(node, "name");
                        const auto new_name = GetString(node, "new");
                        field_data_[name].entity_name_map[old_name] = new_name;
                    }
                    node = node->NextSibling();
                }
            }
 
            void ReadFunction(TiXmlNode* node, const std::string& field_name){
                const auto entity_name = GetString(node, "entity_name");
                const auto old_name = GetString(node, "name");
                const auto new_name = GetString(node, "new");
                const auto comment = GetString(node, "Comment");
                field_data_[field_name].function_map[entity_name][old_name]
                  = std::make_pair(new_name, comment);
            }
 
            void ReadEntityNames(TiXmlNode* node){
                while (node){
                    if (node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "entity"){
                        const auto old_name = GetString(node, "name");
                        const auto new_name = GetString(node, "new");
                        entity_name_map_[old_name] = new_name;
                    }
                    node = node->NextSibling();
                }
            }
 
            void ReadVarNames(TiXmlNode* node){
                while (node){
                    if (node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "var"){
                        const auto bank = GetInt(node, "Bank");
                        const auto address = GetInt(node, "Address");
                        const auto name = GetString(node, "Name");
                        var_map_[bank][address] = name;
                    }
                    node = node->NextSibling();
                }
            }
 
            void ReadCharacterIds(TiXmlNode* node){
                while (node){
                    if (node->Type() == TiXmlNode::TINYXML_ELEMENT && node->ValueStr() == "char"){
                        const auto id = GetInt(node, "Id");
                        const auto name = GetString(node, "Name");
                        character_ids_[id] = name;
                    }
                    node = node->NextSibling();
                }
            }
 
            std::pair<String,String> FieldScriptFunctionData(
              const String& field_name, const String& entity_name, const String& old_function_name
            ){
                // Find a collection of field data for this field.
                auto field_iterator = field_data_.find(field_name);
                if (field_iterator != std::end(field_data_)){
                    // See if there is any info for this entity.
                    auto entity_iterator = field_iterator->second.function_map.find(entity_name);
                    if (entity_iterator != std::end(field_iterator->second.function_map)){
                        // See if there is any info for this function in
                        // this entity.
                        auto function_iterator = entity_iterator->second.find(old_function_name);
                        if (function_iterator != std::end(entity_iterator->second))
                            return function_iterator->second;
                    }
                }
                return std::make_pair("", "");
            }
 
 
            typedef std::map<String, String> LookupMap;
 
            LookupMap models_;
 
            LookupMap animations_;
 
            std::map<int, String> character_ids_;
 
            std::map<int, std::map<int, String>> var_map_;
 
            LookupMap entity_name_map_;
 
            struct FieldMetaData{
 
                std::map<String, std::map<String, std::pair<String,String>>> function_map;
 
                LookupMap entity_name_map;
            };
            std::map<String, FieldMetaData> field_data_;
 
            friend class NameLookup;
 
    };
 
    class NameLookup{
 
        public:
 
            NameLookup() = delete;
 
            static String CharName(int char_id){
                auto it = Data().character_ids_.find(char_id);
                if (it != std::end(Data().character_ids_)) return it->second;
                // Empty becomes lua "nil" value for this special case:
                if (char_id == 254) return "";
                return std::to_string(char_id);
            }
 
            static const String& Animation(const String &key){return Data().Animation(key);}
 
            static const String& model(const String &key){return Data().Model(key);}
 
            static String FieldScriptVarName(int bank, int addr){
                auto bank_iterator = Data().var_map_.find(bank);
                if (bank_iterator != std::end(Data().var_map_)){
                    auto address_iterator = bank_iterator->second.find(addr);
                    if (address_iterator != std::end(bank_iterator->second)){
                        if (address_iterator->second.empty() == false)
                            return address_iterator->second;
                    }
                }
                return "";
            }
 
            static String FieldScriptEntityName(const String& old_entity_name){
                auto it = Data().entity_name_map_.find(old_entity_name);
                if (it != std::end(Data().entity_name_map_)) return it->second;
                return old_entity_name;
            }
 
            static String FieldScriptFunctionComment(
              const String& field_name, const String& entity_name, const String& old_function_name
            ){
                return Data().FieldScriptFunctionData(
                  field_name, entity_name, old_function_name
                ).second;
            }
 
            static String FieldScriptFunctionName(
              const String& field_name, const String& entity_name, const String& old_function_name
            ){
                auto name = Data().FieldScriptFunctionData(
                  field_name, entity_name, old_function_name
                ).first;
                if (name.empty()) return old_function_name;
                return name;
            }
 
            static FF7Metadata& Data(){
                static FF7Metadata data("field_models_and_animation_metadata.xml");
                return data;
            }
    };
}