BattleSceneFile.h

Go to the documentation of this file.

/*
 * V-Gears
 * Copyright (C) 2022 V-Gears Team
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <string>
#include <common/File.h>
#include <data/Attack.h>
#include <data/Enemy.h>
#include <data/Formation.h>
 
class BattleSceneFile{
 
    public:
 
        BattleSceneFile(const unsigned int id, File file);
 
        ~BattleSceneFile();
 
        std::vector<Attack> GetAttacks();
 
        std::vector<Enemy> GetEnemies();
 
        std::vector<Formation> GetFormations();
 
    private:
 
        struct Scene{
 
            struct Setup{
 
                u16 location;
 
                u16 next_battle;
 
                u16 escape_counter;
 
                u16 unused;
 
                u16 next_arena_candidates[4];
 
                u16 flags;
 
                u8 layout;
 
                u8 camera;
            };
 
            struct Camera{
 
                struct Position{
 
                    int x;
 
                    int y;
 
                    int z;
 
                    int d_x;
 
                    int d_y;
 
                    int d_z;
                };
 
                Position camera[3];
 
                u8 unused[12];
            };
 
            struct Formation{
 
                u16 id;
 
                int x;
 
                int y;
 
                int z;
 
                u16 row;
 
                u16 cover_flags;
 
                u32 flags;
            };
 
            struct EnemyData{
 
                u8 name[32];
 
                u8 level;
 
                u8 spd;
 
                u8 lck;
 
                u8 eva;
 
                u8 str;
 
                u8 def;
 
                u8 mag;
 
                u8 mdef;
 
                u8 elements[8];
 
                u8 element_rates[8];
 
                u8 animation_index[16];
 
                u16 attacks[16];
 
                u16 attack_camera[16];
 
                u8 item_rate[4];
 
                u8 item[4];
 
                u16 maniputale_attacks[3];
 
                u16 unknown_0;
 
                u16 mp;
 
                u16 ap;
 
                u16 morph;
 
                u8 back_damage;
 
                u8 unused;
 
                u32 hp;
 
                u32 exp;
 
                u32 money;
 
                u32 immunities;
 
                u32 unknown_1;
            };
 
            struct AttackData{
 
                u8 accuracy;
 
                u8 impact_effect;
 
                u8 hurt_anim;
 
                u8 unknown;
 
                u16 mp;
 
                u16 sound;
 
                u16 camera_single;
 
                u16 camera_multiple;
 
                u8 target;
 
                u8 effect;
 
                u8 damage;
 
                u8 power;
 
                u8 condition;
 
                u8 status_change;
 
                u8 additional_effects;
 
                u8 additional_effects_mod;
 
                u32 status;
 
                u16 element;
 
                u16 special;
 
            };
 
            u16 enemy[3];
 
            u16 unused;
 
            Setup setup[4];
 
            Camera camera[4];
 
            Formation formation[4][6];
 
            EnemyData enemy_data[3];
 
            AttackData attack_data[32];
 
            u16 attack_ids[32];
 
            u8 attack_names[32][32];
 
            // TOOD: AI
        };
 
        static std::string LocationToString(const int id);
 
        void Read(File file);
 
        unsigned int id_;
 
        Scene scene_;
 
        std::vector<Attack> attacks_;
 
        std::vector<Enemy> enemies_;
 
        std::vector<Formation> formations_;
 
};