DataInstaller.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 <string>
#include <vector>
#include <iostream>
#include "common/VGearsApplication.h"
#include "FieldDataInstaller.h"
#include "KernelDataInstaller.h"
#include "MediaDataInstaller.h"
#include "BattleDataInstaller.h"
#include "ModelsAndAnimationsDb.h"
 
class DataInstaller{
 
    public:
 
        struct AdvancedOptions{
 
            bool skip_battle_data;
 
            bool skip_battle_models;
 
            bool skip_kernel;
 
            bool skip_images;
 
            bool skip_sounds;
 
            bool skip_music;
 
            bool skip_fields;
 
            bool skip_field_models;
 
            bool keep_originals;
 
            bool no_ffmpeg;
 
            bool no_timidity;
        };
 
        static float LINE_SCALE_FACTOR;
 
        DataInstaller(
          const std::string input_dir, const std::string output_dir, AdvancedOptions options,
          std::function<void(std::string, int, bool)> write_output_line
        );
 
        ~DataInstaller();
 
        float Progress();
 
    private:
 
        const float CalcProgress();
 
        void CreateDir(const std::string& dir);
 
        void CreateDirectories();
 
        void CleanInstall();
 
        enum InstallationSteps{
 
            IDLE = 0,
 
            CREATE_DIRECTORIES,
 
            INITIALIZE,
 
            BATTLE_SCENES_INIT,
 
            BATTLE_SCENES_PROCESS,
 
            BATTLE_SCENES_WRITE_ATTACKS,
 
            BATTLE_SCENES_WRITE_ENEMIES,
 
            BATTLE_SCENES_WRITE_FORMATIONS,
 
            BATTLE_MODELS_INIT,
 
            BATTLE_MODELS_PROCESS,
 
            BATTLE_MODELS_CONVERT_INIT,
 
            BATTLE_MODELS_CONVERT,
 
            BATTLE_MODELS_WRITE_CHARACTERS,
 
            BATTLE_MODELS_WRITE_SCENES,
 
            KERNEL_PRICES,
 
            KERNEL_COMMANDS,
 
            KERNEL_ATTACKS,
 
            KERNEL_CHARACTERS,
 
            KERNEL_ITEMS,
 
            KERNEL_GROWTH,
 
            KERNEL_WEAPONS,
 
            KERNEL_ARMORS,
 
            KERNEL_ACCESSORIES,
 
            KERNEL_MATERIA,
 
            KERNEL_KEY_ITEMS,
 
            KERNEL_SUMMON_NAMES,
 
            KERNEL_SAVEMAP,
 
            MEDIA_IMAGES,
 
            MEDIA_SOUNDS_INIT,
 
            MEDIA_SOUNDS,
 
            MEDIA_SOUNDS_INDEX,
 
            MEDIA_MUSICS_INIT,
 
            MEDIA_MUSICS,
 
            MEDIA_MUSICS_HQ,
 
            MEDIA_MUSICS_INDEX,
 
            FIELD_SPAWN_POINTS_AND_SCALE_FACTORS_INIT,
 
            FIELD_SPAWN_POINTS_AND_SCALE_FACTORS,
 
            FIELD_CONVERT,
 
            FIELD_WRITE_INIT,
 
            FIELD_WRITE,
 
            FIELD_WRITE_END,
 
            FIELD_CONVERT_MODELS_INIT,
 
            FIELD_CONVERT_MODELS,
 
            CLEAN,
 
            STATE_COUNT,
 
            DONE = 100,
        };
 
        InstallationSteps installation_state_ = IDLE;
 
        int substeps_;
 
        int cur_substep_;
 
        int step_weight_[STATE_COUNT];
 
        std::vector<std::string> field_model_names_;
 
        std::string input_dir_;
 
        std::string output_dir_;
 
        AdvancedOptions options_;
 
        VGears::Application application_;
 
        std::unique_ptr<ScopedLgp> fields_lgp_;
 
        std::unique_ptr<FieldDataInstaller> field_installer_;
 
        std::unique_ptr<KernelDataInstaller> kernel_installer_;
 
        std::unique_ptr<MediaDataInstaller> media_installer_;
 
        std::unique_ptr<BattleDataInstaller> battle_installer_;
 
        std::function<void(std::string msg, int level, bool progress)> write_output_line_;
 
};