FieldDisassembler.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 <array>
#include "installer/decompiler/Disassembler.h"
#include "FieldScriptFormatter.h"
 
class BinaryReader;
class Function;
 
enum OPCODES{
    RET = 0x0,
    REQ = 0x01,
    REQSW = 0x02,
    REQEW = 0x03,
    PREQ = 0x04,
    PRQSW = 0x05,
    PRQEW = 0x06,
    RETTO = 0x07,
    JOIN = 0x08,
    SPLIT = 0x09,
    SPTYE = 0x0A,
    GTPYE = 0x0B,
    DSKCG = 0x0E,
    SPECIAL = 0x0F,
    JMPF = 0x10,
    JMPFL = 0x11,
    JMPB = 0x12,
    JMPBL = 0x13,
    IFUB = 0x14,
    IFUBL = 0x15,
    IFSW = 0x16,
    IFSWL = 0x17,
    IFUW = 0x18,
    IFUWL = 0x19,
    MINIGAME = 0x20,
    TUTOR = 0x21,
    BTMD2 = 0x22,
    BTRLD = 0x23,
    WAIT = 0x24,
    NFADE = 0x25,
    BLINK = 0x26,
    BGMOVIE = 0x27,
    KAWAI = 0x28,
    KAWIW = 0x29,
    PMOVA = 0x2A,
    SLIP = 0x2B,
    BGPDH = 0x2C,
    BGSCR = 0x2D,
    WCLS = 0x2E,
    WSIZW = 0x2F,
    IFKEY = 0x30,
    IFKEYON = 0x31,
    IFKEYOFF = 0x32,
    UC = 0x33,
    PDIRA = 0x34,
    PTURA = 0x35,
    WSPCL = 0x36,
    WNUMB = 0x37,
    STTIM = 0x38,
    GOLDU = 0x39,
    GOLDD = 0x3A,
    CHGLD = 0x3B,
    HMPMAX1 = 0x3C,
    HMPMAX2 = 0x3D,
    MHMMX = 0x3E,
    HMPMAX3 = 0x3F,
    MESSAGE = 0x40,
    MPARA = 0x41,
    MPRA2 = 0x42,
    MPNAM = 0x43,
    MPU = 0x45,
    MPD = 0x47,
    ASK = 0x48,
    MENU = 0x49,
    MENU2 = 0x4A,
    BTLTB = 0x4B,
    HPU = 0x4D,
    HPD = 0x4F,
    WINDOW = 0x50,
    WMOVE = 0x51,
    WMODE = 0x52,
    WREST = 0x53,
    WCLSE = 0x54,
    WROW = 0x55,
    GWCOL = 0x56,
    SWCOL = 0x57,
    STITM = 0x58,
    DLITM = 0x59,
    CKITM = 0x5A,
    SMTRA = 0x5B,
    DMTRA = 0x5C,
    CMTRA = 0x5D,
    SHAKE = 0x5E,
    NOP = 0x5F,
    MAPJUMP = 0x60,
    SCRLO = 0x61,
    SCRLC = 0x62,
    SCRLA = 0x63,
    SCR2D = 0x64,
    SCRCC = 0x65,
    SCR2DC = 0x66,
    SCRLW = 0x67,
    SCR2DL = 0x68,
    MPDSP = 0x69,
    VWOFT = 0x6A,
    FADE = 0x6B,
    FADEW = 0x6C,
    IDLCK = 0x6D,
    LSTMP = 0x6E,
    SCRLP = 0x6F,
    BATTLE = 0x70,
    BTLON = 0x71,
    BTLMD = 0x72,
    PGTDR = 0x73,
    GETPC = 0x74,
    PXYZI = 0x75,
    PLUS_ = 0x76, // PLUS!
    PLUS2_ = 0x77, // PLUS2!
    MINUS_ = 0x78, // MINUS!
    MINUS2_ = 0x79, // MINUS2!
    INC_ = 0x7A, //  INC!
    INC2_ = 0x7B, // INC2!
    DEC_ = 0x7C, // DEC!
    DEC2_ = 0x7D, // DEC2!
    TLKON = 0x7E,
    RDMSD = 0x7F,
    SETBYTE = 0x80,
    SETWORD = 0x81,
    BITON = 0x82,
    BITOFF = 0x83,
    BITXOR = 0x84,
    PLUS = 0x85,
    PLUS2 = 0x86,
    MINUS = 0x87,
    MINUS2 = 0x88,
    MUL = 0x89,
    MUL2 = 0x8A,
    DIV = 0x8B,
    DIV2 = 0x8C,
    MOD = 0x8D,
    MOD2 = 0x8E,
    AND = 0x8F,
    AND2 = 0x90,
    OR = 0x91,
    OR2 = 0x92,
    XOR = 0x93,
    XOR2 = 0x94,
    INC = 0x95,
    INC2 = 0x96,
    DEC = 0x97,
    DEC2 = 0x98,
    RANDOM = 0x99,
    LBYTE = 0x9A,
    HBYTE = 0x9B,
    TWOBYTE = 0x9C,
    SETX = 0x9D,
    GETX = 0x9E,
    SEARCHX = 0x9F,
    PC = 0xA0,
    opCodeCHAR = 0xA1,
    DFANM = 0xA2,
    ANIME1 = 0xA3,
    VISI = 0xA4,
    XYZI = 0xA5,
    XYI = 0xA6,
    XYZ = 0xA7,
    MOVE = 0xA8,
    CMOVE = 0xA9,
    MOVA = 0xAA,
    TURA = 0xAB,
    ANIMW = 0xAC,
    FMOVE = 0xAD,
    ANIME2 = 0xAE,
    ANIM_1 = 0xAF, // ANIM!1
    CANIM1 = 0xB0,
    CANM_1 = 0xB1, // CANM!1
    MSPED = 0xB2,
    DIR = 0xB3,
    TURNGEN = 0xB4,
    TURN = 0xB5,
    DIRA = 0xB6,
    GETDIR = 0xB7,
    GETAXY = 0xB8,
    GETAI = 0xB9,
    ANIM_2 = 0xBA, // ANIM!2
    CANIM2 = 0xBB,
    CANM_2 = 0xBC, // CANM!2
    ASPED = 0xBD,
    CC = 0xBF,
    JUMP = 0xC0,
    AXYZI = 0xC1,
    LADER = 0xC2,
    OFST = 0xC3,
    OFSTW = 0xC4,
    TALKR = 0xC5,
    SLIDR = 0xC6,
    SOLID = 0xC7,
    PRTYP = 0xC8,
    PRTYM = 0xC9,
    PRTYE = 0xCA,
    IFPRTYQ = 0xCB,
    IFMEMBQ = 0xCC,
    MMBUD = 0xCD,
    MMBLK = 0xCE,
    MMBUK = 0xCF,
    LINE = 0xD0,
    LINON = 0xD1,
    MPJPO = 0xD2,
    SLINE = 0xD3,
    SIN = 0xD4,
    COS = 0xD5,
    TLKR2 = 0xD6,
    SLDR2 = 0xD7,
    PMJMP = 0xD8,
    PMJMP2 = 0xD9,
    AKAO2 = 0xDA,
    FCFIX = 0xDB,
    CCANM = 0xDC,
    ANIMB = 0xDD,
    TURNW = 0xDE,
    MPPAL = 0xDF,
    BGON = 0xE0,
    BGOFF = 0xE1,
    BGROL = 0xE2,
    BGROL2 = 0xE3,
    BGCLR = 0xE4,
    STPAL = 0xE5,
    LDPAL = 0xE6,
    CPPAL = 0xE7,
    RTPAL = 0xE8,
    ADPAL = 0xE9,
    MPPAL2 = 0xEA,
    STPLS = 0xEB,
    LDPLS = 0xEC,
    CPPAL2 = 0xED,
    RTPAL2 = 0xEE,
    ADPAL2 = 0xEF,
    MUSIC = 0xF0,
    SOUND = 0xF1,
    AKAO = 0xF2,
    MUSVT = 0xF3,
    MUSVM = 0xF4,
    MULCK = 0xF5,
    BMUSC = 0xF6,
    CHMPH = 0xF7,
    PMVIE = 0xF8,
    MOVIE = 0xF9,
    MVIEF = 0xFA,
    MVCAM = 0xFB,
    FMUSC = 0xFC,
    CMUSC = 0xFD,
    CHMST = 0xFE,
    GAMEOVER = 0xFF
};
 
enum OPCODES_SPECIAL{
    ARROW = 0xF5,
    PNAME = 0xF6,
    GMSPD = 0xF7,
    SMSPD = 0xF8,
    FLMAT = 0xF9,
    FLITM = 0xFA,
    BTLCK = 0xFB,
    MVLCK = 0xFC,
    SPCNM = 0xFD,
    RSGLB = 0xFE,
    CLITM = 0xFF
};
 
enum OPCODES_KAWAI{
    EYETX = 0x00,
    TRNSP = 0x01,
    AMBNT = 0x02,
    Unknown03 = 0x03, // Makou Reactor can write these unknowns.
    Unknown04 = 0x04,
    Unknown05 = 0x05,
    LIGHT = 0x06,
    Unknown07 = 0x07,
    Unknown08 = 0x08,
    Unknown09 = 0x09,
    SBOBJ = 0x0A,
    Unknown0B = 0x0B,
    Unknown0C = 0x0C,
    SHINE = 0x0D,
    RESET = 0xFF
};
 
class FieldEngine;
 
class FieldDisassembler : public Disassembler{
 
    public:
 
        struct InstructionRecord{
 
            unsigned char opcode_size;
 
            unsigned int opcode;
 
            const char* opcode_name;
 
            const char* argument_format;
 
            std::function<InstPtr()> factory_function;
        };
 
        static InstructionRecord FLOW_OPCODES[];
 
        static std::map<std::string, const InstructionRecord*> FieldInstructions();
 
        static int FindId(uint32 start_addr, uint32 end_addr, const InstVec& insts);
 
        FieldDisassembler(FieldScriptFormatter& formatter, FieldEngine* engine, InstVec& insts);
 
        FieldDisassembler(
          FieldScriptFormatter& formatter, FieldEngine* engine,
          InstVec& insts, const std::vector<unsigned char>& raw_script_data
        );
 
        ~FieldDisassembler();
 
        float GetScaleFactor() const;
 
 
        virtual void DoDisassemble() override;
 
    private:
 
        static const int MAGIC;
 
        static const int NUM_SECTIONS;
 
        enum SECTIONS{
 
            SCRIPT = 0,
 
            WALKMESH = 1,
 
            TILE_MAP = 2,
 
            CAMERA_MATRIX = 3,
 
            TRIGGERS = 4,
 
            ENCOUNTERS = 5,
 
            MODELS = 6
        };
 
        struct ScriptInfo{
 
            uint16 entry_point;
 
            uint32 next_entry_point;
 
            size_t index;
        };
 
        struct ScriptHeader{
 
            uint16 magic;
 
            uint8 number_of_entities;
 
            uint8 number_of_models;
 
            uint16 offset_to_strings;
 
            uint16 number_of_akao_offsets;
 
            uint16 scale;
 
            std::array<uint16, 3> blank;
 
            std::array<char, 8> creator;
 
            std::array<char, 8> name;
 
            std::vector<std::array<char, 8>> field_entity_names;
 
            std::vector<uint32> akao_offsets;
 
            std::vector<std::array<uint16, 32>> entity_scripts;
 
            void Read(BinaryReader& reader){
                magic = reader.ReadU16();
                if (magic != MAGIC) throw ScriptHeaderInvalidException();
                number_of_entities = reader.ReadU8();
                number_of_models = reader.ReadU8();
                offset_to_strings = reader.ReadU16();
                number_of_akao_offsets = reader.ReadU16();
                scale = reader.ReadU16();
                for (int i = 0; i < 3; i ++) blank[i] = reader.ReadU16();
                for (int i = 0; i < 8; i ++) creator[i] = reader.ReadU8();
                for (int i = 0; i < 8; i ++) name[i] = reader.ReadU8();
                for (int i = 0; i < number_of_entities; i ++){
                    std::array<char, 8> name;
                    for (int j = 0; j < 8; j ++) name[j] = reader.ReadU8();
                    field_entity_names.emplace_back(name);
                }
                for (int i = 0; i < number_of_akao_offsets; i ++)
                    akao_offsets.emplace_back(reader.ReadU32());
                entity_scripts.reserve(number_of_entities);
                for (int i = 0; i < number_of_entities; i ++){
                    std::array<uint16, 32> scripts;
                    for (int j = 0; j < 32; j ++) scripts[j] = reader.ReadU16();
                    entity_scripts.push_back(scripts);
                }
            }
        };
 
        virtual void Open(const char *filename) override;
 
        void DisassembleIndivdualScript(
          std::string entity_name, size_t entity_index, size_t script_index,
          size_t script_entry_point, uint32 next_script_entry_point, bool is_start, bool is_end
        );
 
        void AddFunc(
          std::string entity_name, size_t entity_index, size_t script_index,
          uint32 next_script_entry_point, const bool is_start, const bool is_end,
          bool to_return_only, std::string func_name
        );
 
        bool ReadOpCodesToPositionOrReturn(
          size_t end_pos, std::vector<float>& point_a, std::vector<float>& point_b
        );
 
        std::unique_ptr<Function> StartFunction(size_t script_index);
 
        void ReadHeader();
 
        void ReadHeader(BinaryReader& reader);
 
        uint32 GetEndOfScriptOffset(
          uint16 cur_entry_point, size_t entity_index, size_t script_index
        );
 
        template<typename T> void ParseOpcode(
          int opcode, std::string name, T instruction, int stack_change, const char* argument_format
        ){
            uint32 full_opcode = (full_opcode << 8) + opcode;
            this->insts_.push_back(instruction);
            this->insts_.back()->SetOpcode(full_opcode);
            this->insts_.back()->SetAddress(this->address_);
            this->insts_.back()->SetStackChange(0);
            this->insts_.back()->SetName(std::string(name));
            this->insts_.back()->SetCodeGenData("");
            this->ReadParams(this->insts_.back(), argument_format);
        }
 
        FieldEngine* engine_;
 
        uint32 header_end_position_ = 0;
 
        std::array<uint32, 7> sections_;
 
        int16 section_pointers_size_;
 
        ScriptHeader header_;
 
        bool loaded_from_raw_data_ = false;
 
        FieldScriptFormatter& formatter_;
 
        float scale_factor_ = 1.0f;
};