/* * 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 . */ #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); }; }