V-Gears/V-Gears-Installer/include/decompiler/field/instruction/FieldModelInstruction.h

/*
 * 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/>.
 */

#pragma once

#include "decompiler/instruction.h"
#include "decompiler/field/FieldEngine.h"

namespace FF7{

    /**
     * A model instruction.
     */
    class FieldModelInstruction : public KernelCallInstruction{

        public:

            /**
             * Processes the instruction.
             *
             * @param func[in] Function to process.
             * @param stack[out] Function stack.
             * @param engine[in] Engine.
             * @param code_gen[in] Code generator.
             */
            virtual void ProcessInst(
              Function& func, ValueStack &stack, Engine *engine, CodeGenerator *code_gen
            ) override;

        private:

            /**
             * Processes a JOIN opcode.
             *
             * Opcode: 0x08
             * Short name: JOIN
             * Long name: Party Field Join
             * Memory layout (2 bytes)
             * |0x08|S|
             *
             * Arguments
             * - const UByte S: Speed that the characters join back together.
             *
             * Causes seperated party characters that have previously been
             * SPLIT onto the field, to be joined back together again; that
             * is, only the party leader becomes visible on the field. This
             * should be called if a previous SPLIT has completed (the party
             * members have finished speaking, or performing their actions,
             * for example). As with SPLIT, the speed of the join is
             * specified, from a scale of 1 (almost instant) to FF (very slow
             * walk), and must be non-zero. In contrast to most MOVE related
             * op codes, the speed is this setting is actually the total
             * number of frames required. Depending on the distance from the
             * player character and the number of frames required, the entity
             * plays a run or walk animation. Also, all characters take the
             * same time irrespective of distance. Calling JOIN without having
             * previously SPLIT the characters will cause the party members to
             * appear at the walkmesh origin and attempt to JOIN from there.
             * This is not normally the required behaviour and should be
             * avoided.
             *
             * @param codegen[in|out] Code generator to append lines.
             */
            void ProcessJOIN(CodeGenerator* code_gen);

            /**
             * Processes a SPLIT opcode.
             *
             * Opcode: 0x09
             * Short name: SPLIT
             * Long name: Party Field Split
             *
             * Memory layout (15 bytes)
             * |0x20|B1/B2|B3/B4|B5/B6|XA|XA|YA|YA|DA|XB|XB|YB|YB|DB|S|
             *
             * Arguments
             * - const Bit[4] B1: Bank for XA, or zero if XA is specified as a
             * literal value.
             * - const Bit[4] B2: Bank for YA, or zero if YA is specified as a
             * literal value.
             * - const Bit[4] B3: Bank for DA, or zero if DA is specified as a
             * literal value.
             * - const Bit[4] B4: Bank for XB, or zero if XB is specified as a
             * literal value.
             * - const Bit[4] B5: Bank for YB, or zero if YB is specified as a
             * literal value.
             * - const Bit[4] B6: Bank for DB, or zero if DB is specified as a
             * literal value.
             * - const Short XA: X-coordinate of the second character in the
             * party after the split, or address for the value if B1 is
             * non-zero.
             * - const Short YA: Y-coordinate of the second character in the
             * party after the split, or address for the value if B2 is
             * non-zero.
             * - const UByte DA: Direction the second character faces after the
             * split, or address for the value if B3 is non-zero.
             * - const Short XB: X-coordinate of the third character in the
             * party after the split, or address for the value if B4 is
             * non-zero.
             * - const Short YB: Y-coordinate of the third character in the
             * party after the split, or address for the value if B5 is
             * non-zero.
             * - const UByte DB: Direction the third character faces after the
             * split, or address for the value if B6 is non-zero.
             * - const UByte S: Speed that the characters split.
             *
             * Causes the common 'split effect' whereby the second and third
             * characters in the current party 'come out' from the party
             * leader. That is, they become visible in the field, starting
             * from the center of the party leader, and move out to the
             * coordinates specified in the argument list. This is commonly
             * used when the other characters in the current party have an
             * action or dialog to perform and must be individually visible in
             * the field. As well as specifying final coordinates for the two
             * other party characters, the directions each character faces
             * after the split are specified as a byte, using the common
             * direction values found throughout the game. Speed is also given
             * and is used to specify the rate at which the characters leave
             * the party leader, using a scale from 1 (almost instant) to FF
             * (extremely slow walk); this must be non-zero. In contrast to
             * most MOVE related op codes, the speed is this setting is
             * actually the total number of frames required. Depending on the
             * distance from the player character and the number of frames
             * required, the entity plays a run or walk animation. Also, all
             * characters take the same time irrespective of distance.
             *
             * @param codegen[in|out] Code generator to append lines.
             */
            void ProcessSPLIT(CodeGenerator* code_gen);
            void ProcessTLKON(CodeGenerator* code_gen, const std::string& entity);
            void ProcessPC(CodeGenerator* code_gen, const std::string& entity);
            void ProcessCHAR(CodeGenerator* code_gen, const std::string& entity);
            void ProcessDFANM(CodeGenerator* code_gen, const std::string& entity, int char_id);
            void ProcessANIME1(CodeGenerator* code_gen, const std::string& entity, int char_id);
            void ProcessVISI(CodeGenerator* code_gen, const std::string& entity);
            void ProcessXYZI(CodeGenerator* code_gen, const std::string& entity);
            void ProcessMOVE(CodeGenerator* code_gen, const std::string& entity);
            void ProcessMSPED(CodeGenerator* code_gen, const std::string& entity);
            void ProcessDIR(CodeGenerator* code_gen, const std::string& entity);
            void ProcessTURNGEN(CodeGenerator* code_gen, const std::string& entity);
            void ProcessGETAI(CodeGenerator* code_gen, const FieldEngine& engine);
            void ProcessANIM_2(CodeGenerator* code_gen, const std::string& entity, int char_id);
            void ProcessCANIM2(CodeGenerator* code_gen, const std::string& entity, int char_id);
            void ProcessCANM_2(CodeGenerator* code_gen, const std::string& entity, int char_id);
            void ProcessCC(CodeGenerator* code_gen, const FieldEngine& engine);

            /**
             * Processes a JUMP opcode.
             *
             * Opcode: 0xC0
             * Short name: JUMP
             * Long name: Jump
             *
             * Memory layout (7 bytes)
             * |0xC2|B1/B2|B3/B4|X|Y|I|Steps|
             *
             * Arguments
             * - const Bit[4] B1: Bank to retrieve X-coordinate, or zero if
             * specifying X as a literal value.
             * - const Bit[4] B2: Bank to retrieve Y-coordinate, or zero if
             * specifying Y as a literal value.
             * - const Bit[4] B3: Bank to retrieve triangle ID, or zero if
             * specifying Z as a literal value.
             * - const Bit[4] B4: Bank to retrieve jump height, or zero if
             * specifying H as a literal value.
             * - const Short X: X-coordinate of the target to jump to, or
             * lower byte specifying address if B1 is non-zero.
             * - const Short Y: Y-coordinate of the target to jump to, or
             * lower byte specifying address if B2 is non-zero.
             * - const Short I: Triangle ID of the target to jump to, or
             * lower byte specifying address if B3 is non-zero.
             * - const UShort Steps: Steps in jump. Must be non-zero if a
             * literal value. Alternatively, lower byte specifies address if
             * B4 is non-zero.
             *
             * Causes the character to jump to the specified point and
             * triangle ID, with the jump curve peaking at a height which is
             * increased by using a larger value for the H argument. In
             * addition, the larger the number, the longer the jump will take
             * to complete. A "normal" value is around 0x15, 0x01 is fast and
             * instantaneous; the argument must not be zero or the game will
             * crash. Whilst this is an unsigned two-byte number, a large
             * value (beyond around 0x60) will not only cause a vast jump
             * height, but also cause the screen to scroll erratically (the
             * larger the number, the more erratic).
             * Main update function go through all entity with JUMP state and
             * if stage is 0 it calculates final Z point according to triangle
             * id. It sets current coords as start coords. The main thing this
             * function does is set B coefficient for later calculation. It
             * defines as follows:
             *   B = (Z_final - Z_start) / steps - steps * 1.45;
             * Then it set current step to 0 and stage to 1. On next update
             * other part of function works. It's calculate real position.
             * First it increment current step number. Then it calculate X and
             * Y. They change linear so nothing interesting here. The Z
             * calculation is as follows:
             *   Z_current = - step^2 * 1.45 + step * B + Z_start;
             * If current substep equal number of steps then we set current
             * triangle to final triangle and set stage to 2. Which finalizes
             * the routine on next opcode call. Neither animation nor sound is
             * specified in this opcode. An animation is played by using an
             * animation opcode such as DFANM, and a SOUND played, before the
             * jump.
             *
             * @param codegen[in|out] Code generator to append lines.
             * @param entity[in] The name of the entity.
             */
            void ProcessJUMP(CodeGenerator* code_gen, const std::string& entity);

            /**
             * Processes a AXYZI opcode
             *
             * Opcode: 0xC1
             * Short name: AXYZI
             * Long name: Entity Get Position
             *
             * Memory layout (8 bytes)
             * |0xC1|B1/B2|B3/B4|A|X|Y|Z|I|
             *
             * Arguments
             * - const Bit[4] B1: Bank to store X.
             * - const Bit[4] B2: Bank to store Y.
             * - const Bit[4] B3: Bank to store Z.
             * - const Bit[4] B4: Bank to store I.
             * - const UByte A: Entity ID whose field object will have its
             * position retrieved from.
             * - const UByte X: Address to store the X-coordinate.
             * - const UByte Y: Address to store the Y-coordinate.
             * - const UByte Z: Address to store the Z-coordinate.
             * - const UByte I: Address to store the ID of the walkmesh
             * triangle the object is standing on.
             *
             * Retrieves the coordinates of the field object that the entity,
             * whose ID specified in A, is associated with. This opcode uses
             * an entity ID, not a field object offset; as such, if an entity
             * ID is given that does not have a field object, this opcode will
             * store zero in each of the four address specified.
             *
             * @param codegen[in|out] Code generator to append lines.
             */
            void ProcessAXYZI(CodeGenerator* code_gen);

            /**
             * Processes a LADER opcode.
             *
             * Opcode: 0xC2
             * Short name: LADER
             * Long name: Ladder
             *
             * Memory layout (15 bytes)
             * |0xC2|B1/B2|B3/B4|X|X|Y|Y|Z|Z|I|I|K|A|D|S|
             *
             * Arguments
             * - const Bit[4] B1: Bank to retrieve X-coordinate, or zero if X
             * is specified as a literal value.
             * - const Bit[4] B2: Bank to retrieve Y-coordinate, or zero if Y
             * is specified as a literal value.
             * - const Bit[4] B3: Bank to retrieve Z-coordinate, or zero if Z
             * is specified as a literal value.
             * - const Bit[4] B4: Bank to retrieve ID, or zero if I is
             * specified as a literal value.
             * - const Short X: X-coordinate of the end of the ladder, or
             * address to find X-coordinate if B1 is non-zero.
             * - const Short Y: Y-coordinate of the end of the ladder, or
             * address to find Y-coordinate if B2 is non-zero.
             * - const Short Z: Z-coordinate of the end of the ladder, or
             * address to find Z-coordinate if B3 is non-zero.
             * - const UShort I: ID of the walkmesh triangle found at the end
             * of the ladder, or address to find ID if B4 is non-zero.
             * - const UByte K: The keys used to move the character on the
             * ladder.
             * - const UByte A: Animation ID for the field object's movement
             * animation.
             * - const UByte D: Direction the character faces when climbing
             * the ladder.
             * - const UByte S: Speed of the animation whilst climbing the
             * ladder.
             *
             * Causes the character to climb a ladder; that is, switching from
             * standard walkmesh movement, to climbing along a line connecting
             * two points on the walkmesh. If B1, B2, B3 or B4 is non-zero,
             * then the value for that particular component is taken from
             * memory using the corresponding bank and address specified,
             * rather than as a literal value. Both retrieved values and
             * literals can be used for different components. If using X, Y, Z
             * or I as addresses, the lower byte should hold the address
             * whilst the higher byte should be zero. The coordinates specify
             * the end-point of the ladder; the current position of the
             * character is used as the start point. The ID of the walkmesh
             * triangle must be specified; this is the triangle the character
             * will step onto after reaching the end point of the ladder. The
             * K value specifies the keys used to move the character across
             * the ladder; keys outside the range found in the table will
             * cause unpredictable behaviour. The animation ID specifies an
             * offset into the field object's animation list; this animation
             * is played at the speed specified by S whilst the character
             * climbs. Finally, the D argument is a direction value in the
             * game's standard direction format, which orients the character
             * on the ladder. This opcode is used as part of the character's
             * entity, rather than in a seperate entity, as with a LINE. A
             * LINE is used to set the start point of the ladder on the
             * walkmesh. When this LINE is crossed by the player, a script in
             * the LINE then uses a PREQ (or one of its variants), calling the
             * script in the party leader that defines the LADER, causing the
             * character to switch to 'climbing mode'. To set up a two-way
             * ladder, two LINEs are used at either end, with different values
             * for the LADER arguments, such as differing end points. If this
             * opcode is used as part of a non-playable character entity, the
             * NPC object will automatically climb from the start to the end
             * point without need for player interaction.
             *
             * @param codegen[in|out] Code generator to append lines.
             * @param entity[in] The name of the entity.
             */
            void ProcessLADER(CodeGenerator* code_gen, const std::string& entity);

            void ProcessSOLID(CodeGenerator* code_gen, const std::string& entity);

            /**
             * Processes an OFST opcode.
             *
             * Opcode: 0xC3
             * Short name: OFST
             * Long name: Offset Object
             *
             * Memory layout (8 bytes)
             * |0xC3|B1/B2|B3/B4|T|X|Y|Z|S|
             *
             * Arguments:
             * - const Bit[4] B1: Bank to retrieve X offset, or zero if X is
             * specified as a literal.
             * - const Bit[4] B2: Bank to retrieve Y offset, or zero if Y is
             * specified as a literal.
             * - const Bit[4] B3: Bank to retrieve Z offset, or zero if Z is
             * specified as a literal.
             * - const Bit[4] B4: Bank to retrieve speed, or zero if S is
             * specified as a literal.
             * - const UByte T: Type of movement.
             * - const Short X: X offset amount, relative to current position,
             * or address to find X offset, if B1 is non-zero.
             * - const Short Y: Y offset amount, relative to current position,
             * or address to find Y offset, if B2 is non-zero.
             * - const Short Z: Z offset amount, relative to current position,
             * or address to find Z offset, if B3 is non-zero.
             * - const UShort S: Speed of the offset movement, if type is
             * non-zero, or address to find speed, if B4 is non-zero.
             *
             * Offsets the field object, belonging to the entity whose script
             * this opcode resides in, by a certain amount. After being
             * offset, the character continues to be constrained in movement
             * as defined by the walkmesh's shape, but at a certain distance
             * away from the normal walkmesh position. Other field objects are
             * unaffected, and their position or movements are maintained on
             * the walkmesh's original position. If B1, B2, B3 or B4 is
             * non-zero, then the value for that particular component is taken
             * from memory using the corresponding bank and address specified,
             * rather than as a literal value. Both retrieved values and
             * literals can be used for different components. If using T, X, Y
             * or S as addresses, the lower byte should hold the address
             * whilst the higher byte should be zero. The amount to offset is
             * specified relative to the current position. If Type is
             * specified, the object moves gradually from its current point to
             * the offset position; this can be used to simulate movements
             * such as elevators. Any type outside the range in the table will
             * cause the offset not to occur. If the object is set to move
             * gradually, then the speed of offset can be set; the greater the
             * number, the slower the object moves to its target offset.
             * Script execution may also be halted until the gradual offset
             * has been completed. For this, see OFSTW.
             *
             * @param codegen[in|out] Code generator to append lines.
             * @param entity[in] The entity name.
             */
            void ProcessOFST(CodeGenerator* codegen, const std::string& entity);
    };

}