KernelDataInstaller.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/BinGZipFile.h"
#include "common/TypeDefine.h"
#include "Characters.h"
#include "SaveMap.h"
 
class KernelDataInstaller{
 
    public:
 
        KernelDataInstaller(std::string path);
 
        ~KernelDataInstaller();
 
        void ReadPrices();
 
        int ReadCommands();
 
        void WriteCommands(std::string file_name);
 
        int ReadAttacks();
 
        void WriteAttacks(std::string file_name);
 
        int ReadCharacters();
 
        void WriteCharacters(std::string file_name);
 
        void ReadGrowth();
 
        void WriteGrowth(std::string file_name);
 
        int ReadItems();
 
        void WriteItems(std::string file_name);
 
        int ReadWeapons();
 
        void WriteWeapons(std::string file_name);
 
        int ReadArmors();
 
        void WriteArmors(std::string file_name);
 
        int ReadAccessories();
 
        void WriteAccessories(std::string file_name);
 
        int ReadMateria();
 
        void WriteMateria(std::string file_name);
 
        int ReadKeyItems();
 
        void WriteKeyItems(std::string file_name);
 
        int ReadSummonNames();
 
        void WriteSummonNames(std::string file_name);
 
        void ReadInitialSaveMap();
 
        void WriteInitialSaveMap(std::string file_name);
 
    private:
 
        enum KERNEL_SECTIONS{
 
            KERNEL_COMMAND_DATA = 0,
 
            KERNEL_ATTACK_DATA,
 
            KERNEL_BATTLE_AND_GROWTH_DATA,
 
            KERNEL_INITIALIZATION_DATA,
 
            KERNEL_ITEM_DATA,
 
            KERNEL_WEAPON_DATA,
 
            KERNEL_ARMOR_DATA,
 
            KERNEL_ACCESSORY_DATA,
 
            KERNEL_MATERIA_DATA,
 
            KERNEL_COMMAND_DESCRIPTIONS,
 
            KERNEL_ATTACK_DESCRIPTIONS,
 
            KERNEL_ITEM_DESCRIPTIONS,
 
            KERNEL_WEAPON_DESCRIPTIONS,
 
            KERNEL_ARMOR_DESCRIPTIONS,
 
            KERNEL_ACCESSORY_DESCRIPTIONS,
 
            KERNEL_MATERIA_DESCRIPTIONS,
 
            KERNEL_KEY_ITEM_DESCRIPTIONS,
 
            KERNEL_COMMAND_NAMES,
 
            KERNEL_ATTACK_NAMES,
 
            KERNEL_ITEM_NAMES,
 
            KERNEL_WEAPON_NAMES,
 
            KERNEL_ARMOR_NAMES,
 
            KERNEL_ACCESSORY_NAMES,
 
            KERNEL_MATERIA_NAMES,
 
            KERNEL_KEY_ITEM_NAMES,
 
            KERNEL_BATTLE_AND_BATTLE_SCREEN_TEXT,
 
            KERNEL_SUMMON_ATTACK_NAMES
 
 
        };
 
        enum ELEMENT{
 
            FIRE = 0,
 
 
            ICE,
 
 
            BOLT,
 
 
            EARTH,
 
 
            POISON,
 
 
            GRAVITY,
 
 
            WATER,
 
 
            WIND,
 
 
            HOLY,
 
 
            RESTORATIVE,
 
 
            CUT,
 
 
            HIT,
 
 
            PUNCH,
 
 
            SHOOT,
 
 
            SHOUT,
 
 
            HIDDEN,
        };
 
        struct Target{
 
            bool selection_enabled;
 
            bool default_enemy;
 
            bool default_multiple;
 
            bool toggle_multiple;
 
            bool fixed_row;
 
            bool short_range;
 
            bool all_rows;
 
            bool random;
 
        };
 
        enum RESTORE_TYPE{
 
            RESTORE_HP = 0,
 
            RESTORE_MP = 1,
 
            RESTORE_STATUS = 2,
 
            RESTORE_NONE = 3
        };
 
        enum STATUS{
 
            DEATH = 0,
 
            NEAR_DEATH,
 
            SLEEP,
 
            POISONED,
 
            SADNESS,
 
            FURY,
 
            CONFU,
 
            SILENCE,
 
            HASTE,
 
            SLOW,
 
            STOP,
 
            FROG,
 
            SMALL,
 
            SLOW_NUMB,
 
            PETRIFY,
 
            REGEN,
 
            BARRIER,
 
            M_BARRIER,
 
            REFLECT,
 
            DUAL,
 
            SHIELD,
 
            D_SENTENCE,
 
            MANIPULATE,
 
            BERSERK,
 
            PEERLESS,
 
            PARALYSIS,
 
            DARKNESS,
 
            DUAL_DRAIN,
 
            DEATH_FORCE,
 
            RESIST,
 
            LUCKY_GIRL,
 
            IMPRISONED
        };
 
        enum STATUS_EFFECT{
 
            INFLICT = 0,
 
            CURE = 1,
 
            TOGGLE = 2
        };
 
        enum COMMAND_MENU{
 
            NONE = 0,
 
            MAGIC = 1,
 
            SUMMON = 2,
 
            ITEM = 3,
 
            E_SKILL = 4,
 
            THROW = 5,
 
            LIMIT = 6,
 
            TARGET = 7,
 
            W_MAGIC = 8,
 
            W_SUMMON = 9,
 
            W_ITEM = 10,
 
            COIN = 11,
 
 
        };
 
        struct StatusEffect{
 
            std::vector<int> status;
 
            u16 chance;
 
            STATUS_EFFECT mode;
 
        };
 
        struct CommandData{
 
            u8 cursor_action;
 
            u8 target_raw;
 
            u16 unknown;
 
            u16 camera_single;
 
            u16 camera_multiple;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            Target target;
 
            std::string menu;
 
        };
 
        struct AttackData{
 
            u8 accuracy;
 
            u8 impact_effect;
 
            u8 hurt_anim;
 
            u8 unknown;
 
            u16 mp;
 
            u16 sound;
 
            u16 camera_single;
 
            u16 camera_multiple;
 
            u8 target_raw;
 
            u8 effect;
 
            u8 damage_raw;
 
            u8 power;
 
            u8 condition_raw;
 
            u8 status_change_raw;
 
            u8 additional_effects_raw;
 
            u8 additional_effects_mod_raw;
 
            u32 status_raw;
 
            u16 element_raw;
 
            u16 special_raw;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            Target target;
 
            u8 damage_formula;
 
            u8 damage_modifier;
 
            RESTORE_TYPE restore_type;
 
            StatusEffect status;
 
            std::vector<int> elements;
 
        };
 
        struct ItemData{
 
            u32 unknown_0;
 
            u32 unknown_1;
 
            u16 camera;
 
            u16 restrict_raw;
 
            u8 target_raw;
 
            u8 effect;
 
            u8 damage_raw;
 
            u8 power;
 
            u8 condition_raw;
 
            u8 status_change_raw;
 
            u8 additional_effects_raw;
 
            u8 additional_effects_mod_raw;
 
            u32 status_raw;
 
            u16 element_raw;
 
            u16 special_raw;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            bool sellable;
 
            bool useable_battle;
 
            bool useable_menu;
 
            Target target;
 
            u8 damage_formula;
 
            u8 damage_modifier;
 
            RESTORE_TYPE restore_type;
 
            StatusEffect status;
 
            std::vector<int> elements;
 
        };
 
        enum SLOT_TYPE{
 
            SLOT_UNLINKED = 0,
 
            SLOT_LINKED = 1
        };
 
        struct StatBonus{
 
            u8 stat;
 
            u8 bonus;
        };
 
        struct WeaponData{
 
            u8 target_raw;
 
            u8 unused_0;
 
            u8 damage_raw;
 
            u8 unused_1;
 
            u8 power;
 
            u8 status;
 
            u8 growth;
 
            u8 critical;
 
            u8 accuracy;
 
            u8 model_raw;
 
            u8 unused_2;
 
            u8 high_sound;
 
            u16 camera;
 
            u16 equip_raw;
 
            u16 element_raw;
 
            u8 unused_3;
 
            u8 stat_raw[4];
 
            u8 stat_bonus_raw[4];
 
            u8 slots_raw[8];
 
            u8 sound;
 
            u8 sound_critical;
 
            u8 sound_miss;
 
            u8 effect;
 
            u16 special_raw;
 
            u16 restrict_raw;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            bool sellable;
 
            bool useable_battle;
 
            bool useable_menu;
 
            bool throwable;
 
            Target target;
 
            u8 damage_formula;
 
            u8 damage_modifier;
 
            u8 animation_index;
 
            u8 model;
 
            std::vector<u8> equip;
 
            std::vector<StatBonus> stat_bonus;
 
            std::vector<u8> materia_slots;
 
            std::vector<int> elements;
 
        };
 
        struct ArmorData{
 
            u8 unknown_0;
 
            u8 element_defense_mode;
 
            u8 defense;
 
            u8 m_defense;
 
            u8 evasion;
 
            u8 m_evasion;
 
            u8 status;
 
            u16 unknown_1;
 
            u8 slots_raw[8];
 
            u8 growth;
 
            u16 equip_raw;
 
            u16 element_raw;
 
            u16 unknown_2;
 
            u8 stat_raw[4];
 
            u8 stat_bonus_raw[4];
 
            u16 restrict_raw;
 
            u16 unknown_3;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            bool sellable;
 
            bool useable_battle;
 
            bool useable_menu;
 
            std::vector<u8> equip;
 
            std::vector<StatBonus> stat_bonus;
 
            std::vector<u8> materia_slots;
 
            std::vector<int> elements;
 
        };
 
        struct AccessoryData{
 
            u8 stat_raw[2];
 
            u8 stat_bonus_raw[2];
 
            u8 element_defense_mode;
 
            u8 effect;
 
            u16 element_raw;
 
            u32 status_raw;
 
            u16 equip_raw;
 
            u16 restrict_raw;
 
            int id;
 
            std::string name;
 
            std::string description;
 
            bool sellable;
 
            bool useable_battle;
 
            bool useable_menu;
 
            std::vector<u8> equip;
 
            std::vector<StatBonus> stat_bonus;
 
            std::vector<int> elements;
 
            std::vector<int> status;
 
        };
 
        enum class MATERIA_TYPE{
 
            MAGIC = 1,
 
            SUPPORT,
 
            COMMAND,
 
            INDEPENDENT,
 
            SUMMON
        };
 
        struct MateriaStatBonus{
 
            int str;
 
            int vit;
 
            int mag;
 
            int spr;
 
            int dex;
 
            int lck;
 
            int hp;
 
            int mp;
 
            bool change;
        };
 
        struct MateriaData{
 
            u16 level_up_ap[4];
 
            u8 stat_raw;
 
            u32 status_raw;
 
            u8 element;
 
            u8 type_raw;
 
            u8 attribute[6];
 
            int id;
 
            std::string name;
 
            std::string description;
 
            int type;
 
            int sub_type;
 
            MateriaStatBonus stats;
 
            std::vector<int> status;
 
            std::vector<int> command;
 
            int attack[6];
 
            int attack_times[6];
 
            std::string ability;
 
            int ability_parameters[5];
        };
 
        struct KeyItemData{
 
            int id;
 
            std::string name;
 
            std::string description;
        };
 
        struct SummonNameData{
 
            int id;
 
            std::string name;
        };
 
        struct CharacterData{
 
            u8 curve_str;
 
            u8 curve_vit;
 
            u8 curve_mag;
 
            u8 curve_spr;
 
            u8 curve_dex;
 
            u8 curve_lck;
 
            u8 curve_hp;
 
            u8 curve_mp;
 
            u8 curve_exp;
 
            u8 unused_0;
 
            u8 initial_level;
 
            u8 unused_1;
 
            u8 limit_1_1;
 
            u8 limit_1_2;
 
            u8 limit_1_3;
 
            u8 limit_2_1;
 
            u8 limit_2_2;
 
            u8 limit_2_3;
 
            u8 limit_3_1;
 
            u8 limit_3_2;
 
            u8 limit_3_3;
 
            u8 limit_4_1;
 
            u8 limit_4_2;
 
            u8 limit_4_3;
 
            u16 limit_2_kills;
 
            u16 limit_3_kills;
 
            u16 limit_1_2_uses;
 
            u16 limit_1_3_uses;
 
            u16 limit_2_2_uses;
 
            u16 limit_2_3_uses;
 
            u16 limit_3_2_uses;
 
            u16 limit_3_3_uses;
 
            u32 limit_1_div;
 
            u32 limit_2_div;
 
            u32 limit_3_div;
 
            u32 limit_4_div;
 
            int id;
 
            std::string name;
 
        };
 
        enum STAT_CURVE_TYPE{
 
            CURVE_PRIMARY = 0,
 
            CURVE_HP,
 
            CURVE_MP,
 
            CURVE_EXP
 
        };
 
        struct StatCurve{
 
            int id;
 
            STAT_CURVE_TYPE type;
 
            u8 gradient[8];
 
            u8 base[8];
 
        };
 
        struct GrowthData{
 
            u8 bonus_stat[12];
 
            u8 bonus_hp[12];
 
            u8 bonus_mp[12];
 
            StatCurve curves[64];
        };
 
        std::string GetBasicStatName(int id);
 
        std::vector<CommandData> commands_;
 
        std::vector<AttackData> attacks_;
 
        std::vector<CharacterData> characters_;
 
        GrowthData growth_;
 
        std::vector<ItemData> items_;
 
        std::vector<WeaponData> weapons_;
 
        std::vector<ArmorData> armors_;
 
        std::vector<AccessoryData> accessories_;
 
        std::vector<MateriaData> materia_;
 
        std::vector<KeyItemData> key_items_;
 
        std::vector<SummonNameData> summon_names_;
 
        SaveMap savemap_;
 
        BinGZipFile kernel_;
 
        std::string exe_path_;
 
        u32 prices_[416];
 
        std::string attack_names_[128];
 
        std::string command_names_[128];
 
};