Difference between revisions of "Modify Status Inflictions"

From Final Fantasy Hacktics Wiki
Jump to navigation Jump to search
m (Complete return locations)
m (short summary)
Line 1: Line 1:
  # ROUTINE: MODIFY STATUS INFLICTIONS
+
  # ROUTINE: MODIFY STATUS INFLICTIONS [[#MSIshort|Short summary]]
 
  #  Parameters:
 
  #  Parameters:
 
  #      r4: 0 signifies more strict status removal?
 
  #      r4: 0 signifies more strict status removal?
Line 248: Line 248:
 
  0018e104: [[Post Ability Hardcoding?]]
 
  0018e104: [[Post Ability Hardcoding?]]
 
  0018e434: [[Store status,modified ENTD for current attack]]
 
  0018e434: [[Store status,modified ENTD for current attack]]
 +
 +
== Short summary ==
 +
<span id="MSIshort"></span>
 +
(Nullify somes statuses from current action infliction/removal bytes)
 +
 +
Check if target is riding a unit
 +
    - Nullify status infliction not allowed for riders
 +
 +
Check Frog
 +
  - If target is a frog --> un-frog (toggle mechanics)
 +
 +
If called with r4 = 0x00 (else avoid the three next lines) 
 +
    Zero out innate status (permanently inflicted)
 +
    Zero out status that don't expire (no need to refresh CT)
 +
    Zero out immortal  if target is immortal
 +
 +
Zero out innate status from removal byte
 +
Zero out statuses not present in inflicted status list (0x01bb)
 +
 +
Zero out status X infliction if it can't stack on target current statuses
 +
Zero out statuses from action 0x001b if they are in the cancel list of status X
 +
 +
returns r2 = 0x00 if no statuses are inflicted

Revision as of 20:02, 13 June 2021

# ROUTINE: MODIFY STATUS INFLICTIONS Short summary
#   Parameters:
#       r4: 0 signifies more strict status removal?
#   Returns:
#       r2 = {
#           0, If no status is being inflicted or removed by the current action
#           Non-zero, otherwise
#       }

00184b24: 00803821 addu r7,r4,r0
00184b28: 3c028019 lui r2,0x8019
00184b2c: 8c422d98 lw r2,0x2d98(r2)             #   Target
00184b30: 00005021 addu r10,r0,r0               #   Result = 0
00184b34: 90430005 lbu r3,0x0005(r2)            #   Target's ENTD flags
00184b38: 90420182 lbu r2,0x0182(r2)            #   Target's Mount information
00184b3c: 00000000 nop
00184b40: 30420080 andi r2,r2,0x0080            #   Whether or not Target is riding a unit (true=0x80, false=0)
00184b44: 1040000f beq r2,r0,0x00184b84         #   if (Target is riding a unit) {
00184b48: 30680004 andi r8,r3,0x0004            
00184b4c: 00003021 addu r6,r0,r0                #       Set statusByteIndex = 0
                                                #       do {
00184b50: 3c038019 lui r3,0x8019
00184b54: 8c632d90 lw r3,0x2d90(r3)             #           Action
00184b58: 3c018019 lui r1,0x8019
00184b5c: 00260821 addu r1,r1,r6
00184b60: 9024f60c lbu r4,-0x09f4(r1)           #           Rider-allowed status inflictions byte (#statusByteIndex)
00184b64: 00661821 addu r3,r3,r6
00184b68: 9062001b lbu r2,0x001b(r3)            #           Action's Status Infliction byte (#statusByteIndex)
00184b6c: 24c60001 addiu r6,r6,0x0001           #           Set statusByteIndex = statusByteIndex + 1
00184b70: 00441024 and r2,r2,r4                 #           Zero out statuses that aren't allowed on riders
00184b74: a062001b sb r2,0x001b(r3)             #           Store as Action's Status Infliction byte (#statusByteIndex)
00184b78: 28c20005 slti r2,r6,0x0005            
00184b7c: 1440fff4 bne r2,r0,0x00184b50         #       } while (statusByteIndex < 5)
00184b80: 00000000 nop
                                                #   }
00184b84: 3c048019 lui r4,0x8019
00184b88: 8c842d90 lw r4,0x2d90(r4)             #   Action
00184b8c: 00000000 nop
00184b90: 9083001d lbu r3,0x001d(r4)            #   Action's Status Infliction byte (#3)
00184b94: 00000000 nop
00184b98: 30620002 andi r2,r3,0x0002            #   Check for Frog
00184b9c: 10400013 beq r2,r0,0x00184bec         #   If (Action is inflicting Frog status) {
00184ba0: 00003021 addu r6,r0,r0
00184ba4: 3c028019 lui r2,0x8019
00184ba8: 8c422d98 lw r2,0x2d98(r2)             #       Target
00184bac: 00000000 nop
00184bb0: 9042005a lbu r2,0x005a(r2)            #       Target's current status byte (#3)
00184bb4: 00000000 nop
00184bb8: 30420002 andi r2,r2,0x0002            #       Check if Target is currently a Frog (in Frog status)
00184bbc: 1040000b beq r2,r0,0x00184bec         
00184bc0: 00000000 nop
00184bc4: 14e00009 bne r7,r0,0x00184bec         #       if ((Target is a Frog) && ([Input parameter] == 0)) {
00184bc8: 306200fd andi r2,r3,0x00fd            
00184bcc: a082001d sb r2,0x001d(r4)             #           Zero out Frog status from current action's inflicted status
00184bd0: 3c038019 lui r3,0x8019
00184bd4: 8c632d90 lw r3,0x2d90(r3)             #           Action
00184bd8: 00000000 nop
00184bdc: 90620022 lbu r2,0x0022(r3)            #           Action's Status Removal byte (#3)
00184be0: 00000000 nop
00184be4: 34420002 ori r2,r2,0x0002             #           Action removes Frog status
00184be8: a0620022 sb r2,0x0022(r3)             #           Save to Action's Status Removal byte (#3)
                                                #       }
                                                #   }
                                                #   do {
00184bec: 14e00023 bne r7,r0,0x00184c7c         #       if ([Input parameter] == 0) {
00184bf0: 28c20003 slti r2,r6,0x0003            
00184bf4: 1040000a beq r2,r0,0x00184c20         #           if (statusIndex < 3) {  // Status that doesn't expire
00184bf8: 00000000 nop
00184bfc: 3c058019 lui r5,0x8019
00184c00: 8ca52d90 lw r5,0x2d90(r5)             #               Action
00184c04: 3c028019 lui r2,0x8019
00184c08: 8c422d98 lw r2,0x2d98(r2)             #               Target
00184c0c: 00000000 nop
00184c10: 00461021 addu r2,r2,r6                
00184c14: 90430058 lbu r3,0x0058(r2)            #               [Status byte] = Target's Current Status Byte (#statusIndex)
00184c18: 0806130f j 0x00184c3c
00184c1c: 00a62821 addu r5,r5,r6
                                                #           } else {                // Status that does expire
00184c20: 3c058019 lui r5,0x8019
00184c24: 8ca52d90 lw r5,0x2d90(r5)             #               Action
00184c28: 3c028019 lui r2,0x8019
00184c2c: 8c422d98 lw r2,0x2d98(r2)             #               Target
00184c30: 00a62821 addu r5,r5,r6
00184c34: 00461021 addu r2,r2,r6
00184c38: 9043004e lbu r3,0x004e(r2)                            [Status byte] = Target's Innate Status Byte (#statusIndex)
                                                #           }
00184c3c: 90440053 lbu r4,0x0053(r2)            #           Target's Status Immunities Byte (#statusIndex)
00184c40: 90a2001b lbu r2,0x001b(r5)            #           Action's Status Infliction Byte (#statusIndex)
00184c44: 00641827 nor r3,r3,r4                 #           [Status byte] = [Statuses not in the status byte or the immunities]
00184c48: 00431024 and r2,r2,r3                 #           Zero out statuses that are already on the unit and don't expire (either because the status itself doesn't expire, 
                                                #               or because the unit has the status innately)
00184c4c: 1100000b beq r8,r0,0x00184c7c         #           Check whether or not Target is Immortal
00184c50: a0a2001b sb r2,0x001b(r5)             #           Save as statuses inflicted (#statusIndex)

                                                #           if (Target is Immortal) {
00184c54: 3c028019 lui r2,0x8019
00184c58: 8c422d90 lw r2,0x2d90(r2)             #               Action
00184c5c: 3c018006 lui r1,0x8006
00184c60: 00260821 addu r1,r1,r6
00184c64: 902362ee lbu r3,0x62ee(r1)            #               Immortal Immunities? (#statusIndex)
00184c68: 00461021 addu r2,r2,r6                #               
00184c6c: 9044001b lbu r4,0x001b(r2)            #               Action Status Infliction Byte (#statusIndex)
00184c70: 00031827 nor r3,r0,r3                 #               
00184c74: 00832024 and r4,r4,r3                 #               Zero out Immortal Immunities?
00184c78: a044001b sb r4,0x001b(r2)             #               Save as Action Status Infliction Byte (#statusIndex)
                                                #           }
                                                #       }
00184c7c: 3c058019 lui r5,0x8019
00184c80: 8ca52d90 lw r5,0x2d90(r5)             #       Action
00184c84: 3c048019 lui r4,0x8019
00184c88: 8c842d98 lw r4,0x2d98(r4)             #       Target
00184c8c: 00a62821 addu r5,r5,r6
00184c90: 00862021 addu r4,r4,r6                
00184c94: 24c60001 addiu r6,r6,0x0001           #       statusIndex = statusIndex + 1
00184c98: 9083004e lbu r3,0x004e(r4)            #       Target's Innate Status Byte (#[old statusIndex])
00184c9c: 90a20020 lbu r2,0x0020(r5)            #       Action's Status Removal Byte (#[old statusIndex])       
00184ca0: 908401bb lbu r4,0x01bb(r4)            #       Inflicted Status List Byte (#[old statusIndex])
00184ca4: 00031827 nor r3,r0,r3                 #       
00184ca8: 00431024 and r2,r2,r3                 #       Zero out Innate Statuses in Status Removal byte
00184cac: 00441024 and r2,r2,r4                 #       Zero out statuses not in Inflicted Status List Byte flags in Status Removal byte
00184cb0: a0a20020 sb r2,0x0020(r5)             #       Save as Status Removal byte
00184cb4: 28c20005 slti r2,r6,0x0005
00184cb8: 1440ffcc bne r2,r0,0x00184bec         #   } while (statusIndex < 5)
00184cbc: 00000000 nop
00184cc0: 14e00051 bne r7,r0,0x00184e08         #   if ([Input parameter] == 0) {
00184cc4: 00003021 addu r6,r0,r0                #       statusIndex = 0
00184cc8: 340b0080 ori r11,r0,0x0080
00184ccc: 3c098006 lui r9,0x8006
00184cd0: 25295def addiu r9,r9,0x5def           #       [Status Stack On pointer] = 0x80065def
                                                #       do {
00184cd4: 04c10002 bgez r6,0x00184ce0
00184cd8: 00c01021 addu r2,r6,r0
00184cdc: 24c20007 addiu r2,r6,0x0007
00184ce0: 000238c3 sra r7,r2,0x03               #           statusIndex / 8 (integer division)
00184ce4: 3c028019 lui r2,0x8019
00184ce8: 8c422d90 lw r2,0x2d90(r2)             #           Action
00184cec: 30c30007 andi r3,r6,0x0007            #           statusIndex mod 8
00184cf0: 00471021 addu r2,r2,r7                
00184cf4: 9042001b lbu r2,0x001b(r2)            #           Action's Inflict Status byte for this status
00184cf8: 006b1807 srav r3,r11,r3               #           Current Status flag (0x80 >> (statusIndex mod 8)) 
00184cfc: 00431024 and r2,r2,r3                 #           Check if Current Status is being inflicted (#statusIndex)   
00184d00: 10400019 beq r2,r0,0x00184d68         #           if (Current Status is being inflicted) {
00184d04: 00000000 nop
00184d08: 00002821 addu r5,r0,r0                #               innerIndex = 0
00184d0c: 00034027 nor r8,r0,r3                 #               Bitmask with current status (#statusIndex) negated
00184d10: 01202021 addu r4,r9,r0                #               [Status Stack on pointer]
                                                #               do {
00184d14: 3c028019 lui r2,0x8019
00184d18: 8c422d98 lw r2,0x2d98(r2)             #                   Target
00184d1c: 90830000 lbu r3,0x0000(r4)            #                   Load Status Can't Stack On Byte (#innerIndex)
00184d20: 00451021 addu r2,r2,r5
00184d24: 90420058 lbu r2,0x0058(r2)            #                   Target Current Status Byte (#innerIndex)   
00184d28: 00000000 nop
00184d2c: 00431024 and r2,r2,r3                 #                   Statuses from Target Current Status Byte (#innerIndex) that are also in Can't Stack On Byte (#innerIndex)
00184d30: 10400009 beq r2,r0,0x00184d58         #                   if (Statuses exist in Target Current Status Byte (#innerIndex) that are also in Can't Stack On Byte (#innerIndex)) {
00184d34: 24840001 addiu r4,r4,0x0001
00184d38: 3c038019 lui r3,0x8019
00184d3c: 8c632d90 lw r3,0x2d90(r3)             #                       Action
00184d40: 00000000 nop
00184d44: 00671821 addu r3,r3,r7                
00184d48: 9062001b lbu r2,0x001b(r3)            #                       Load Action Inflict Status byte (based on statusIndex - outer loop's index)       
00184d4c: 00000000 nop
00184d50: 00481024 and r2,r2,r8                 #                       Zero out current status (outer loop, #statusIndex)
00184d54: a062001b sb r2,0x001b(r3)             #                       Save as Load Action Inflict Status byte (based on statusIndex)
                                                #                   }
00184d58: 24a50001 addiu r5,r5,0x0001           #                   innerIndex = innerIndex + 1
00184d5c: 28a20005 slti r2,r5,0x0005
00184d60: 1440ffec bne r2,r0,0x00184d14         #               } while (innerIndex < 5)
00184d64: 00000000 nop
                                                #           }
00184d68: 24c60001 addiu r6,r6,0x0001           #           Set statusIndex = statusIndex + 1
00184d6c: 28c20028 slti r2,r6,0x0028
00184d70: 1440ffd8 bne r2,r0,0x00184cd4         #       
00184d74: 25290010 addiu r9,r9,0x0010           #           [Status Stack on pointer] = [Status Stack on pointer] + sizeof(Status pointer data) (= 16)
                                                #       } while (statusIndex < 40)
00184d78: 00003021 addu r6,r0,r0                #       statusIndex = 0
00184d7c: 34090080 ori r9,r0,0x0080
00184d80: 3c088006 lui r8,0x8006
00184d84: 25085dea addiu r8,r8,0x5dea           #       [Status Cancels pointer] = 0x80065dea
                                                #       do {
00184d88: 04c10002 bgez r6,0x00184d94
00184d8c: 00c01021 addu r2,r6,r0
00184d90: 24c20007 addiu r2,r6,0x0007
00184d94: 000238c3 sra r7,r2,0x03               #           statusIndex / 8 (integer division)
00184d98: 3c028019 lui r2,0x8019
00184d9c: 8c422d90 lw r2,0x2d90(r2)             #           Action
00184da0: 30c30007 andi r3,r6,0x0007            #           statusIndex mod 8
00184da4: 00471021 addu r2,r2,r7
00184da8: 9042001b lbu r2,0x001b(r2)            #           Action's Current Inflict Status Byte (based on statusIndex)
00184dac: 00691807 srav r3,r9,r3                #           Current Status flag (0x80 >> (statusIndex mod 8))
00184db0: 00431024 and r2,r2,r3                 #           Check if Current Status is being inflicted (#statusIndex)
00184db4: 1040000f beq r2,r0,0x00184df4         #           if (Current Status is being inflicted) {
00184db8: 00000000 nop
00184dbc: 00002821 addu r5,r0,r0                #               innerIndex = 0
00184dc0: 01003821 addu r7,r8,r0                #               [Status Cancels pointer]
                                                #               do {
00184dc4: 3c048019 lui r4,0x8019
00184dc8: 8c842d90 lw r4,0x2d90(r4)             #                   Action
00184dcc: 90e30000 lbu r3,0x0000(r7)            #                   Status Cancels pointer (#innerIndex)
00184dd0: 00852021 addu r4,r4,r5
00184dd4: 24a50001 addiu r5,r5,0x0001           #                   innerIndex = innerIndex + 1
00184dd8: 9082001b lbu r2,0x001b(r4)            #                   Action's Status Infliction Byte (#innerIndex)
00184ddc: 00031827 nor r3,r0,r3
00184de0: 00431024 and r2,r2,r3                 #                   Zero out any statuses that this status cancels
00184de4: a082001b sb r2,0x001b(r4)             #                   Save as Action's Status Infliction Byte (#innerIndex)
00184de8: 28a20005 slti r2,r5,0x0005                   
00184dec: 1440fff5 bne r2,r0,0x00184dc4
00184df0: 24e70001 addiu r7,r7,0x0001           #      
                                                #               } while (innerIndex < 5)

00184df4: 24c60001 addiu r6,r6,0x0001           #           statusIndex = statusIndex + 1
00184df8: 28c20028 slti r2,r6,0x0028
00184dfc: 1440ffe2 bne r2,r0,0x00184d88
00184e00: 25080010 addiu r8,r8,0x0010           #           [Status Cancels pointer] = [Status Cancels pointer] + sizeof(Status pointer data) (= 16)
                                                #       } while (statusIndex < 40)
00184e04: 00003021 addu r6,r0,r0
                                                #   }
                                                #   statusByteIndex = 0
00184e08: 3c048019 lui r4,0x8019
00184e0c: 8c842d90 lw r4,0x2d90(r4)             #   Action
00184e10: 00000000 nop                          #   do {
00184e14: 00861821 addu r3,r4,r6
00184e18: 24c60001 addiu r6,r6,0x0001           #       statusByteIndex = statusByteIndex + 1
00184e1c: 9062001b lbu r2,0x001b(r3)            #       Action's Inflict Status Byte (#[old statusByteIndex])
00184e20: 90630020 lbu r3,0x0020(r3)            #       Action's Remove Status Byte (#[old statusByteIndex])
00184e24: 01421021 addu r2,r10,r2
00184e28: 00435021 addu r10,r2,r3               #       Result = Result + Action's Inflict Status Byte + Action's Remove Status Byte
00184e2c: 28c20005 slti r2,r6,0x0005
00184e30: 1440fff7 bne r2,r0,0x00184e10
00184e34: 00000000 nop                          #   } while (statusByteIndex < 5)
00184e38: 03e00008 jr r31                       #   Return Result (Non-zero if at least one status is being inflicted or removed, zero otherwise)
00184e3c: 01401021 addu r2,r10,r0


Return Locations

001881fc: 38 (100%)
00180070: Set target for mounted unit, move find item/trap
00187054: Ability Elemental?
00187e64: Formula 01 - 06 Aftermath
001881fc: 38 (100%)
0018b070: Perform reaction abilities
0018c4c8: Main Reaction Routine - performs ability effects
0018d9d4: Process Expiring Statuses
0018db70: Poison Marsh Routine
0018dca4: Traps Routine
0018dccc: Traps Routine
0018e104: Post Ability Hardcoding?
0018e434: Store status,modified ENTD for current attack

Short summary


(Nullify somes statuses from current action infliction/removal bytes)

Check if target is riding a unit
   - Nullify status infliction not allowed for riders

Check Frog
  - If target is a frog --> un-frog (toggle mechanics)

If called with r4 = 0x00 (else avoid the three next lines)  
    Zero out innate status (permanently inflicted) 
    Zero out status that don't expire (no need to refresh CT)
    Zero out immortal  if target is immortal

Zero out innate status from removal byte
Zero out statuses not present in inflicted status list (0x01bb)

Zero out status X infliction if it can't stack on target current statuses
Zero out statuses from action 0x001b if they are in the cancel list of status X

returns r2 = 0x00 if no statuses are inflicted