lsd_chunks.h

Go to the documentation of this file.

/* !!!! GENERATED FILE - DO NOT EDIT !!!!
 * --------------------------------------
 *
 * This file is part of liblcf. Copyright (c) 2020 liblcf authors.
 * https://github.com/EasyRPG/liblcf - https://easyrpg.org
 *
 * liblcf is Free/Libre Open Source Software, released under the MIT License.
 * For the full copyright and license information, please view the COPYING
 * file that was distributed with this source code.
 */
 
#ifndef LCF_LSD_CHUNKS_H
#define LCF_LSD_CHUNKS_H
 
namespace LSD_Reader {
    struct ChunkSaveTitle {
        enum Index {
            timestamp = 0x01,
            hero_name = 0x0B,
            hero_level = 0x0C,
            hero_hp = 0x0D,
            face1_name = 0x15,
            face1_id = 0x16,
            face2_name = 0x17,
            face2_id = 0x18,
            face3_name = 0x19,
            face3_id = 0x1A,
            face4_name = 0x1B,
            face4_id = 0x1C
        };
    };
    struct ChunkSaveSystem {
        enum Index {
            scene = 0x01,
            frame_count = 0x0B,
            graphics_name = 0x15,
            message_stretch = 0x16,
            font_id = 0x17,
            switches_size = 0x1F,
            switches = 0x20,
            variables_size = 0x21,
            variables = 0x22,
            message_transparent = 0x29,
            message_position = 0x2A,
            message_prevent_overlap = 0x2B,
            message_continue_events = 0x2C,
            face_name = 0x33,
            face_id = 0x34,
            face_right = 0x35,
            face_flip = 0x36,
            message_active = 0x37,
            music_stopping = 0x3D,
            title_music = 0x47,
            battle_music = 0x48,
            battle_end_music = 0x49,
            inn_music = 0x4A,
            current_music = 0x4B,
            before_vehicle_music = 0x4C,
            before_battle_music = 0x4D,
            stored_music = 0x4E,
            boat_music = 0x4F,
            ship_music = 0x50,
            airship_music = 0x51,
            gameover_music = 0x52,
            cursor_se = 0x5B,
            decision_se = 0x5C,
            cancel_se = 0x5D,
            buzzer_se = 0x5E,
            battle_se = 0x5F,
            escape_se = 0x60,
            enemy_attack_se = 0x61,
            enemy_damaged_se = 0x62,
            actor_damaged_se = 0x63,
            dodge_se = 0x64,
            enemy_death_se = 0x65,
            item_se = 0x66,
            transition_out = 0x6F,
            transition_in = 0x70,
            battle_start_fadeout = 0x71,
            battle_start_fadein = 0x72,
            battle_end_fadeout = 0x73,
            battle_end_fadein = 0x74,
            teleport_allowed = 0x79,
            escape_allowed = 0x7A,
            save_allowed = 0x7B,
            menu_allowed = 0x7C,
            background = 0x7D,
            save_count = 0x83,
            save_slot = 0x84,
            atb_mode = 0x8C
        };
    };
    struct ChunkSaveScreen {
        enum Index {
            tint_finish_red = 0x01,
            tint_finish_green = 0x02,
            tint_finish_blue = 0x03,
            tint_finish_sat = 0x04,
            tint_current_red = 0x0B,
            tint_current_green = 0x0C,
            tint_current_blue = 0x0D,
            tint_current_sat = 0x0E,
            tint_time_left = 0x0F,
            flash_continuous = 0x14,
            flash_red = 0x15,
            flash_green = 0x16,
            flash_blue = 0x17,
            flash_current_level = 0x18,
            flash_time_left = 0x19,
            shake_continuous = 0x1E,
            shake_strength = 0x1F,
            shake_speed = 0x20,
            shake_position = 0x21,
            shake_position_y = 0x22,
            shake_time_left = 0x23,
            pan_x = 0x29,
            pan_y = 0x2A,
            battleanim_id = 0x2B,
            battleanim_target = 0x2C,
            battleanim_frame = 0x2D,
            battleanim_active = 0x2E,
            battleanim_global = 0x2F,
            weather = 0x30,
            weather_strength = 0x31
        };
    };
    struct ChunkSavePicture {
        enum Index {
            name = 0x01,
            start_x = 0x02,
            start_y = 0x03,
            current_x = 0x04,
            current_y = 0x05,
            fixed_to_map = 0x06,
            current_magnify = 0x07,
            current_top_trans = 0x08,
            use_transparent_color = 0x09,
            current_red = 0x0B,
            current_green = 0x0C,
            current_blue = 0x0D,
            current_sat = 0x0E,
            effect_mode = 0x0F,
            current_effect_power = 0x10,
            current_bot_trans = 0x12,
            spritesheet_cols = 0x13,
            spritesheet_rows = 0x14,
            spritesheet_frame = 0x15,
            spritesheet_speed = 0x16,
            frames = 0x17,
            spritesheet_play_once = 0x18,
            map_layer = 0x19,
            battle_layer = 0x1A,
            flags = 0x1B,
            finish_x = 0x1F,
            finish_y = 0x20,
            finish_magnify = 0x21,
            finish_top_trans = 0x22,
            finish_bot_trans = 0x23,
            finish_red = 0x29,
            finish_green = 0x2A,
            finish_blue = 0x2B,
            finish_sat = 0x2C,
            finish_effect_power = 0x2E,
            time_left = 0x33,
            current_rotation = 0x34,
            current_waver = 0x35
        };
    };
    struct ChunkSavePartyLocation {
        enum Index {
            active = 0x01,
            map_id = 0x0B,
            position_x = 0x0C,
            position_y = 0x0D,
            direction = 0x15,
            sprite_direction = 0x16,
            anim_frame = 0x17,
            transparency = 0x18,
            remaining_step = 0x1F,
            move_frequency = 0x20,
            layer = 0x21,
            overlap_forbidden = 0x22,
            animation_type = 0x23,
            lock_facing = 0x24,
            move_speed = 0x25,
            move_route = 0x29,
            move_route_overwrite = 0x2A,
            move_route_index = 0x2B,
            move_route_repeated = 0x2C,
            sprite_transparent = 0x2E,
            route_through = 0x2F,
            anim_paused = 0x30,
            through = 0x33,
            stop_count = 0x34,
            anim_count = 0x35,
            max_stop_count = 0x36,
            jumping = 0x3D,
            begin_jump_x = 0x3E,
            begin_jump_y = 0x3F,
            pause = 0x47,
            flying = 0x48,
            sprite_name = 0x49,
            sprite_id = 0x4A,
            processed = 0x4B,
            flash_red = 0x51,
            flash_green = 0x52,
            flash_blue = 0x53,
            flash_current_level = 0x54,
            flash_time_left = 0x55,
            boarding = 0x65,
            aboard = 0x66,
            vehicle = 0x67,
            unboarding = 0x68,
            preboard_move_speed = 0x69,
            menu_calling = 0x6C,
            pan_state = 0x6F,
            pan_current_x = 0x70,
            pan_current_y = 0x71,
            pan_finish_x = 0x72,
            pan_finish_y = 0x73,
            pan_speed = 0x79,
            encounter_steps = 0x7C,
            encounter_calling = 0x7D,
            map_save_count = 0x83,
            database_save_count = 0x84
        };
    };
    struct ChunkSaveVehicleLocation {
        enum Index {
            active = 0x01,
            map_id = 0x0B,
            position_x = 0x0C,
            position_y = 0x0D,
            direction = 0x15,
            sprite_direction = 0x16,
            anim_frame = 0x17,
            transparency = 0x18,
            remaining_step = 0x1F,
            move_frequency = 0x20,
            layer = 0x21,
            overlap_forbidden = 0x22,
            animation_type = 0x23,
            lock_facing = 0x24,
            move_speed = 0x25,
            move_route = 0x29,
            move_route_overwrite = 0x2A,
            move_route_index = 0x2B,
            move_route_repeated = 0x2C,
            sprite_transparent = 0x2E,
            route_through = 0x2F,
            anim_paused = 0x30,
            through = 0x33,
            stop_count = 0x34,
            anim_count = 0x35,
            max_stop_count = 0x36,
            jumping = 0x3D,
            begin_jump_x = 0x3E,
            begin_jump_y = 0x3F,
            pause = 0x47,
            flying = 0x48,
            sprite_name = 0x49,
            sprite_id = 0x4A,
            processed = 0x4B,
            flash_red = 0x51,
            flash_green = 0x52,
            flash_blue = 0x53,
            flash_current_level = 0x54,
            flash_time_left = 0x55,
            vehicle = 0x65,
            remaining_ascent = 0x6A,
            remaining_descent = 0x6B,
            orig_sprite_name = 0x6F,
            orig_sprite_id = 0x70
        };
    };
    struct ChunkSaveActor {
        enum Index {
            name = 0x01,
            title = 0x02,
            sprite_name = 0x0B,
            sprite_id = 0x0C,
            transparency = 0x0D,
            face_name = 0x15,
            face_id = 0x16,
            level = 0x1F,
            exp = 0x20,
            hp_mod = 0x21,
            sp_mod = 0x22,
            attack_mod = 0x29,
            defense_mod = 0x2A,
            spirit_mod = 0x2B,
            agility_mod = 0x2C,
            skills_size = 0x33,
            skills = 0x34,
            equipped = 0x3D,
            current_hp = 0x47,
            current_sp = 0x48,
            battle_commands = 0x50,
            status_size = 0x51,
            status = 0x52,
            changed_battle_commands = 0x53,
            class_id = 0x5A,
            row = 0x5B,
            two_weapon = 0x5C,
            lock_equipment = 0x5D,
            auto_battle = 0x5E,
            super_guard = 0x5F,
            battler_animation = 0x60
        };
    };
    struct ChunkSaveInventory {
        enum Index {
            party_size = 0x01,
            party = 0x02,
            item_ids_size = 0x0B,
            item_ids = 0x0C,
            item_counts = 0x0D,
            item_usage = 0x0E,
            gold = 0x15,
            timer1_frames = 0x17,
            timer1_active = 0x18,
            timer1_visible = 0x19,
            timer1_battle = 0x1A,
            timer2_frames = 0x1B,
            timer2_active = 0x1C,
            timer2_visible = 0x1D,
            timer2_battle = 0x1E,
            battles = 0x20,
            defeats = 0x21,
            escapes = 0x22,
            victories = 0x23,
            turns = 0x29,
            steps = 0x2A
        };
    };
    struct ChunkSaveTarget {
        enum Index {
            map_id = 0x01,
            map_x = 0x02,
            map_y = 0x03,
            switch_on = 0x04,
            switch_id = 0x05
        };
    };
    struct ChunkSaveEventExecFrame {
        enum Index {
            commands_size = 0x01,
            commands = 0x02,
            current_command = 0x0B,
            event_id = 0x0C,
            triggered_by_decision_key = 0x0D,
            subcommand_path_size = 0x15,
            subcommand_path = 0x16
        };
    };
    struct ChunkSaveEventExecState {
        enum Index {
            stack = 0x01,
            show_message = 0x04,
            abort_on_escape = 0x0B,
            wait_movement = 0x0D,
            keyinput_wait = 0x15,
            keyinput_variable = 0x16,
            keyinput_all_directions = 0x17,
            keyinput_decision = 0x18,
            keyinput_cancel = 0x19,
            keyinput_2kshift_2k3numbers = 0x1A,
            keyinput_2kdown_2k3operators = 0x1B,
            keyinput_2kleft_2k3shift = 0x1C,
            keyinput_2kright = 0x1D,
            keyinput_2kup = 0x1E,
            wait_time = 0x1F,
            keyinput_time_variable = 0x20,
            keyinput_2k3down = 0x23,
            keyinput_2k3left = 0x24,
            keyinput_2k3right = 0x25,
            keyinput_2k3up = 0x26,
            keyinput_timed = 0x29,
            wait_key_enter = 0x2A
        };
    };
    struct ChunkSaveMapEventBase {
        enum Index {
            active = 0x01,
            map_id = 0x0B,
            position_x = 0x0C,
            position_y = 0x0D,
            direction = 0x15,
            sprite_direction = 0x16,
            anim_frame = 0x17,
            transparency = 0x18,
            remaining_step = 0x1F,
            move_frequency = 0x20,
            layer = 0x21,
            overlap_forbidden = 0x22,
            animation_type = 0x23,
            lock_facing = 0x24,
            move_speed = 0x25,
            move_route = 0x29,
            move_route_overwrite = 0x2A,
            move_route_index = 0x2B,
            move_route_repeated = 0x2C,
            sprite_transparent = 0x2E,
            route_through = 0x2F,
            anim_paused = 0x30,
            through = 0x33,
            stop_count = 0x34,
            anim_count = 0x35,
            max_stop_count = 0x36,
            jumping = 0x3D,
            begin_jump_x = 0x3E,
            begin_jump_y = 0x3F,
            pause = 0x47,
            flying = 0x48,
            sprite_name = 0x49,
            sprite_id = 0x4A,
            processed = 0x4B,
            flash_red = 0x51,
            flash_green = 0x52,
            flash_blue = 0x53,
            flash_current_level = 0x54,
            flash_time_left = 0x55
        };
    };
    struct ChunkSaveMapEvent {
        enum Index {
            active = 0x01,
            map_id = 0x0B,
            position_x = 0x0C,
            position_y = 0x0D,
            direction = 0x15,
            sprite_direction = 0x16,
            anim_frame = 0x17,
            transparency = 0x18,
            remaining_step = 0x1F,
            move_frequency = 0x20,
            layer = 0x21,
            overlap_forbidden = 0x22,
            animation_type = 0x23,
            lock_facing = 0x24,
            move_speed = 0x25,
            move_route = 0x29,
            move_route_overwrite = 0x2A,
            move_route_index = 0x2B,
            move_route_repeated = 0x2C,
            sprite_transparent = 0x2E,
            route_through = 0x2F,
            anim_paused = 0x30,
            through = 0x33,
            stop_count = 0x34,
            anim_count = 0x35,
            max_stop_count = 0x36,
            jumping = 0x3D,
            begin_jump_x = 0x3E,
            begin_jump_y = 0x3F,
            pause = 0x47,
            flying = 0x48,
            sprite_name = 0x49,
            sprite_id = 0x4A,
            processed = 0x4B,
            flash_red = 0x51,
            flash_green = 0x52,
            flash_blue = 0x53,
            flash_current_level = 0x54,
            flash_time_left = 0x55,
            waiting_execution = 0x65,
            original_move_route_index = 0x66,
            triggered_by_decision_key = 0x67,
            parallel_event_execstate = 0x6C
        };
    };
    struct ChunkSaveMapInfo {
        enum Index {
            position_x = 0x01,
            position_y = 0x02,
            encounter_rate = 0x03,
            chipset_id = 0x05,
            events = 0x0B,
            lower_tiles = 0x15,
            upper_tiles = 0x16,
            parallax_name = 0x20,
            parallax_horz = 0x21,
            parallax_vert = 0x22,
            parallax_horz_auto = 0x23,
            parallax_horz_speed = 0x24,
            parallax_vert_auto = 0x25,
            parallax_vert_speed = 0x26
        };
    };
    struct ChunkSaveCommonEvent {
        enum Index {
            parallel_event_execstate = 0x01
        };
    };
    struct ChunkSavePanorama {
        enum Index {
            pan_x = 0x01,
            pan_y = 0x02
        };
    };
    struct ChunkSave {
        enum Index {
            title = 0x64,
            system = 0x65,
            screen = 0x66,
            pictures = 0x67,
            party_location = 0x68,
            boat_location = 0x69,
            ship_location = 0x6A,
            airship_location = 0x6B,
            actors = 0x6C,
            inventory = 0x6D,
            targets = 0x6E,
            map_info = 0x6F,
            panorama = 0x70,
            foreground_event_execstate = 0x71,
            common_events = 0x72,
            easyrpg_data = 0xC8
        };
    };
    struct ChunkSaveEasyRpgData {
        enum Index {
            version = 0x01
        };
    };
}
 
#endif