Punkline
Dr. Frankenstack
- Joined
- May 15, 2015
- Messages
- 423
Made a note in the Crazy Hand thread that I'd post a WIP of this when I had something interesting.
@Achilles1515 @Ampers @Tater @tatatat0
Tyadran
Guesmu
@Itaru @MagicScrumpy
This is an extension of the existing subaction event 5C (IASA flag)
The original syntax is barren; just an opcode that tells the system to set a flag.
I’ve added 4 new features to this event in a way that preserves its original functionality.
These shouldn't change much, but more may be added to it later:
5C xx FLAG - IASA flag toggle
5D xx ASID - IASA function override
5E xx ASID - Animation interrupt function override
5F EE ASID - Force immediate action state transition
---
You may use this new syntax (in Crazy Hand!) to set interrupt logic for moves with a single line of data, and you can use it to transition into action states in a way that allows you to pair the new state with unique subaction event data that it doesn't normally go with.
If used in a way that extends the space available for subaction events, it's very easy to chain several action state changes over the course of a single (large) subaction read.
I'll post some examples soon.
@Achilles1515 @Ampers @Tater @tatatat0
Tyadran
Guesmu
@Itaru @MagicScrumpyThis is an extension of the existing subaction event 5C (IASA flag)
The original syntax is barren; just an opcode that tells the system to set a flag.
I’ve added 4 new features to this event in a way that preserves its original functionality.
These shouldn't change much, but more may be added to it later:
5C xx FLAG - IASA flag toggle
FLAG - IASA flag -- 0 flags the IASA bit on (default 5C behavior) -- not-0 flags the IASA bit off
5D xx ASID - IASA function override
ASID - 11-bit ASID for defining a specific IASA function
-- makes IASA logic match another action state by ID
5E xx ASID - Animation interrupt function override
ASID - 11-bit ASID for defining a specific animation interrupt
-- set the logic to match another action state by ID
5F EE ASID - Force immediate action state transition
EE - number of events to continue reading from the old action state. (ignores timer events, but counts them)
bit 0x8000 of ASID - a flag that tells the new action state to only use subaction events from the old action state
-- these events are read after the transition, but before the new subaction event data is read; all in 1 frame.
ASID - 11-bit ASID for action state transition. New action state starts on frame 0.bit 0x8000 of ASID - a flag that tells the new action state to only use subaction events from the old action state
-- using this flag will cause EE to be ignored.
---
You may use this new syntax (in Crazy Hand!) to set interrupt logic for moves with a single line of data, and you can use it to transition into action states in a way that allows you to pair the new state with unique subaction event data that it doesn't normally go with.
If used in a way that extends the space available for subaction events, it's very easy to chain several action state changes over the course of a single (large) subaction read.
I'll post some examples soon.
Code:
-==-
Custom Subaction Event -- Actionstate Logic
Adds the ability to change IASA and animation interrupt logic from the default 5C syntax.
Also allows for forcing new action state transitions.
5C - IASA flag toggle
5D - IASA function override
5E - Animation interrupt function override
5F - Force new action state
[Punkline]
Version -- DOL Offset ------ Hex to Replace ---------- ASM Code
1.02 ----- 0x80071960 --- 98032218 -> Branch
80A40008 80A50000
54A501BF 41A20024
7C0802A6 90010004
9421FFF8
bl <EX5C_parseExtension>
38210008 80010004
7C0803A6 48000008
98032218 00000000
<EX5C_parseExtension>
7C0802A6 90010004
9421FF80 BC610008
7C7F1B78 80840008
54BB47BF 54BC863E
54BD053E 41820108
83DF0018 7C1DF040
41800010 7C1EE850
83DF0020 4800000C
7FA0EB78 83DF001C
54002834 7FDE0214
281B0001 418200CC
281B0002 418200B8
7C9E2378 3BDE0004
54BB8FFE 7FA4EB78
807F0000 3D808008
618CCFAC 7D8803A6
4E800021 281B0000
4182000C 93DF03EC
480000A8 83BF03EC
93DF03EC 281C0000
41820060 807F03EC
28030000 41820054
48000045 7C0802A6
90010004 9421FFC8
DBE10030 DBC10028
BF610014 C3C288D4
D3DF03E4 3BBF03E4
837F0000 3FE0803C
63FF06E8 C3C288D8
3D808007 618C32EC
7D8803A6 4E800021
3B9CFFFF 4BFFFFA0
3BBDFFFC C00288D8
D01F03E4 93BF03EC
48000028 837E000C
937F21A0 4800001C
837E0010 937F219C
48000010 8B7F2218
737B007F 9B7F2218
B8610008 38210080
80010004 7C0803A6
4E800020
Code:
$Custom Subaction Event -- Action State Logic 1.0 [Punkline]
C2071960 00000031
80A40008 80A50000
54A501BF 41A20024
7C0802A6 90010004
9421FFF8 4800001D
38210008 80010004
7C0803A6 48000158
98032218 48000150
7C0802A6 90010004
9421FF80 BC610008
7C7F1B78 80840008
54BB47BF 54BC863E
54BD053E 41820108
83DF0018 7C1DF040
41800010 7C1EE850
83DF0020 4800000C
7FA0EB78 83DF001C
54002834 7FDE0214
281B0001 418200CC
281B0002 418200B8
7C9E2378 3BDE0004
54BB8FFE 7FA4EB78
807F0000 3D808008
618CCFAC 7D8803A6
4E800021 281B0000
4182000C 93DF03EC
480000A8 83BF03EC
93DF03EC 281C0000
41820060 807F03EC
28030000 41820054
48000045 7C0802A6
90010004 9421FFC8
DBE10030 DBC10028
BF610014 C3C288D4
D3DF03E4 3BBF03E4
837F0000 3FE0803C
63FF06E8 C3C288D8
3D808007 618C32EC
7D8803A6 4E800021
3B9CFFFF 4BFFFFA0
3BBDFFFC C00288D8
D01F03E4 93BF03EC
48000028 837E000C
937F21A0 4800001C
837E0010 937F219C
48000010 8B7F2218
737B007F 9B7F2218
B8610008 38210080
80010004 7C0803A6
4E800020 00000000
Code:
#Custom Subaction Event -- Action State Logic 0.1 [Punkline]
#ASM is for MCM, use labels to assemble in ASM<>Wiird
#@80071960: stb r0, 0x2218(r3) (storing modified IASA flag for normal attacks)
#r5-12, cr0, are safe; LR is not safe
#r3 == internal player data pointer
#r4 == player event data
#--this injection simply checks if the original syntax is used (blank) and if not, runs the code
lwz r5, 0x8(r4)
lwz r5, 0(r5)
rlwinm. r5, r5, 0, 6, 31 #mask out opcode, check if remaining argument is == 0
beq+ default #if it is (5C000000) then just use the default instruction
#else, branch link into standalone function that adds new parse features to vanilla event 5C
mflr r0
stw r0, 0x4(sp)
stwu sp, -0x8(sp)
bl <EX5C_parseExtension> #standalone function, can work with labels in gecko code
addi sp, sp, 0x8
lwz r0, 0x4(sp)
mtlr r0
b return
default:
stb r0, 0x2218(r3)
return: #from injection code
.long 0x00000000
/*EX5C_parseExtension
r3 == internal player data pointer
r4 == player event table -- only used to continue reading event data after action state transition
r5 == incoming event data -- this is what's actually interpreted.
--You can pass r5 from other codes outside of the subaction event system. the opcode is ignored.
This adds the following extra capabilities to the 5C event:
-- can toggle IASA flag on or off
-- can override IASA function pointer with new logic
-- can override animation interrupt function pointer with new logic
-- can force an action state transition in a way that continues reading subaction events from the old action state (before the next frame)
Functionality is determined by a 2-bit ID checked in the passed r5 value. See other comments for more details behind the syntax*/
mflr r0
stw r0, 0x4(sp)
stwu sp, -0x80(sp)
stmw r3, 0x8(sp) #keep the context safe while we potentially go crazy with registers
mr r31, r3
lwz r4, 0x8(r4)
rlwinm. r27, r5, 8, 30, 31 #r27 = extracted 2-bit function id
rlwinm r28, r5, 16, 24, 31 #r28 = extracted 8-bit AA (determined by function)
rlwinm r29, r5, 0, 20, 31 #r29 = extracted 11-bit BBBB (determined by function) (5 leftmost bits are ignored in hword, can be used as flags)
beq- option5C #if id is 0 (5C) then input was a non-0 argument for the default 5C syntax.
#else, we're going to find the move logic from the input ASID in r29
lwz r30, 0x18(r31) #ASID division between common/character dependent moves
cmplw r29, r30 #is input ID < threshold? (usually 0x155)
blt- commonASID
uncommonASID:
sub r0, r29, r30 #uncommon ASIDs use their own 0-based character move index
lwz r30, 0x20(r31) #if ASID >= (0x155) then load uncommon move table
b loadMoveData
commonASID:
mr r0, r29
lwz r30, 0x1C(r31) #if ASID < (0x155) then load common move table
loadMoveData:
rlwinm r0, r0, 5, 0, 26 #shift left 5 (1 = 32)
add r30, r30, r0 #r30 = pointer to move data (from ASID)
cmplwi r27, 1
beq option5D #if id is 1 (5D) then the syntax is used to override IASA logic.
cmplwi r27, 2
beq option5E #if id is 2 (5E) then the syntax is used to override animation interrupt logic.
#else, id is 3 (max 2-bit range) if id is 3 (5F) then use syntax to force an immediate action state transition.
option5F: /*force action state transition
5F AA BBBB
AA - 8-bit number of events to continue reading without timer events post-transition
BBBB - 11-bit ASID ID
flag - bit 0x8000 of BBBB is a flag that tells the new action state to use the old subaction event data. Ignores AA
-- this option is complicated by the fact that changing an action state cuts off the remaining subaction event data from the state it came from.
-- with the AA argument, you can specify a number of subaction events to read before returning to handle the new action state's subaction event data.
-- see the SSBM Data sheet for more info on actionstate IDs*/
mr r30, r4 #use the passed event pointer in r4
addi r30, r30, 0x4 #r30 = next event from old subaction event data (passed in r4)
rlwinm r27, r5, 17, 31, 31 #r27 = subaction event override flag. If true, the old subaction events will continue in new action state
#first, pass the id over to the aerial attack transition function to force an action state
mr r4, r29 #pass the ID
lwz r3, 0(r31) #pass external player data pointer
lis r12, 0x8008
ori r12, r12, 0xcfac #pointer to function
mtlr r12
blrl #change action state
#now that the action state has transitioned, subaction event data from the previous state is gone
#so we take advantage of the fact that we still have the pointer in a saved register and continue reading event data.
#the number of events that we read is determined by the parsed AA value, stored in r28. A value of 00 reads no extra events
cmplwi r27, 0
beq- storeNewData
storeOldData:
stw r30, 0x3EC(r31) #if subaction event override flag was detected, just continue the old event data
b return
storeNewData: #otherwise, we're going to attempt to sandwich as much data specified by AA between states
lwz r29, 0x3EC(r31) #r29 = new data start
stw r30, 0x3EC(r31) #set event pointer to continue reading our old data
eventReadLoop:
cmplwi r28, 0 #if AA value is 0, then exit loop
beq- exitLoop
lwz r3, 0x3EC(r31)
cmplwi r3, 0 #if event pointer contains no data, exit loop
beq- exitLoop
#else, read a single event and decrement AA by -1
bl returnFromEventRead #set up the lr to continue our event reading loop
mflr r0 #reconstruct the prolog of the SAEvent parsing loop function
stw r0, 0x4(sp)
stwu sp, -0x38(sp)
stfd f31, 0x30(sp)
stfd f30, 0x28(sp)
stmw r27, 0x14(sp)
lfs f30, -0x772C(rtoc)
stfs f30, 0x3E4(r31) #set event timer to 1.0
#reconstruct context for our intrusive branch
addi r29, r31, 0x3E4 #r29 = pointer to player data offset 0x3E4
lwz r27, 0(r31) #r27 = external player data pointer
lis r31, 0x803c
ori r31, r31, 0x06e8 #r31 = 803C06E8 (lookup table for player events)
lfs f30, -0x7728(rtoc) #f30 = 0
#branch into player event parsing loop
lis r12, 0x8007
ori r12, r12, 0x32ec #this is a very specific part of the subaction event parsing loop
mtlr r12 #branching here with non-0 float in internal player data offset 0x3E4 will read a single event
returnFromEventRead:
blrl #a super tricky blrl
#a return from here has collapsed the above stack frame
decrementAA:
subi r28, r28, 1 #else, decrement AA by -1 and read a single event
b eventReadLoop
exitLoop:
subi r29, r29, 4 #the hook context will try and move this on return, so correct for it
lfs f0, -0x7728(rtoc)
stfs f0, 0x3E4(r31) #set event timer back to 0
stw r29, 0x3EC(r31) #set event pointer back to new data start
b return
#end of option5F
option5E: /*override animation interrupt logic
5E xx BBBB
BBBB - 11-bit ASID -- looks up animation interrupt associated with this ASID*/
lwz r27, 0xC(r30) #this is where we make use of that r30 calculation
stw r27, 0x21A0(r31) #apply target animation interrupt to 0x21A0 playerThinkAnimation blrl
b return
option5D: /*override IASA logic
5E xx BBBB
BBBB - 11-bit ASID -- looks up IASA associated with this ASID*/
lwz r27, 0x10(r30) #target IASA pointer
stw r27, 0x219C(r31) #apply to 0x219C playerThinkController blrl
b return
option5C: /*toggle off IASA flag
5C xx BBBB
BBBB - 11-bit flag; if not 0 then this extension turns off the IASA flag bit in the middle of an action state
r27 and r28 are freed up
-- the following is executed only if the function ID was 0 (5C) and the argument was not equal to 0
-- so 0 = IASA flag toggled on, !0 = IASA flag toggled off */
lbz r27, 0x2218(r31)
andi. r27, r27, 0x7F #bit 0x80 is the IASA flag, so mask it out
stb r27, 0x2218(r31) #store it, like the original instruction does
return: #from standalone function
lmw r3, 0x8(sp)
addi sp, sp, 0x80
lwz r0, 0x4(sp)
mtlr r0
blr
Last edited:
