From 0e3b13ee3e3b8de816431736b818dda44147d294 Mon Sep 17 00:00:00 2001 From: robojumper Date: Fri, 31 May 2024 02:50:17 +0200 Subject: [PATCH 1/5] State system + match d_t_rock_boat --- config/SOUE01/rels/d_t_rock_boatNP/splits.txt | 4 +- .../SOUE01/rels/d_t_rock_boatNP/symbols.txt | 86 ++++++------- .../SOUE01/rels/d_t_tumble_weedNP/splits.txt | 3 + .../SOUE01/rels/d_t_tumble_weedNP/symbols.txt | 108 ++++++++--------- config/SOUE01/splits.txt | 14 +++ config/SOUE01/symbols.txt | 86 ++++++------- configure.py | 5 +- include/c/c_math.h | 5 + include/d/a/obj/d_a_obj_base.h | 4 +- include/d/tg/d_t_rock_boat.h | 36 ++++++ include/d/tg/d_t_tumble_weed.h | 44 +++++++ include/f/f_list_nd.h | 1 + include/s/docgroup.h | 10 ++ include/s/s_FState.hpp | 41 +++++++ include/s/s_FStateFct.hpp | 26 ++++ include/s/s_FStateID.hpp | 58 +++++++++ include/s/s_FStateMgr.hpp | 17 +++ include/s/s_Phase.hpp | 34 ++++++ include/s/s_State.hpp | 14 +++ include/s/s_StateID.hpp | 43 +++++++ include/s/s_StateIDChk.hpp | 10 ++ include/s/s_StateInterfaces.hpp | 73 +++++++++++ include/s/s_StateMethod.hpp | 49 ++++++++ include/s/s_StateMethodUsr_FI.hpp | 16 +++ include/s/s_StateMgr.hpp | 37 ++++++ src/REL/d/t/d_t_rock_boat.cpp | 37 ++++++ src/REL/d/t/d_t_tumble_weed.cpp | 114 ++++++++++++++++++ src/s/s_Phase.cpp | 28 +++++ src/s/s_StateID.cpp | 53 ++++++++ src/s/s_StateMethod.cpp | 74 ++++++++++++ src/s/s_StateMethodUsr_FI.cpp | 27 +++++ 31 files changed, 1013 insertions(+), 144 deletions(-) create mode 100644 include/d/tg/d_t_rock_boat.h create mode 100644 include/d/tg/d_t_tumble_weed.h create mode 100644 include/s/docgroup.h create mode 100644 include/s/s_FState.hpp create mode 100644 include/s/s_FStateFct.hpp create mode 100644 include/s/s_FStateID.hpp create mode 100644 include/s/s_FStateMgr.hpp create mode 100644 include/s/s_Phase.hpp create mode 100644 include/s/s_State.hpp create mode 100644 include/s/s_StateID.hpp create mode 100644 include/s/s_StateIDChk.hpp create mode 100644 include/s/s_StateInterfaces.hpp create mode 100644 include/s/s_StateMethod.hpp create mode 100644 include/s/s_StateMethodUsr_FI.hpp create mode 100644 include/s/s_StateMgr.hpp create mode 100644 src/s/s_Phase.cpp create mode 100644 src/s/s_StateID.cpp create mode 100644 src/s/s_StateMethod.cpp create mode 100644 src/s/s_StateMethodUsr_FI.cpp diff --git a/config/SOUE01/rels/d_t_rock_boatNP/splits.txt b/config/SOUE01/rels/d_t_rock_boatNP/splits.txt index 86bb8f92..3fc7e803 100644 --- a/config/SOUE01/rels/d_t_rock_boatNP/splits.txt +++ b/config/SOUE01/rels/d_t_rock_boatNP/splits.txt @@ -2,7 +2,7 @@ Sections: .text type:code align:16 .ctors type:rodata align:4 .dtors type:rodata align:4 - .rodata type:rodata align:16 + .data type:data align:16 .bss type:bss align:8 REL/executor.c: @@ -16,3 +16,5 @@ REL/global_destructor_chain.c: REL/d/t/d_t_rock_boat.cpp: .text start:0x000000F0 end:0x00000A28 .ctors start:0x00000000 end:0x00000004 + .data start:0x00000000 end:0x00000200 + .bss start:0x00000008 end:0x00000048 diff --git a/config/SOUE01/rels/d_t_rock_boatNP/symbols.txt b/config/SOUE01/rels/d_t_rock_boatNP/symbols.txt index 85063c83..ea8907ed 100644 --- a/config/SOUE01/rels/d_t_rock_boatNP/symbols.txt +++ b/config/SOUE01/rels/d_t_rock_boatNP/symbols.txt @@ -3,50 +3,50 @@ _epilog = .text:0x00000030; // type:function size:0x2C scope:global _unresolved = .text:0x00000060; // type:function size:0x4 scope:global __register_global_object = .text:0x00000070; // type:function size:0x1C scope:global __destroy_global_chain = .text:0x00000090; // type:function size:0x54 scope:global -fn_487_F0 = .text:0x000000F0; // type:function size:0xAC -fn_487_1A0 = .text:0x000001A0; // type:function size:0x58 -fn_487_200 = .text:0x00000200; // type:function size:0x58 -fn_487_260 = .text:0x00000260; // type:function size:0x6C -fn_487_2D0 = .text:0x000002D0; // type:function size:0xA0 -fn_487_370 = .text:0x00000370; // type:function size:0xA4 -fn_487_420 = .text:0x00000420; // type:function size:0x50 -fn_487_470 = .text:0x00000470; // type:function size:0x10 -fn_487_480 = .text:0x00000480; // type:function size:0x8 -fn_487_490 = .text:0x00000490; // type:function size:0x30 -fn_487_4C0 = .text:0x000004C0; // type:function size:0x10 -fn_487_4D0 = .text:0x000004D0; // type:function size:0x8 -fn_487_4E0 = .text:0x000004E0; // type:function size:0x4 -fn_487_4F0 = .text:0x000004F0; // type:function size:0x90 -fn_487_580 = .text:0x00000580; // type:function size:0x4 -fn_487_590 = .text:0x00000590; // type:function size:0xC8 -fn_487_660 = .text:0x00000660; // type:function size:0x10 -fn_487_670 = .text:0x00000670; // type:function size:0x60 -fn_487_6D0 = .text:0x000006D0; // type:function size:0xC -fn_487_6E0 = .text:0x000006E0; // type:function size:0x1C -fn_487_700 = .text:0x00000700; // type:function size:0x1C -fn_487_720 = .text:0x00000720; // type:function size:0x1C -fn_487_740 = .text:0x00000740; // type:function size:0x10 -fn_487_750 = .text:0x00000750; // type:function size:0x10 -fn_487_760 = .text:0x00000760; // type:function size:0x10 -fn_487_770 = .text:0x00000770; // type:function size:0x10 -fn_487_780 = .text:0x00000780; // type:function size:0x10 -fn_487_790 = .text:0x00000790; // type:function size:0x10 -fn_487_7A0 = .text:0x000007A0; // type:function size:0x30 -fn_487_7D0 = .text:0x000007D0; // type:function size:0x30 -fn_487_800 = .text:0x00000800; // type:function size:0x30 -fn_487_830 = .text:0x00000830; // type:function size:0x10C -fn_487_940 = .text:0x00000940; // type:function size:0x58 -fn_487_9A0 = .text:0x000009A0; // type:function size:0x88 +dTgRockBoat_c_classInit__Fv = .text:0x000000F0; // type:function size:0xAC +__dt__8dTgAbs_cFv = .text:0x000001A0; // type:function size:0x58 +__dt__26sFState_c<13dTgRockBoat_c>Fv = .text:0x00000200; // type:function size:0x58 +__dt__29sFStateFct_c<13dTgRockBoat_c>Fv = .text:0x00000260; // type:function size:0x6C +__dt__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x000002D0; // type:function size:0xA0 +__dt__52sFStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c>Fv = .text:0x00000370; // type:function size:0xA4 +create__13dTgRockBoat_cFv = .text:0x00000420; // type:function size:0x50 +changeState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>FRC12sStateIDIf_c = .text:0x00000470; // type:function size:0x10 +doDelete__13dTgRockBoat_cFv = .text:0x00000480; // type:function size:0x8 +actorExecute__13dTgRockBoat_cFv = .text:0x00000490; // type:function size:0x30 +executeState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x000004C0; // type:function size:0x10 +draw__13dTgRockBoat_cFv = .text:0x000004D0; // type:function size:0x8 +initializeState_Wait__13dTgRockBoat_cFv = .text:0x000004E0; // type:function size:0x4 +executeState_Wait__13dTgRockBoat_cFv = .text:0x000004F0; // type:function size:0x90 +finalizeState_Wait__13dTgRockBoat_cFv = .text:0x00000580; // type:function size:0x4 +__dt__13dTgRockBoat_cFv = .text:0x00000590; // type:function size:0xC8 +getStateID__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000660; // type:function size:0x10 +build__29sFStateFct_c<13dTgRockBoat_c>FRC12sStateIDIf_c = .text:0x00000670; // type:function size:0x60 +dispose__29sFStateFct_c<13dTgRockBoat_c>FRP10sStateIf_c = .text:0x000006D0; // type:function size:0xC +initialize__26sFState_c<13dTgRockBoat_c>Fv = .text:0x000006E0; // type:function size:0x1C +execute__26sFState_c<13dTgRockBoat_c>Fv = .text:0x00000700; // type:function size:0x1C +finalize__26sFState_c<13dTgRockBoat_c>Fv = .text:0x00000720; // type:function size:0x1C +initializeState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000740; // type:function size:0x10 +finalizeState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000750; // type:function size:0x10 +refreshState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000760; // type:function size:0x10 +getState__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000770; // type:function size:0x10 +getNewStateID__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000780; // type:function size:0x10 +getOldStateID__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000790; // type:function size:0x10 +finalizeState__28sFStateID_c<13dTgRockBoat_c>CFR13dTgRockBoat_c = .text:0x000007A0; // type:function size:0x30 +executeState__28sFStateID_c<13dTgRockBoat_c>CFR13dTgRockBoat_c = .text:0x000007D0; // type:function size:0x30 +initializeState__28sFStateID_c<13dTgRockBoat_c>CFR13dTgRockBoat_c = .text:0x00000800; // type:function size:0x30 +__sinit_\d_t_rock_boat_cpp = .text:0x00000830; // type:function size:0x10C scope:local +__dt__28sFStateID_c<13dTgRockBoat_c>Fv = .text:0x00000940; // type:function size:0x58 +isSameName__28sFStateID_c<13dTgRockBoat_c>CFPCc = .text:0x000009A0; // type:function size:0x88 _ctors = .ctors:0x00000000; // type:label scope:global _dtors = .dtors:0x00000000; // type:label scope:global __destroy_global_chain_reference = .dtors:0x00000000; // type:object size:0x4 scope:global -lbl_487_section4_0 = .rodata:0x00000000; // type:object size:0x10 data:4byte -lbl_487_section4_10 = .rodata:0x00000010; // type:object size:0x78 -lbl_487_section4_88 = .rodata:0x00000088; // type:object size:0x30 -lbl_487_section4_B8 = .rodata:0x000000B8; // type:object size:0x30 -lbl_487_section4_E8 = .rodata:0x000000E8; // type:object size:0x18 -lbl_487_section4_100 = .rodata:0x00000100; // type:object size:0xCC -lbl_487_section4_1CC = .rodata:0x000001CC; // type:object size:0x34 +g_profile_TAG_ROCK_BOAT = .data:0x00000000; // type:object size:0x10 data:4byte +__vt__13dTgRockBoat_c = .data:0x00000010; // type:object size:0x74 +__vt__52sFStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c> = .data:0x00000088; // type:object size:0x30 +__vt__82sStateMgr_c<13dTgRockBoat_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c> = .data:0x000000B8; // type:object size:0x30 +__vt__29sFStateFct_c<13dTgRockBoat_c> = .data:0x000000E8; // type:object size:0x14 +__vt__26sFState_c<13dTgRockBoat_c> = .data:0x00000100; // type:object size:0x18 +__vt__28sFStateID_c<13dTgRockBoat_c> = .data:0x000001CC; // type:object size:0x34 __global_destructor_chain = .bss:0x00000000; // type:object size:0x4 scope:global -lbl_487_bss_8 = .bss:0x00000008; // type:object size:0x10 -lbl_487_bss_18 = .bss:0x00000018; // type:object size:0x30 data:4byte +lbl_487_bss_8 = .bss:0x00000008; // type:object size:0xC scope:local +StateID_Wait__13dTgRockBoat_c = .bss:0x00000018; // type:object size:0x30 data:4byte diff --git a/config/SOUE01/rels/d_t_tumble_weedNP/splits.txt b/config/SOUE01/rels/d_t_tumble_weedNP/splits.txt index 6637ccf5..978aeadb 100644 --- a/config/SOUE01/rels/d_t_tumble_weedNP/splits.txt +++ b/config/SOUE01/rels/d_t_tumble_weedNP/splits.txt @@ -17,3 +17,6 @@ REL/global_destructor_chain.c: REL/d/t/d_t_tumble_weed.cpp: .text start:0x000000F0 end:0x00001288 .ctors start:0x00000000 end:0x00000004 + .rodata start:0x00000000 end:0x00000064 + .data start:0x00000000 end:0x00000294 + .bss start:0x00000008 end:0x000000C8 diff --git a/config/SOUE01/rels/d_t_tumble_weedNP/symbols.txt b/config/SOUE01/rels/d_t_tumble_weedNP/symbols.txt index ddb33f7e..2b24ae56 100644 --- a/config/SOUE01/rels/d_t_tumble_weedNP/symbols.txt +++ b/config/SOUE01/rels/d_t_tumble_weedNP/symbols.txt @@ -3,66 +3,66 @@ _epilog = .text:0x00000030; // type:function size:0x2C scope:global _unresolved = .text:0x00000060; // type:function size:0x4 scope:global __register_global_object = .text:0x00000070; // type:function size:0x1C scope:global __destroy_global_chain = .text:0x00000090; // type:function size:0x54 scope:global -fn_476_F0 = .text:0x000000F0; // type:function size:0xC0 -fn_476_1B0 = .text:0x000001B0; // type:function size:0x58 -fn_476_210 = .text:0x00000210; // type:function size:0x58 -fn_476_270 = .text:0x00000270; // type:function size:0x6C -fn_476_2E0 = .text:0x000002E0; // type:function size:0xA0 -fn_476_380 = .text:0x00000380; // type:function size:0xA4 -fn_476_430 = .text:0x00000430; // type:function size:0x48 -fn_476_480 = .text:0x00000480; // type:function size:0x10 -fn_476_490 = .text:0x00000490; // type:function size:0x8 -fn_476_4A0 = .text:0x000004A0; // type:function size:0x48 -fn_476_4F0 = .text:0x000004F0; // type:function size:0x10 -fn_476_500 = .text:0x00000500; // type:function size:0x1C -fn_476_520 = .text:0x00000520; // type:function size:0x8 -fn_476_530 = .text:0x00000530; // type:function size:0x4 -fn_476_540 = .text:0x00000540; // type:function size:0xA0 -fn_476_5E0 = .text:0x000005E0; // type:function size:0x4 -fn_476_5F0 = .text:0x000005F0; // type:function size:0x4 -fn_476_600 = .text:0x00000600; // type:function size:0xC8 -fn_476_6D0 = .text:0x000006D0; // type:function size:0x4 -fn_476_6E0 = .text:0x000006E0; // type:function size:0x44 -fn_476_730 = .text:0x00000730; // type:function size:0x74 -fn_476_7B0 = .text:0x000007B0; // type:function size:0x4 -fn_476_7C0 = .text:0x000007C0; // type:function size:0x98 -fn_476_860 = .text:0x00000860; // type:function size:0x54 -fn_476_8C0 = .text:0x000008C0; // type:function size:0x288 -fn_476_B50 = .text:0x00000B50; // type:function size:0x114 -fn_476_C70 = .text:0x00000C70; // type:function size:0xD8 -fn_476_D50 = .text:0x00000D50; // type:function size:0x10 -fn_476_D60 = .text:0x00000D60; // type:function size:0x60 -fn_476_DC0 = .text:0x00000DC0; // type:function size:0xC -fn_476_DD0 = .text:0x00000DD0; // type:function size:0x1C -fn_476_DF0 = .text:0x00000DF0; // type:function size:0x1C -fn_476_E10 = .text:0x00000E10; // type:function size:0x1C -fn_476_E30 = .text:0x00000E30; // type:function size:0x10 -fn_476_E40 = .text:0x00000E40; // type:function size:0x10 -fn_476_E50 = .text:0x00000E50; // type:function size:0x10 -fn_476_E60 = .text:0x00000E60; // type:function size:0x10 -fn_476_E70 = .text:0x00000E70; // type:function size:0x10 -fn_476_E80 = .text:0x00000E80; // type:function size:0x10 -fn_476_E90 = .text:0x00000E90; // type:function size:0x30 -fn_476_EC0 = .text:0x00000EC0; // type:function size:0x30 -fn_476_EF0 = .text:0x00000EF0; // type:function size:0x30 -fn_476_F20 = .text:0x00000F20; // type:function size:0x27C -fn_476_11A0 = .text:0x000011A0; // type:function size:0x58 -fn_476_1200 = .text:0x00001200; // type:function size:0x88 +dTgTumbleWeed_c_classInit__Fv = .text:0x000000F0; // type:function size:0xC0 +__dt__8dTgAbs_cFv = .text:0x000001B0; // type:function size:0x58 +__dt__28sFState_c<15dTgTumbleWeed_c>Fv = .text:0x00000210; // type:function size:0x58 +__dt__31sFStateFct_c<15dTgTumbleWeed_c>Fv = .text:0x00000270; // type:function size:0x6C +__dt__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x000002E0; // type:function size:0xA0 +__dt__54sFStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c>Fv = .text:0x00000380; // type:function size:0xA4 +create__15dTgTumbleWeed_cFv = .text:0x00000430; // type:function size:0x48 +changeState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>FRC12sStateIDIf_c = .text:0x00000480; // type:function size:0x10 +doDelete__15dTgTumbleWeed_cFv = .text:0x00000490; // type:function size:0x8 +actorExecute__15dTgTumbleWeed_cFv = .text:0x000004A0; // type:function size:0x48 +executeState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x000004F0; // type:function size:0x10 +decr__FPUs = .text:0x00000500; // type:function size:0x1C +draw__15dTgTumbleWeed_cFv = .text:0x00000520; // type:function size:0x8 +initializeState_AreaOut__15dTgTumbleWeed_cFv = .text:0x00000530; // type:function size:0x4 +executeState_AreaOut__15dTgTumbleWeed_cFv = .text:0x00000540; // type:function size:0xA0 +finalizeState_AreaOut__15dTgTumbleWeed_cFv = .text:0x000005E0; // type:function size:0x4 +initializeState_AreaIn__15dTgTumbleWeed_cFv = .text:0x000005F0; // type:function size:0x4 +executeState_AreaIn__15dTgTumbleWeed_cFv = .text:0x00000600; // type:function size:0xC8 +finalizeState_AreaIn__15dTgTumbleWeed_cFv = .text:0x000006D0; // type:function size:0x4 +initializeState_Wind__15dTgTumbleWeed_cFv = .text:0x000006E0; // type:function size:0x44 +executeState_Wind__15dTgTumbleWeed_cFv = .text:0x00000730; // type:function size:0x74 +finalizeState_Wind__15dTgTumbleWeed_cFv = .text:0x000007B0; // type:function size:0x4 +shouldSpawnTumbleweed__15dTgTumbleWeed_cFv = .text:0x000007C0; // type:function size:0x98 +shouldDoWind__15dTgTumbleWeed_cFv = .text:0x00000860; // type:function size:0x54 +doSpawnTumbleweed__15dTgTumbleWeed_cFv = .text:0x000008C0; // type:function size:0x288 +getWind__15dTgTumbleWeed_cFP7mVec3_c = .text:0x00000B50; // type:function size:0x114 +__dt__15dTgTumbleWeed_cFv = .text:0x00000C70; // type:function size:0xD8 +getStateID__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000D50; // type:function size:0x10 +build__31sFStateFct_c<15dTgTumbleWeed_c>FRC12sStateIDIf_c = .text:0x00000D60; // type:function size:0x60 +dispose__31sFStateFct_c<15dTgTumbleWeed_c>FRP10sStateIf_c = .text:0x00000DC0; // type:function size:0xC +initialize__28sFState_c<15dTgTumbleWeed_c>Fv = .text:0x00000DD0; // type:function size:0x1C +execute__28sFState_c<15dTgTumbleWeed_c>Fv = .text:0x00000DF0; // type:function size:0x1C +finalize__28sFState_c<15dTgTumbleWeed_c>Fv = .text:0x00000E10; // type:function size:0x1C +initializeState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000E30; // type:function size:0x10 +finalizeState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000E40; // type:function size:0x10 +refreshState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>Fv = .text:0x00000E50; // type:function size:0x10 +getState__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000E60; // type:function size:0x10 +getNewStateID__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000E70; // type:function size:0x10 +getOldStateID__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c>CFv = .text:0x00000E80; // type:function size:0x10 +finalizeState__30sFStateID_c<15dTgTumbleWeed_c>CFR15dTgTumbleWeed_c = .text:0x00000E90; // type:function size:0x30 +executeState__30sFStateID_c<15dTgTumbleWeed_c>CFR15dTgTumbleWeed_c = .text:0x00000EC0; // type:function size:0x30 +initializeState__30sFStateID_c<15dTgTumbleWeed_c>CFR15dTgTumbleWeed_c = .text:0x00000EF0; // type:function size:0x30 +__sinit_\d_t_tumble_weed_cpp = .text:0x00000F20; // type:function size:0x27C +__dt__30sFStateID_c<15dTgTumbleWeed_c>Fv = .text:0x000011A0; // type:function size:0x58 +isSameName__30sFStateID_c<15dTgTumbleWeed_c>CFPCc = .text:0x00001200; // type:function size:0x88 _ctors = .ctors:0x00000000; // type:label scope:global _dtors = .dtors:0x00000000; // type:label scope:global __destroy_global_chain_reference = .dtors:0x00000000; // type:object size:0x4 scope:global lbl_476_rodata_0 = .rodata:0x00000000; // type:object size:0x1C data:float lbl_476_rodata_1C = .rodata:0x0000001C; // type:object size:0x4 data:float lbl_476_rodata_20 = .rodata:0x00000020; // type:object size:0x44 data:float -lbl_476_data_0 = .data:0x00000000; // type:object size:0x10 data:4byte -lbl_476_data_10 = .data:0x00000010; // type:object size:0x78 -lbl_476_data_88 = .data:0x00000088; // type:object size:0x30 -lbl_476_data_B8 = .data:0x000000B8; // type:object size:0x30 -lbl_476_data_E8 = .data:0x000000E8; // type:object size:0x18 -lbl_476_data_100 = .data:0x00000100; // type:object size:0x160 -lbl_476_data_260 = .data:0x00000260; // type:object size:0x34 +g_profile_TAG_TUMBLE_WEED = .data:0x00000000; // type:object size:0x10 data:4byte +__vt__15dTgTumbleWeed_c = .data:0x00000010; // type:object size:0x74 +__vt__54sFStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c> = .data:0x00000088; // type:object size:0x30 +__vt__84sStateMgr_c<15dTgTumbleWeed_c,20sStateMethodUsr_FI_c,12sFStateFct_c,13sStateIDChk_c> = .data:0x000000B8; // type:object size:0x30 +__vt__31sFStateFct_c<15dTgTumbleWeed_c> = .data:0x000000E8; // type:object size:0x14 +__vt__28sFState_c<15dTgTumbleWeed_c> = .data:0x00000100; // type:object size:0x18 +__vt__30sFStateID_c<15dTgTumbleWeed_c> = .data:0x00000260; // type:object size:0x34 __global_destructor_chain = .bss:0x00000000; // type:object size:0x4 scope:global lbl_476_bss_8 = .bss:0x00000008; // type:object size:0x10 data:4byte -lbl_476_bss_18 = .bss:0x00000018; // type:object size:0x40 data:4byte -lbl_476_bss_58 = .bss:0x00000058; // type:object size:0x40 data:4byte +StateID_AreaOut__15dTgTumbleWeed_c = .bss:0x00000018; // type:object size:0x30 data:4byte +lbl_476_bss_58 = .bss:0x00000058; // type:object size:0x30 data:4byte lbl_476_bss_98 = .bss:0x00000098; // type:object size:0x30 data:4byte diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt index 8428ae57..393ae007 100644 --- a/config/SOUE01/splits.txt +++ b/config/SOUE01/splits.txt @@ -198,6 +198,20 @@ toBeSorted/counters/extra_wallet_counter.cpp: .data start:0x805280B0 end:0x805280D0 .sbss start:0x80575640 end:0x80575648 +s/s_StateId.cpp: + .text start:0x802DDDB0 end:0x802DE1F4 + .ctors start:0x804DB8B8 end:0x804DB8BC + .data start:0x80541930 end:0x805419A8 + .sbss start:0x80575B68 end:0x80575B70 + .bss start:0x805B84B0 end:0x805B84C8 + +s/s_StateMethod.cpp: + .text start:0x802DE200 end:0x802DE534 + .data start:0x805419A8 end:0x805419E8 + +s/s_StateMethodUsr_FI.cpp: + .text start:0x802DE540 end:0x802DE6EC + DynamicLink.cpp: .text start:0x802DF100 end:0x802DFD74 .data start:0x805419E8 end:0x80541A70 diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt index 0570fe6b..2bcfdfc2 100644 --- a/config/SOUE01/symbols.txt +++ b/config/SOUE01/symbols.txt @@ -1118,7 +1118,7 @@ fn_8002E2A0 = .text:0x8002E2A0; // type:function size:0x90 fn_8002E330 = .text:0x8002E330; // type:function size:0x27C fn_8002E5B0 = .text:0x8002E5B0; // type:function size:0x8 fn_8002E5C0 = .text:0x8002E5C0; // type:function size:0x70 -fn_8002E630 = .text:0x8002E630; // type:function size:0x98 +create__12dAcObjBase_cFQ28fProfile14PROFILE_NAME_eScUlP7mVec3_cP7mAng3_cP7mVec3_cUl = .text:0x8002E630; // type:function size:0x98 fn_8002E6D0 = .text:0x8002E6D0; // type:function size:0xA0 fn_8002E770 = .text:0x8002E770; // type:function size:0x7C fn_8002E7F0 = .text:0x8002E7F0; // type:function size:0x58 @@ -1231,7 +1231,7 @@ fn_80032840 = .text:0x80032840; // type:function size:0x10 fn_80032850 = .text:0x80032850; // type:function size:0x64 fn_800328C0 = .text:0x800328C0; // type:function size:0x58 fn_80032920 = .text:0x80032920; // type:function size:0x10 -fn_80032930 = .text:0x80032930; // type:function size:0x8 +getStateID__14sStateMethod_cCFv = .text:0x80032930; // type:function size:0x8 fn_80032940 = .text:0x80032940; // type:function size:0x10 fn_80032950 = .text:0x80032950; // type:function size:0x8 fn_80032960 = .text:0x80032960; // type:function size:0x94 @@ -1620,10 +1620,10 @@ fn_8003EE80 = .text:0x8003EE80; // type:function size:0xC fn_8003EE90 = .text:0x8003EE90; // type:function size:0x1C fn_8003EEB0 = .text:0x8003EEB0; // type:function size:0x1C fn_8003EED0 = .text:0x8003EED0; // type:function size:0x1C -fn_8003EEF0 = .text:0x8003EEF0; // type:function size:0xC -fn_8003EF00 = .text:0x8003EF00; // type:function size:0x8 -fn_8003EF10 = .text:0x8003EF10; // type:function size:0x8 -fn_8003EF20 = .text:0x8003EF20; // type:function size:0x8 +refreshStateMethod__14sStateMethod_cFv = .text:0x8003EEF0; // type:function size:0xC +getState__14sStateMethod_cCFv = .text:0x8003EF00; // type:function size:0x8 +getNewStateID__14sStateMethod_cCFv = .text:0x8003EF10; // type:function size:0x8 +getOldStateID__14sStateMethod_cCFv = .text:0x8003EF20; // type:function size:0x8 fn_8003EF30 = .text:0x8003EF30; // type:function size:0x10 fn_8003EF40 = .text:0x8003EF40; // type:function size:0x10 fn_8003EF50 = .text:0x8003EF50; // type:function size:0x10 @@ -17168,36 +17168,36 @@ fn_802DDC20 = .text:0x802DDC20; // type:function size:0x40 fn_802DDC60 = .text:0x802DDC60; // type:function size:0x58 fn_802DDCC0 = .text:0x802DDCC0; // type:function size:0xA8 fn_802DDD70 = .text:0x802DDD70; // type:function size:0x40 -fn_802DDDB0 = .text:0x802DDDB0; // type:function size:0x34 -fn_802DDDF0 = .text:0x802DDDF0; // type:function size:0x58 -fn_802DDE50 = .text:0x802DDE50; // type:function size:0x10 -fn_802DDE60 = .text:0x802DDE60; // type:function size:0x68 -fn_802DDED0 = .text:0x802DDED0; // type:function size:0x10 -fn_802DDEE0 = .text:0x802DDEE0; // type:function size:0x34 -fn_802DDF20 = .text:0x802DDF20; // type:function size:0x8 -fn_802DDF30 = .text:0x802DDF30; // type:function size:0x8 -fn_802DDF40 = .text:0x802DDF40; // type:function size:0x8 -fn_802DDF50 = .text:0x802DDF50; // type:function size:0x40 -fn_802DDF90 = .text:0x802DDF90; // type:function size:0x40 -fn_802DDFD0 = .text:0x802DDFD0; // type:function size:0x58 -fn_802DE030 = .text:0x802DE030; // type:function size:0x40 -fn_802DE070 = .text:0x802DE070; // type:function size:0x40 -fn_802DE0B0 = .text:0x802DE0B0; // type:function size:0x40 -fn_802DE0F0 = .text:0x802DE0F0; // type:function size:0x58 -fn_802DE150 = .text:0x802DE150; // type:function size:0x40 -fn_802DE190 = .text:0x802DE190; // type:function size:0x8 -fn_802DE1A0 = .text:0x802DE1A0; // type:function size:0x54 -fn_802DE200 = .text:0x802DE200; // type:function size:0x48 -fn_802DE250 = .text:0x802DE250; // type:function size:0x58 -fn_802DE2B0 = .text:0x802DE2B0; // type:function size:0xA8 -fn_802DE360 = .text:0x802DE360; // type:function size:0xC4 -fn_802DE430 = .text:0x802DE430; // type:function size:0x8C -fn_802DE4C0 = .text:0x802DE4C0; // type:function size:0x74 -fn_802DE540 = .text:0x802DE540; // type:function size:0x3C -fn_802DE580 = .text:0x802DE580; // type:function size:0x68 -fn_802DE5F0 = .text:0x802DE5F0; // type:function size:0x4C -fn_802DE640 = .text:0x802DE640; // type:function size:0x54 -fn_802DE6A0 = .text:0x802DE6A0; // type:function size:0x4C +__ct__10sStateID_cFPCc = .text:0x802DDDB0; // type:function size:0x34 +__dt__10sStateID_cFv = .text:0x802DDDF0; // type:function size:0x58 +isNull__10sStateID_cCFv = .text:0x802DDE50; // type:function size:0x10 +isEqual__10sStateID_cCFRC12sStateIDIf_c = .text:0x802DDE60; // type:function size:0x68 +__eq__10sStateID_cCFRC12sStateIDIf_c = .text:0x802DDED0; // type:function size:0x10 +__ne__10sStateID_cCFRC12sStateIDIf_c = .text:0x802DDEE0; // type:function size:0x34 +isSameName__10sStateID_cCFPCc = .text:0x802DDF20; // type:function size:0x8 +name__10sStateID_cCFv = .text:0x802DDF30; // type:function size:0x8 +number__10sStateID_cCFv = .text:0x802DDF40; // type:function size:0x8 +__dt__13sStateFctIf_cFv = .text:0x802DDF50; // type:function size:0x40 +__dt__15sStateIDChkIf_cFv = .text:0x802DDF90; // type:function size:0x40 +__dt__13sStateIDChk_cFv = .text:0x802DDFD0; // type:function size:0x58 +__dt__12sStateIDIf_cFv = .text:0x802DE030; // type:function size:0x40 +__dt__10sStateIf_cFv = .text:0x802DE070; // type:function size:0x40 +__dt__16sStateMethodIf_cFv = .text:0x802DE0B0; // type:function size:0x40 +__dt__20sStateMethodUsr_FI_cFv = .text:0x802DE0F0; // type:function size:0x58 +__dt__13sStateMgrIf_cFv = .text:0x802DE150; // type:function size:0x40 +isNormalID__13sStateIDChk_cCFRC12sStateIDIf_c = .text:0x802DE190; // type:function size:0x8 +__sinit_\s_StateId_cpp = .text:0x802DE1A0; // type:function size:0x54 scope:local +__ct__14sStateMethod_cFR15sStateIDChkIf_cR13sStateFctIf_cRC12sStateIDIf_c = .text:0x802DE200; // type:function size:0x48 +__dt__14sStateMethod_cFv = .text:0x802DE250; // type:function size:0x58 +initializeStateMethod__14sStateMethod_cFv = .text:0x802DE2B0; // type:function size:0xA8 +executeStateMethod__14sStateMethod_cFv = .text:0x802DE360; // type:function size:0xC4 +finalizeStateMethod__14sStateMethod_cFv = .text:0x802DE430; // type:function size:0x8C +changeStateMethod__14sStateMethod_cFRC12sStateIDIf_c = .text:0x802DE4C0; // type:function size:0x74 +__ct__20sStateMethodUsr_FI_cFR15sStateIDChkIf_cR13sStateFctIf_cRC12sStateIDIf_c = .text:0x802DE540; // type:function size:0x3C +initializeStateLocalMethod__20sStateMethodUsr_FI_cFv = .text:0x802DE580; // type:function size:0x68 +executeStateLocalMethod__20sStateMethodUsr_FI_cFv = .text:0x802DE5F0; // type:function size:0x4C +finalizeStateLocalMethod__20sStateMethodUsr_FI_cFv = .text:0x802DE640; // type:function size:0x54 +changeStateLocalMethod__20sStateMethodUsr_FI_cFRC12sStateIDIf_c = .text:0x802DE6A0; // type:function size:0x4C fn_802DE6F0 = .text:0x802DE6F0; // type:function size:0x4 fn_802DE700 = .text:0x802DE700; // type:function size:0x8 fn_802DE710 = .text:0x802DE710; // type:function size:0x2C @@ -17288,7 +17288,7 @@ fn_802E0AB0 = .text:0x802E0AB0; // type:function size:0x34 fn_802E0AF0 = .text:0x802E0AF0; // type:function size:0x1BC fn_802E0CB0 = .text:0x802E0CB0; // type:function size:0x48 fn_802E0D00 = .text:0x802E0D00; // type:function size:0x8 -fn_802E0D10 = .text:0x802E0D10; // type:function size:0x8 +rnd__2cMFv = .text:0x802E0D10; // type:function size:0x8 fn_802E0D20 = .text:0x802E0D20; // type:function size:0x58 fn_802E0D80 = .text:0x802E0D80; // type:function size:0x38 fn_802E0DC0 = .text:0x802E0DC0; // type:function size:0x48 @@ -35658,10 +35658,10 @@ lbl_805417B8 = .data:0x805417B8; // type:object size:0x8C lbl_80541844 = .data:0x80541844; // type:object size:0x58 lbl_8054189C = .data:0x8054189C; // type:object size:0x4C lbl_805418E8 = .data:0x805418E8; // type:object size:0x48 -lbl_80541930 = .data:0x80541930; // type:object size:0x10 -lbl_80541940 = .data:0x80541940; // type:object size:0x40 -lbl_80541980 = .data:0x80541980; // type:object size:0x28 -lbl_805419A8 = .data:0x805419A8; // type:object size:0x40 +__vt__13sStateIDChk_c = .data:0x80541930; // type:object size:0x10 +__vt__20sStateMethodUsr_FI_c = .data:0x80541940; // type:object size:0x40 +__vt__10sStateID_c = .data:0x80541980; // type:object size:0x28 +__vt__14sStateMethod_c = .data:0x805419A8; // type:object size:0x40 lbl_805419E8 = .data:0x805419E8; // type:object size:0xC data:string lbl_805419F4 = .data:0x805419F4; // type:object size:0xC data:string lbl_80541A00 = .data:0x80541A00; // type:object size:0x10 @@ -40272,7 +40272,7 @@ lbl_80575B00 = .sbss:0x80575B00; // type:object size:0x20 data:4byte lbl_80575B20 = .sbss:0x80575B20; // type:object size:0x20 data:4byte lbl_80575B40 = .sbss:0x80575B40; // type:object size:0x20 data:4byte lbl_80575B60 = .sbss:0x80575B60; // type:object size:0x8 data:4byte -lbl_80575B68 = .sbss:0x80575B68; // type:object size:0x8 data:4byte +sm_numberMemo__10sStateID_c = .sbss:0x80575B68; // type:object size:0x8 data:4byte lbl_80575B70 = .sbss:0x80575B70; // type:object size:0x8 data:4byte lbl_80575B78 = .sbss:0x80575B78; // type:object size:0x4 data:4byte lbl_80575B7C = .sbss:0x80575B7C; // type:object size:0x4 data:4byte @@ -49102,7 +49102,7 @@ lbl_805B8378 = .bss:0x805B8378; // type:object size:0x28 data:4byte lbl_805B83A0 = .bss:0x805B83A0; // type:object size:0x100 lbl_805B84A0 = .bss:0x805B84A0; // type:object size:0x10 data:4byte lbl_805B84B0 = .bss:0x805B84B0; // type:object size:0xC -lbl_805B84BC = .bss:0x805B84BC; // type:object size:0xC +null__8sStateID = .bss:0x805B84BC; // type:object size:0xC m_tmpCtData__7fBase_c = .bss:0x805B84C8; // type:object size:0x10 data:4byte m_connectManage__10fManager_c = .bss:0x805B84D8; // type:object size:0x10 data:4byte m_createManage__10fManager_c = .bss:0x805B84E8; // type:object size:0x14 data:4byte diff --git a/configure.py b/configure.py index 7782d9dd..13218904 100644 --- a/configure.py +++ b/configure.py @@ -311,6 +311,9 @@ config.libs = [ Object(Matching, "m/m_heap.cpp"), Object(NonMatching, "m/m_mtx.cpp"), Object(Matching, "m/m_pad.cpp"), + Object(Matching, "s/s_StateId.cpp"), + Object(Matching, "s/s_StateMethod.cpp"), + Object(Matching, "s/s_StateMethodUsr_FI.cpp"), Object(Matching, "DynamicLink.cpp"), # framework (f_name) # d stuff (d_name) @@ -1051,7 +1054,7 @@ config.libs = [ Rel(NonMatching, "d_t_reaction", "REL/d/t/d_t_reaction.cpp"), Rel(NonMatching, "d_t_restart_time_stone", "REL/d/t/d_t_restart_time_stone.cpp"), Rel(NonMatching, "d_t_ride_rock_set", "REL/d/t/d_t_ride_rock_set.cpp"), - Rel(NonMatching, "d_t_rock_boat", "REL/d/t/d_t_rock_boat.cpp"), + Rel(Matching, "d_t_rock_boat", "REL/d/t/d_t_rock_boat.cpp"), Rel(NonMatching, "d_t_roll_attack_log", "REL/d/t/d_t_roll_attack_log.cpp"), Rel(NonMatching, "d_t_ro_at_target_manager", "REL/d/t/d_t_ro_at_target_manager.cpp"), Rel(NonMatching, "d_t_scene_change", "REL/d/t/d_t_scene_change.cpp"), diff --git a/include/c/c_math.h b/include/c/c_math.h index e192fa20..78e47876 100644 --- a/include/c/c_math.h +++ b/include/c/c_math.h @@ -5,6 +5,11 @@ namespace cM { static s16 atan2s(f32, f32); +void initRnd(s32); +f32 rnd(); +int rndInt(int max); +f32 rndF(f32 max); +f32 rndFX(f32 amp); } // namespace cM #endif diff --git a/include/d/a/obj/d_a_obj_base.h b/include/d/a/obj/d_a_obj_base.h index ed6d5abd..c46e92a9 100644 --- a/include/d/a/obj/d_a_obj_base.h +++ b/include/d/a/obj/d_a_obj_base.h @@ -49,9 +49,9 @@ public: /* 8002ea20 */ virtual bool drop(); public: - /* 8002e630 */ static dAcObjBase_c create(fProfile::PROFILE_NAME_e actorId, u32 roomId, u32 params1, mVec3_c *pos, + /* 8002e630 */ static void create(fProfile::PROFILE_NAME_e actorId, s8 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2); - /* 8002e6d0 */ static dAcObjBase_c create(char *name, u32 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, + /* 8002e6d0 */ static void create(char *name, u32 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2, u16 id, u8 viewclipId); /* 8002e770 */ static dAcObjBase_c *findObject(fProfile::PROFILE_NAME_e actorId, fLiNdBa_c *refList, dAcObjBase_c *parent); diff --git a/include/d/tg/d_t_rock_boat.h b/include/d/tg/d_t_rock_boat.h new file mode 100644 index 00000000..378593b4 --- /dev/null +++ b/include/d/tg/d_t_rock_boat.h @@ -0,0 +1,36 @@ +#ifndef D_T_ROCK_BOAT +#define D_T_ROCK_BOAT + +#include +#include +#include +#include + +class dTgAbs_c : public dAcBase_c { +public: + virtual ~dTgAbs_c() {} +}; + +class dTgRockBoat_c : public dTgAbs_c { +public: + dTgRockBoat_c() : mStateMgr(*this, sStateID::null) {} + virtual ~dTgRockBoat_c() {} + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + STATE_FUNC_DECLARE(dTgRockBoat_c, Wait); + +private: + + sFStateMgr_c mStateMgr; + int cooldown; + int boatNum; + + void dummy() { + mStateMgr.getStateID(); + } +}; + +#endif diff --git a/include/d/tg/d_t_tumble_weed.h b/include/d/tg/d_t_tumble_weed.h new file mode 100644 index 00000000..baf61848 --- /dev/null +++ b/include/d/tg/d_t_tumble_weed.h @@ -0,0 +1,44 @@ +#ifndef D_T_TUMBLE_WEED_H +#define D_T_TUMBLE_WEED_H + +#include +#include +#include +#include + +class fLiNdTumbleweed_c : public fLiNdBa_c { +public: + fLiNdTumbleweed_c(fBase_c *owner) : fLiNdBa_c(owner) {} + u16 someField; +}; + +class dTgTumbleWeed_c : public dTg_c { +public: + dTgTumbleWeed_c() : mStateMgr(*this, sStateID::null), childTumbleweed(nullptr) {} + virtual ~dTgTumbleWeed_c() {} + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + STATE_FUNC_DECLARE(dTgTumbleWeed_c, AreaOut); + STATE_FUNC_DECLARE(dTgTumbleWeed_c, AreaIn); + STATE_FUNC_DECLARE(dTgTumbleWeed_c, Wind); + +private: + bool shouldSpawnTumbleweed(); + bool shouldDoWind(); + void doSpawnTumbleweed(); + void getWind(mVec3_c *); + void unused() { + mStateMgr.getStateID(); + } + + sFStateMgr_c mStateMgr; + u16 tumbleweedTimer; + u16 padding; + u16 windTimer; + fLiNdTumbleweed_c childTumbleweed; +}; + +#endif diff --git a/include/f/f_list_nd.h b/include/f/f_list_nd.h index 6e5cc8eb..6adb8ea6 100644 --- a/include/f/f_list_nd.h +++ b/include/f/f_list_nd.h @@ -12,6 +12,7 @@ class fBase_c; class fLiNdBa_c : public cListNd_c { public: fLiNdBa_c(fBase_c *owner) : p_owner(owner) {} + ~fLiNdBa_c() { unlink(); } inline fLiNdBa_c *getPrev() const { return (fLiNdBa_c *)cListNd_c::getPrev(); diff --git a/include/s/docgroup.h b/include/s/docgroup.h new file mode 100644 index 00000000..a99aa2fb --- /dev/null +++ b/include/s/docgroup.h @@ -0,0 +1,10 @@ +#pragma once +// [This header file defines documentation groups for better categorization] + +/// @ingroup game +/// @defgroup slib sLib +/// @brief Provides various utilities (including the state system). + +/// @defgroup state sState +/// @ingroup slib +/// @brief A state system implementation. diff --git a/include/s/s_FState.hpp b/include/s/s_FState.hpp new file mode 100644 index 00000000..2772d3dd --- /dev/null +++ b/include/s/s_FState.hpp @@ -0,0 +1,41 @@ +#pragma once +#include +#include + +/// @brief A state holder for a given class. +/// @tparam T The class that this state belongs to. +/// @ingroup state +template +class sFState_c : public sStateIf_c { +public: + sFState_c(T &owner) : mpOwner(owner) { mpID = nullptr; } + + enum STATE_ACTION_e { + INITIALIZE, + EXECUTE, + FINALIZE + }; + + /// @brief Performs a state action. + /// @details [Gets inlined, needed for function order to match]. + /// @param action The action to perform. + void performAction(STATE_ACTION_e action) { + if (action == FINALIZE) { + mpID->finalizeState(mpOwner); + } else if (action == EXECUTE) { + mpID->executeState(mpOwner); + } else if (action == INITIALIZE) { + mpID->initializeState(mpOwner); + } + } + + virtual void initialize() { performAction(INITIALIZE); } + virtual void execute() { performAction(EXECUTE); } + virtual void finalize() { performAction(FINALIZE); } + + void setID(const sFStateID_c *id) { mpID = id; } + +private: + T &mpOwner; ///< The owner of this state. + const sFStateID_c *mpID; ///< The state ID that runs the state methods. +}; diff --git a/include/s/s_FStateFct.hpp b/include/s/s_FStateFct.hpp new file mode 100644 index 00000000..55c1d861 --- /dev/null +++ b/include/s/s_FStateFct.hpp @@ -0,0 +1,26 @@ +#pragma once +#include +#include +#include + +/// @brief A state factory for a given class. +/// @tparam T The class that this state belongs to. +/// @ingroup state +template +class sFStateFct_c : public sStateFctIf_c { +public: + sFStateFct_c(T &owner) : mState(owner) {} + + virtual sStateIf_c* build(const sStateIDIf_c &id) { + if (!id.isNull()) { + mState.setID((const sFStateID_c *) &id); + return &mState; + } + return nullptr; + } + + virtual void dispose(sStateIf_c *&id) { id = nullptr; } + +private: + sFState_c mState; +}; diff --git a/include/s/s_FStateID.hpp b/include/s/s_FStateID.hpp new file mode 100644 index 00000000..1100c54b --- /dev/null +++ b/include/s/s_FStateID.hpp @@ -0,0 +1,58 @@ +#pragma once +#include +#include + +/// @brief An implementation of a state ID for a given class. +/// @details It adds the ability to call the three state methods on a state owner class. +/// @tparam T The class that this state belongs to. +/// @ingroup state +template +class sFStateID_c : public sStateID_c { +public: + typedef void (T::*stateFunc)(); + + /** + * @brief Constructs a new sFStateID_c instance. + * + * @param name The name of this state ID. + * @param initialize The initialize method for this state ID. + * @param execute The execute method for this state ID. + * @param finalize The finalize method for this state ID. + */ + sFStateID_c(const char *name, stateFunc initialize, stateFunc execute, stateFunc finalize) : + sStateID_c(name), + mpInitialize(initialize), + mpExecute(execute), + mpFinalize(finalize) {} + + /// @brief Returns true if the given name matches this state ID's name. + virtual bool isSameName(const char *otherName) const { + char *part = strrchr(otherName, ':'); + if (part != nullptr) { + otherName = part + 1; + } + const char *thisName = strrchr(name(), ':') + 1; + if (strcmp(thisName, otherName) == 0) { + return true; + } else { + return false; + } + } + + /// @brief Calls the initialize method on the owner. + /// @param owner The owner of this state ID. + virtual void initializeState(T &owner) const { (owner.*mpInitialize)(); } + + /// @brief Calls the execute method on the owner. + /// @param owner The owner of this state ID. + virtual void executeState(T &owner) const { (owner.*mpExecute)(); } + + /// @brief Calls the finalize method on the owner. + /// @param owner The owner of this state ID. + virtual void finalizeState(T &owner) const { (owner.*mpFinalize)(); } + +private: + stateFunc mpInitialize; ///< The initialize method for this state ID. + stateFunc mpExecute; ///< The execute method for this state ID. + stateFunc mpFinalize; ///< The finalize method for this state ID. +}; diff --git a/include/s/s_FStateMgr.hpp b/include/s/s_FStateMgr.hpp new file mode 100644 index 00000000..be2858c4 --- /dev/null +++ b/include/s/s_FStateMgr.hpp @@ -0,0 +1,17 @@ +#pragma once +#include +#include +#include +#include +#include + +/// @brief A wrapper for sStateMgr_c that uses sFStateFct_c and sStateIDChk_c. +/// @tparam T The class that this state belongs to. +/// @tparam Method The method to use for the state manager. +/// @ingroup state +template +class sFStateMgr_c : public sStateMgr_c { +public: + sFStateMgr_c(T &owner, const sStateIDIf_c &initializeState) : + sStateMgr_c(owner, initializeState) {} +}; diff --git a/include/s/s_Phase.hpp b/include/s/s_Phase.hpp new file mode 100644 index 00000000..d21b2f80 --- /dev/null +++ b/include/s/s_Phase.hpp @@ -0,0 +1,34 @@ +#pragma once + +/// @brief A phase is a list of methods to be called in order. +/// @ingroup slib dol +class sPhase_c { +public: + /// @brief Return value of a phase method and ::callMethod. + /// @unofficial + enum METHOD_RESULT_e { + WAIT, ///< Do not proceed to the next method in the phase. + OK, ///< Proceed to the next method in the phase. + DONE ///< The phase is done. + }; + typedef METHOD_RESULT_e (phaseMethod)(void *); + + /** + * @brief Constructs a new phase with a given method list. + * + * @param methodList The list of methods in the phase. + * @param count The length of the method list. + */ + sPhase_c(phaseMethod **methodList, int count); + /** + * @brief Executes the phase until the end is reached or a method returns METHOD_RESULT_e::WAIT. + * + * @param thisPtr A pointer to the owner. + * @return METHOD_RESULT_e::WAIT if the phase is not done yet, and METHOD_RESULT_e::DONE if the phase is finished. + */ + METHOD_RESULT_e callMethod(void *thisPtr); + + phaseMethod **mpMethodList; ///< The method list. + unsigned short mPhaseLength; ///< The length of the method list. + unsigned short mCurrMethod; ///< The index of the method to execute. +}; diff --git a/include/s/s_State.hpp b/include/s/s_State.hpp new file mode 100644 index 00000000..1df9c01f --- /dev/null +++ b/include/s/s_State.hpp @@ -0,0 +1,14 @@ +#pragma once +#include +#include + +#define STATE_FUNC_DECLARE(class, name) void initializeState_##name(); \ + void executeState_##name(); \ + void finalizeState_##name(); \ + static sFStateID_c StateID_##name + +#define STATE_DEFINE(class, name) sFStateID_c class::StateID_##name( \ + #class "::StateID_" #name, \ + &class::initializeState_##name, \ + &class::executeState_##name, \ + &class::finalizeState_##name) diff --git a/include/s/s_StateID.hpp b/include/s/s_StateID.hpp new file mode 100644 index 00000000..cbfaab57 --- /dev/null +++ b/include/s/s_StateID.hpp @@ -0,0 +1,43 @@ +#pragma once +#include + +/// @brief A generic implementation of a state ID. +/// @details It simply contains a name string and a unique number. +/// @ingroup state +class sStateID_c : public sStateIDIf_c { +public: + class NumberMemo_c { + public: + NumberMemo_c() : curr(0) {} + unsigned int get() { + curr++; + return curr; + } + unsigned int curr; + }; + + sStateID_c(const char *name); + virtual ~sStateID_c(); + + virtual bool isNull() const; + virtual bool isEqual(const sStateIDIf_c &other) const; + + virtual bool operator==(const sStateIDIf_c &other) const; + virtual bool operator!=(const sStateIDIf_c &other) const; + + virtual bool isSameName(const char *name) const; + virtual const char *name() const; + virtual unsigned int number() const; + +protected: + const char *mpName; ///< The name of this state ID. + unsigned int mNumber; ///< The number of this state ID. + + static NumberMemo_c sm_numberMemo; ///< Used to give each state a unique number. +}; + +namespace sStateID { + + /// @ingroup state + extern sStateID_c null; ///< A null state instance. +} diff --git a/include/s/s_StateIDChk.hpp b/include/s/s_StateIDChk.hpp new file mode 100644 index 00000000..41d99213 --- /dev/null +++ b/include/s/s_StateIDChk.hpp @@ -0,0 +1,10 @@ +#pragma once +#include + +/// @brief A default implementation of a state ID checker. +/// @details ::isNormalID always returns true. +class sStateIDChk_c : public sStateIDChkIf_c { +public: + virtual ~sStateIDChk_c(); + virtual bool isNormalID(const sStateIDIf_c &) const { return true; } +}; diff --git a/include/s/s_StateInterfaces.hpp b/include/s/s_StateInterfaces.hpp new file mode 100644 index 00000000..cb624230 --- /dev/null +++ b/include/s/s_StateInterfaces.hpp @@ -0,0 +1,73 @@ +#pragma once + +/// @addtogroup state +/// @{ + +class sStateMethodIf_c { +public: + virtual ~sStateMethodIf_c(); +}; + +/// @brief The interface for state IDs. +/// @details A state ID is made up of a name string and a unique number, where 0 denotes a null state. +/// Null states do not have any corresponding behaviour. They can be used, for example, +/// if a state holder needs to be initialized but the initial state ID is not known yet. +class sStateIDIf_c { +public: + virtual ~sStateIDIf_c(); + + virtual bool isNull() const = 0; ///< Returns whether this is a null state. + virtual bool isEqual(const sStateIDIf_c &other) const = 0; ///< Returns whether both states have the same number. + + virtual bool operator==(const sStateIDIf_c &other) const = 0; ///< Overloaded equality operator, using ::isEqual. + virtual bool operator!=(const sStateIDIf_c &other) const = 0; ///< Overloaded inequality operator, using ::isEqual. + + virtual bool isSameName(const char *name) const = 0; ///< Returns whether this state ID is called @p name. + virtual const char *name() const = 0; ///< Returns the name of this state ID. + virtual unsigned int number() const = 0; ///< Returns the number of this state ID. +}; + +/// @brief The interface for a state holder. +/// @details A state holder is linked to a state ID and can execute its corresponding behaviour. +class sStateIf_c { +public: + virtual ~sStateIf_c(); + virtual const void initialize() = 0; ///< Initializes the state. + virtual const void execute() = 0; ///< Executes the state. + virtual const void finalize() = 0; ///< Prepares the state for termination. +}; + +/// @brief The interface for state factories. +/// @details A state factory produces a state holder from a given state ID. +class sStateFctIf_c { +public: + virtual ~sStateFctIf_c(); + virtual sStateIf_c *build(sStateIDIf_c const &id) = 0; ///< Returns a new state with a given state ID. + virtual void dispose(sStateIf_c *&id) = 0; ///< Clears out the pointer to a state. +}; + +/// @brief The interface for state ID checkers. +/// @details [This class is not really used, but it seems to be intended for testing if a state is "normal", most likely a debug leftover]. +class sStateIDChkIf_c { +public: + virtual ~sStateIDChkIf_c(); + virtual bool isNormalID(const sStateIDIf_c &id) const = 0; ///< Returns whether a state ID is normal. +}; + +/// @brief The interface for state managers. +/// @details A state manager handles execution of and transitioning between state IDs. +class sStateMgrIf_c { +public: + virtual ~sStateMgrIf_c(); + virtual void initializeState() = 0; ///< Initializes the current state. + virtual void executeState() = 0; ///< Executes the current state. + virtual void finalizeState() = 0; ///< Prepares the current state for termination. + virtual void changeState(const sStateIDIf_c &newStateID) = 0; ///< Transitions to a new state ID. + virtual void refreshState() = 0; ///< Marks the current state to be executed again. + virtual sStateIf_c *getState() const = 0; ///< Gets the state holder. + virtual const sStateIDIf_c *getNewStateID() const = 0; ///< Gets the next state ID. + virtual const sStateIDIf_c *getStateID() const = 0; ///< Gets the current state ID. + virtual const sStateIDIf_c *getOldStateID() const = 0; ///< Gets the previous state ID. +}; + +/// @} diff --git a/include/s/s_StateMethod.hpp b/include/s/s_StateMethod.hpp new file mode 100644 index 00000000..8dadaa9e --- /dev/null +++ b/include/s/s_StateMethod.hpp @@ -0,0 +1,49 @@ +#pragma once +#include + +/// @brief A class that handles state execution and transition. +/// @details [Presumably, sStateMethod_c actually means "methods for state interaction", or something like that]. +/// @ingroup state +class sStateMethod_c : public sStateMethodIf_c { +public: + /** + * @brief Constructs a new sStateMethod_c instance. + * + * @param checker The state checker to use. + * @param factory The state factory to use. + * @param initialState The initial state ID of this instance. + */ + sStateMethod_c(sStateIDChkIf_c &checker, sStateFctIf_c &factory, const sStateIDIf_c &initialState); + virtual ~sStateMethod_c(); ///< Destroys the sStateMethod_c instance. + + virtual void initializeStateMethod(); ///< @copydoc sStateMgrIf_c::initializeState + virtual void executeStateMethod(); ///< @copydoc sStateMgrIf_c::executeState + virtual void finalizeStateMethod(); ///< @copydoc sStateMgrIf_c::finalizeState + virtual void changeStateMethod(const sStateIDIf_c &newStateID); ///< @copydoc sStateMgrIf_c::changeState + virtual void refreshStateMethod() { mRefreshStateMethod = true; } ///< @copydoc sStateMgrIf_c::refreshState + virtual sStateIf_c *getState() const { return mpState; } ///< @copydoc sStateMgrIf_c::getState + virtual const sStateIDIf_c *getNewStateID() const { return mpNewStateID; } ///< @copydoc sStateMgrIf_c::getNewStateID + virtual const sStateIDIf_c *getStateID() const { return mpStateID; } ///< @copydoc sStateMgrIf_c::getStateID + virtual const sStateIDIf_c *getOldStateID() const { return mpOldStateID; } ///< @copydoc sStateMgrIf_c::getOldStateID + + virtual int initializeStateLocalMethod() = 0; ///< Performs the actual state initialization. + virtual void executeStateLocalMethod() = 0; ///< Performs the actual state execution. + virtual void finalizeStateLocalMethod() = 0; ///< Performs the actual state termination. + virtual void changeStateLocalMethod(const sStateIDIf_c &newStateID) = 0; ///< Performs the actual state transition. + +protected: + sStateIDChkIf_c &mpStateChk; ///< @unused The state checker to use. + sStateFctIf_c &mpStateFct; ///< The state factory which produces the state holder. + + bool mInitFinalizeLock; ///< A lock to ensure ::initializeStateMethod and ::finalizeStateMethod are not called recursively. + bool mExecutionLock; ///< A lock to ensure ::executeStateMethod is not called recursively. + bool mIsValid; ///< If the state holder contains a valid state ID. + bool mStateChanged; ///< If the current state has changed during execution. + bool mRefreshStateMethod; ///< True, if after a state transition, the state should be executed again. + + const sStateIDIf_c *mpNewStateID; ///< The next state ID. + const sStateIDIf_c *mpOldStateID; ///< The previous state ID. + const sStateIDIf_c *mpStateID; ///< The current state ID. + + sStateIf_c *mpState; ///< The current state holder. +}; diff --git a/include/s/s_StateMethodUsr_FI.hpp b/include/s/s_StateMethodUsr_FI.hpp new file mode 100644 index 00000000..0921f336 --- /dev/null +++ b/include/s/s_StateMethodUsr_FI.hpp @@ -0,0 +1,16 @@ +#pragma once +#include + +/// @brief An extension to sStateMethod_c that implements the remaining abstract methods. +/// @details [Name might mean "Functionality implementation"]. +/// @ingroup state +class sStateMethodUsr_FI_c : public sStateMethod_c { +public: + sStateMethodUsr_FI_c(sStateIDChkIf_c &checker, sStateFctIf_c &factory, const sStateIDIf_c &initialState); + virtual ~sStateMethodUsr_FI_c(); + + virtual int initializeStateLocalMethod(); + virtual void executeStateLocalMethod(); + virtual void finalizeStateLocalMethod(); + virtual void changeStateLocalMethod(const sStateIDIf_c &newStateID); +}; diff --git a/include/s/s_StateMgr.hpp b/include/s/s_StateMgr.hpp new file mode 100644 index 00000000..3fe4c74c --- /dev/null +++ b/include/s/s_StateMgr.hpp @@ -0,0 +1,37 @@ +#pragma once +#include + +/** + * @brief An implementation of sStateMgrIf_c. + * + * @tparam T The parent class for this state manager. + * @tparam Method The state method handler to use. + * @tparam Factory The state factory to use. + * @tparam Check The state ID checker to use. + * @ingroup state + */ +template class Factory, class Check> +class sStateMgr_c : sStateMgrIf_c { +public: + sStateMgr_c(T &owner, const sStateIDIf_c &initialState) : + mFactory(owner), + mMethod(mCheck, mFactory, initialState) {} + + virtual void initializeState() { mMethod.initializeStateMethod(); } + virtual void executeState() { mMethod.executeStateMethod(); } + virtual void finalizeState() { mMethod.finalizeStateMethod(); } + + virtual void changeState(const sStateIDIf_c &newState) { mMethod.changeStateMethod(newState); } + + virtual void refreshState() { mMethod.refreshStateMethod(); } + + virtual sStateIf_c *getState() const { return mMethod.getState(); } + virtual const sStateIDIf_c *getNewStateID() const { return mMethod.getNewStateID(); } + virtual const sStateIDIf_c *getStateID() const { return mMethod.getStateID(); } + virtual const sStateIDIf_c *getOldStateID() const { return mMethod.getOldStateID(); } + +private: + Check mCheck; + Factory mFactory; + Method mMethod; +}; diff --git a/src/REL/d/t/d_t_rock_boat.cpp b/src/REL/d/t/d_t_rock_boat.cpp index e69de29b..c22d2b7c 100644 --- a/src/REL/d/t/d_t_rock_boat.cpp +++ b/src/REL/d/t/d_t_rock_boat.cpp @@ -0,0 +1,37 @@ +#include +#include + +SPECIAL_ACTOR_PROFILE(TAG_ROCK_BOAT, dTgRockBoat_c, fProfile::TAG_ROCK_BOAT, 0x173, 0, 3); + +STATE_DEFINE(dTgRockBoat_c, Wait); + +int dTgRockBoat_c::create() { + mStateMgr.changeState(StateID_Wait); + cooldown = 1; + return 1; +} + +int dTgRockBoat_c::doDelete() { + return 1; +} + +int dTgRockBoat_c::actorExecute() { + mStateMgr.executeState(); + return 1; +} + +int dTgRockBoat_c::draw() { + return 1; +} + +void dTgRockBoat_c::initializeState_Wait() {} +void dTgRockBoat_c::executeState_Wait() { + if (cooldown > 0 && --cooldown == 0) { + dAcObjBase_c::create(fProfile::OBJ_ROCK_BOAT, roomid, (boatNum << 0x1c) | 0xff, &position, 0, 0, -1); + cooldown = 0x259; + if (++boatNum == 0xf) { + boatNum = 0; + } + } +} +void dTgRockBoat_c::finalizeState_Wait() {} diff --git a/src/REL/d/t/d_t_tumble_weed.cpp b/src/REL/d/t/d_t_tumble_weed.cpp index e69de29b..c98f6121 100644 --- a/src/REL/d/t/d_t_tumble_weed.cpp +++ b/src/REL/d/t/d_t_tumble_weed.cpp @@ -0,0 +1,114 @@ +#include +#include +#include + +SPECIAL_ACTOR_PROFILE(TAG_TUMBLE_WEED, dTgTumbleWeed_c, fProfile::TUMBLE_WEED_TAG, 0x0244, 0, 0); + +STATE_DEFINE(dTgTumbleWeed_c, AreaOut); +STATE_DEFINE(dTgTumbleWeed_c, AreaIn); +STATE_DEFINE(dTgTumbleWeed_c, Wind); + +int dTgTumbleWeed_c::create() { + tumbleweedTimer = 0; + windTimer = 0x96; + mStateMgr.changeState(StateID_AreaOut); + return 1; +} + +u16 decr(u16 *num); + +int dTgTumbleWeed_c::doDelete() { + return 1; +} + +int dTgTumbleWeed_c::actorExecute() { + mStateMgr.executeState(); + decr(&tumbleweedTimer); + return 1; +} + +u16 decr(u16 *num) { + if (*num != 0) { + (*num)--; + } + return *num; +} + +int dTgTumbleWeed_c::draw() { + return 1; +} + +void dTgTumbleWeed_c::initializeState_AreaOut() {} +void dTgTumbleWeed_c::executeState_AreaOut() { + if (decr(&windTimer) == 0) { + windTimer = 0x96; + if (shouldDoWind()) { + mStateMgr.changeState(StateID_Wind); + return; + } + } + if (isWithinPlayerRadius(scale.x)) { + mStateMgr.changeState(StateID_AreaIn); + } +} +void dTgTumbleWeed_c::finalizeState_AreaOut() {} + +void dTgTumbleWeed_c::initializeState_AreaIn() {} +void dTgTumbleWeed_c::executeState_AreaIn() { + if (tumbleweedTimer == 0) { + if (shouldSpawnTumbleweed()) { + doSpawnTumbleweed(); + } + tumbleweedTimer = 600; + } + if (decr(&windTimer) == 0) { + windTimer = 0x96; + if (shouldDoWind()) { + mStateMgr.changeState(StateID_Wind); + return; + } + } + if (!isWithinPlayerRadius(scale.x)) { + mStateMgr.changeState(StateID_AreaOut); + } +} +void dTgTumbleWeed_c::finalizeState_AreaIn() {} + +extern "C" void fn_475_1B00(fBase_c *, mVec3_c&); +void dTgTumbleWeed_c::initializeState_Wind() { + mVec3_c vec; + getWind(&vec); + if (childTumbleweed.p_owner != nullptr) { + fn_475_1B00(childTumbleweed.p_owner, vec); + } +} + +void dTgTumbleWeed_c::executeState_Wind() { + if (isWithinPlayerRadius(scale.x)) { + mStateMgr.changeState(StateID_AreaIn); + } else { + mStateMgr.changeState(StateID_AreaOut); + } +} +void dTgTumbleWeed_c::finalizeState_Wind() {} + +bool dTgTumbleWeed_c::shouldSpawnTumbleweed() { + bool spawnAllowed = false; + if (childTumbleweed.p_owner == nullptr && cM::rnd() <= 0.8f) { + spawnAllowed = true; + } + + if (spawnAllowed) { + return true; + } + + return false; +} + + +bool dTgTumbleWeed_c::shouldDoWind() { + return childTumbleweed.p_owner != nullptr && cM::rnd() <= 0.5f; +} +void dTgTumbleWeed_c::doSpawnTumbleweed() { +} +void dTgTumbleWeed_c::getWind(mVec3_c*) {} diff --git a/src/s/s_Phase.cpp b/src/s/s_Phase.cpp new file mode 100644 index 00000000..9418fbe9 --- /dev/null +++ b/src/s/s_Phase.cpp @@ -0,0 +1,28 @@ +#include + +sPhase_c::sPhase_c(phaseMethod **methodList, int count) { + mpMethodList = methodList; + mPhaseLength = count; + mCurrMethod = 0; +} + +sPhase_c::METHOD_RESULT_e sPhase_c::callMethod(void *thisPtr) { + if (mCurrMethod >= mPhaseLength) { + return DONE; + } + + METHOD_RESULT_e result = OK; + while (result == OK) { + result = (mpMethodList[mCurrMethod])(thisPtr); + + if (result == OK) { + // Go to the next method + mCurrMethod++; + if (mCurrMethod >= mPhaseLength) { + return DONE; + } + } + } + + return result; +} diff --git a/src/s/s_StateID.cpp b/src/s/s_StateID.cpp new file mode 100644 index 00000000..548a01e7 --- /dev/null +++ b/src/s/s_StateID.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include + +sStateID_c::NumberMemo_c sStateID_c::sm_numberMemo; +sStateID_c sStateID::null(nullptr); + +sStateID_c::sStateID_c(const char *name) { + mpName = name; + mNumber = (name != nullptr) ? sm_numberMemo.get() : 0; +} + +sStateID_c::~sStateID_c() {} + +bool sStateID_c::isNull() const { + return mNumber == 0; +} + +bool sStateID_c::isEqual(const sStateIDIf_c &other) const { + return number() == other.number(); +} + +bool sStateID_c::operator==(const sStateIDIf_c &other) const { + return isEqual(other); +} + +bool sStateID_c::operator!=(const sStateIDIf_c &other) const { + return !isEqual(other); +} + +bool sStateID_c::isSameName(const char *name) const { + // Just return false, the full implementation is in sFStateID_c + return false; +} + +const char *sStateID_c::name() const { + return mpName; +} + +unsigned int sStateID_c::number() const { + return mNumber; +} + +sStateFctIf_c::~sStateFctIf_c() {} +sStateIDChkIf_c::~sStateIDChkIf_c() {} +sStateIDChk_c::~sStateIDChk_c() {} +sStateIDIf_c::~sStateIDIf_c() {} +sStateIf_c::~sStateIf_c() {} +sStateMethodIf_c::~sStateMethodIf_c() {} +sStateMethodUsr_FI_c::~sStateMethodUsr_FI_c() {} +sStateMgrIf_c::~sStateMgrIf_c() {} diff --git a/src/s/s_StateMethod.cpp b/src/s/s_StateMethod.cpp new file mode 100644 index 00000000..fec04f78 --- /dev/null +++ b/src/s/s_StateMethod.cpp @@ -0,0 +1,74 @@ +#include +#include +#include +#include + +sStateMethod_c::sStateMethod_c(sStateIDChkIf_c &checker, sStateFctIf_c &factory, const sStateIDIf_c &initialState) : + mpStateChk(checker), + mpStateFct(factory), + mInitFinalizeLock(false), + mExecutionLock(false), + mIsValid(false), + mStateChanged(false), + mRefreshStateMethod(false), + mpNewStateID(&initialState), + mpOldStateID(&sStateID::null), + mpStateID(&initialState), + mpState(nullptr) { +} + +sStateMethod_c::~sStateMethod_c() {} + +void sStateMethod_c::initializeStateMethod() { + if (!mpNewStateID->isNull() && !mInitFinalizeLock && !mIsValid) { + mInitFinalizeLock = true; + + mpStateID = mpNewStateID; + int ret = initializeStateLocalMethod(); + if (ret != 0) { + mIsValid = true; + } else { + mIsValid = false; + } + + mInitFinalizeLock = false; + } +} + +void sStateMethod_c::executeStateMethod() { + if (!mExecutionLock) { + int i = 2; + do { + if (mRefreshStateMethod) { + i--; + } + mRefreshStateMethod = false; + // We only want to execute if we have a valid next state + if (!mpNewStateID->isNull()) { + mExecutionLock = true; + executeStateLocalMethod(); + mExecutionLock = false; + } + } while (mRefreshStateMethod && mStateChanged && i); + } +} + +void sStateMethod_c::finalizeStateMethod() { + if (!mpNewStateID->isNull() && mIsValid && !mInitFinalizeLock) { + mInitFinalizeLock = true; + + mpOldStateID = mpStateID; + finalizeStateLocalMethod(); + mIsValid = false; + + mInitFinalizeLock = false; + } +} + +void sStateMethod_c::changeStateMethod(const sStateIDIf_c &newID) { + if (!newID.isNull()) { + mpNewStateID = &newID; + changeStateLocalMethod(newID); + mStateChanged = true; + } +} diff --git a/src/s/s_StateMethodUsr_FI.cpp b/src/s/s_StateMethodUsr_FI.cpp new file mode 100644 index 00000000..cbcb5a54 --- /dev/null +++ b/src/s/s_StateMethodUsr_FI.cpp @@ -0,0 +1,27 @@ +#include +#include + +sStateMethodUsr_FI_c::sStateMethodUsr_FI_c(sStateIDChkIf_c &check, sStateFctIf_c &factory, const sStateIDIf_c &state) : + sStateMethod_c(check, factory, state) { +} + +int sStateMethodUsr_FI_c::initializeStateLocalMethod() { + mpState = mpStateFct.build(*getNewStateID()); // Create new state holder with the next state ID + mpState->initialize(); + return 1; +} + +void sStateMethodUsr_FI_c::executeStateLocalMethod() { + initializeStateMethod(); // Ensure we are in a valid state (this only actually initializes the state if !mIsValid) + mpState->execute(); +} + +void sStateMethodUsr_FI_c::finalizeStateLocalMethod() { + mpState->finalize(); + mpStateFct.dispose(mpState); +} + +void sStateMethodUsr_FI_c::changeStateLocalMethod(const sStateIDIf_c &newID) { + finalizeStateMethod(); // Terminate the current state + initializeStateMethod(); // Initialize the new state +} From 374e93821ed87c05e972f9c0c49424a8cb1cf061 Mon Sep 17 00:00:00 2001 From: robojumper Date: Fri, 31 May 2024 12:00:20 +0200 Subject: [PATCH 2/5] Document, fixup --- config/SOUE01/splits.txt | 3 +++ config/SOUE01/symbols.txt | 4 ++-- configure.py | 1 + include/d/tg/d_t_tumble_weed.h | 4 ++-- include/f/f_list_nd.h | 8 +++++++- include/f/f_manager.h | 1 + include/s/README.txt | 17 +++++++++++++++++ include/s/s_FState.hpp | 3 +++ include/s/s_FStateFct.hpp | 3 +++ include/s/s_FStateID.hpp | 3 +++ include/s/s_FStateMgr.hpp | 3 +++ include/s/s_Phase.hpp | 3 +++ include/s/s_State.hpp | 3 +++ include/s/s_StateID.hpp | 3 +++ include/s/s_StateIDChk.hpp | 3 +++ include/s/s_StateInterfaces.hpp | 3 +++ include/s/s_StateMethod.hpp | 3 +++ include/s/s_StateMethodUsr_FI.hpp | 3 +++ include/s/s_StateMgr.hpp | 3 +++ src/f/f_base.cpp | 5 ++--- src/s/s_Phase.cpp | 3 +++ src/s/s_StateID.cpp | 3 +++ src/s/s_StateMethod.cpp | 4 ++++ src/s/s_StateMethodUsr_FI.cpp | 3 +++ 24 files changed, 84 insertions(+), 8 deletions(-) create mode 100644 include/s/README.txt diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt index 393ae007..af8e679c 100644 --- a/config/SOUE01/splits.txt +++ b/config/SOUE01/splits.txt @@ -212,6 +212,9 @@ s/s_StateMethod.cpp: s/s_StateMethodUsr_FI.cpp: .text start:0x802DE540 end:0x802DE6EC +s/s_Phase.cpp: + .text start:0x802DEEB0 end:0x802DEF74 + DynamicLink.cpp: .text start:0x802DF100 end:0x802DFD74 .data start:0x805419E8 end:0x80541A70 diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt index 2bcfdfc2..0b0428d6 100644 --- a/config/SOUE01/symbols.txt +++ b/config/SOUE01/symbols.txt @@ -17221,8 +17221,8 @@ fn_802DED40 = .text:0x802DED40; // type:function size:0x4 fn_802DED50 = .text:0x802DED50; // type:function size:0x50 fn_802DEDA0 = .text:0x802DEDA0; // type:function size:0x64 fn_802DEE10 = .text:0x802DEE10; // type:function size:0x98 -fn_802DEEB0 = .text:0x802DEEB0; // type:function size:0x14 -fn_802DEED0 = .text:0x802DEED0; // type:function size:0xA4 +__ct__8sPhase_cFPPFPv_Q28sPhase_c15METHOD_RESULT_ei = .text:0x802DEEB0; // type:function size:0x14 +callMethod__8sPhase_cFPv = .text:0x802DEED0; // type:function size:0xA4 fn_802DEF80 = .text:0x802DEF80; // type:function size:0x8 fn_802DEF90 = .text:0x802DEF90; // type:function size:0x4C fn_802DEFE0 = .text:0x802DEFE0; // type:function size:0x80 diff --git a/configure.py b/configure.py index 13218904..4ee79aad 100644 --- a/configure.py +++ b/configure.py @@ -314,6 +314,7 @@ config.libs = [ Object(Matching, "s/s_StateId.cpp"), Object(Matching, "s/s_StateMethod.cpp"), Object(Matching, "s/s_StateMethodUsr_FI.cpp"), + Object(Matching, "s/s_Phase.cpp"), Object(Matching, "DynamicLink.cpp"), # framework (f_name) # d stuff (d_name) diff --git a/include/d/tg/d_t_tumble_weed.h b/include/d/tg/d_t_tumble_weed.h index baf61848..e3a80dd4 100644 --- a/include/d/tg/d_t_tumble_weed.h +++ b/include/d/tg/d_t_tumble_weed.h @@ -6,9 +6,9 @@ #include #include -class fLiNdTumbleweed_c : public fLiNdBa_c { +class fLiNdTumbleweed_c : public fLiNdBaAutoUnlink_c { public: - fLiNdTumbleweed_c(fBase_c *owner) : fLiNdBa_c(owner) {} + fLiNdTumbleweed_c(fBase_c *owner) : fLiNdBaAutoUnlink_c(owner) {} u16 someField; }; diff --git a/include/f/f_list_nd.h b/include/f/f_list_nd.h index 6adb8ea6..cc237048 100644 --- a/include/f/f_list_nd.h +++ b/include/f/f_list_nd.h @@ -12,7 +12,7 @@ class fBase_c; class fLiNdBa_c : public cListNd_c { public: fLiNdBa_c(fBase_c *owner) : p_owner(owner) {} - ~fLiNdBa_c() { unlink(); } + ~fLiNdBa_c() {} inline fLiNdBa_c *getPrev() const { return (fLiNdBa_c *)cListNd_c::getPrev(); @@ -28,4 +28,10 @@ public: fBase_c *p_owner; }; +class fLiNdBaAutoUnlink_c : public fLiNdBa_c { +public: + fLiNdBaAutoUnlink_c(fBase_c *owner) : fLiNdBa_c(owner) {} + ~fLiNdBaAutoUnlink_c() { unlink(); } +}; + #endif diff --git a/include/f/f_manager.h b/include/f/f_manager.h index d54f9acf..e2c18609 100644 --- a/include/f/f_manager.h +++ b/include/f/f_manager.h @@ -29,6 +29,7 @@ public: PROC_FLAG_DRAW = GET_PROC_FLAG(DRAW) }; fManager_c(fBase_c *owner) : connect_node(owner), execute_node(owner), draw_node(owner), search_node(owner) {} + ~fManager_c() {} /* 802e28c0 */ int getSearchTableNum(); /* 802e28d0 */ static fBase_c *searchBaseByID(fBaseID_e id); /* 802e2920 */ static fBase_c *searchBaseByProfName(ProfileName profID, const fBase_c *parent); diff --git a/include/s/README.txt b/include/s/README.txt new file mode 100644 index 00000000..99281a97 --- /dev/null +++ b/include/s/README.txt @@ -0,0 +1,17 @@ +This library was ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +with differences/modifications outlined below: + +## No inline destructors + +The NSMBW code uses inlined destructors. In SS, these destructors are all part of the s_StateID.cpp(?) TU, +and pretty much every generic instantiation of the state manager (which for a large part are in RELs) +will call back into those destructors in the main DOL. + +## s_StateIDChk.hpp + +In order for vtable ordering to match, some classes had to be extracted to a new header. + +## sStateMethodIf_c + +S_StateMethod_c's destructors calls back into another destructors. sStateMethodIf_c follows the example of +the other abstract interface classes and provides this dtor. diff --git a/include/s/s_FState.hpp b/include/s/s_FState.hpp index 2772d3dd..a883d6f3 100644 --- a/include/s/s_FState.hpp +++ b/include/s/s_FState.hpp @@ -2,6 +2,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A state holder for a given class. /// @tparam T The class that this state belongs to. /// @ingroup state diff --git a/include/s/s_FStateFct.hpp b/include/s/s_FStateFct.hpp index 55c1d861..3d349d3e 100644 --- a/include/s/s_FStateFct.hpp +++ b/include/s/s_FStateFct.hpp @@ -3,6 +3,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A state factory for a given class. /// @tparam T The class that this state belongs to. /// @ingroup state diff --git a/include/s/s_FStateID.hpp b/include/s/s_FStateID.hpp index 1100c54b..7ea2295a 100644 --- a/include/s/s_FStateID.hpp +++ b/include/s/s_FStateID.hpp @@ -2,6 +2,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief An implementation of a state ID for a given class. /// @details It adds the ability to call the three state methods on a state owner class. /// @tparam T The class that this state belongs to. diff --git a/include/s/s_FStateMgr.hpp b/include/s/s_FStateMgr.hpp index be2858c4..f154cbb6 100644 --- a/include/s/s_FStateMgr.hpp +++ b/include/s/s_FStateMgr.hpp @@ -5,6 +5,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A wrapper for sStateMgr_c that uses sFStateFct_c and sStateIDChk_c. /// @tparam T The class that this state belongs to. /// @tparam Method The method to use for the state manager. diff --git a/include/s/s_Phase.hpp b/include/s/s_Phase.hpp index d21b2f80..4b3d6403 100644 --- a/include/s/s_Phase.hpp +++ b/include/s/s_Phase.hpp @@ -1,5 +1,8 @@ #pragma once +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A phase is a list of methods to be called in order. /// @ingroup slib dol class sPhase_c { diff --git a/include/s/s_State.hpp b/include/s/s_State.hpp index 1df9c01f..8a7079f9 100644 --- a/include/s/s_State.hpp +++ b/include/s/s_State.hpp @@ -2,6 +2,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + #define STATE_FUNC_DECLARE(class, name) void initializeState_##name(); \ void executeState_##name(); \ void finalizeState_##name(); \ diff --git a/include/s/s_StateID.hpp b/include/s/s_StateID.hpp index cbfaab57..e74d155e 100644 --- a/include/s/s_StateID.hpp +++ b/include/s/s_StateID.hpp @@ -1,6 +1,9 @@ #pragma once #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A generic implementation of a state ID. /// @details It simply contains a name string and a unique number. /// @ingroup state diff --git a/include/s/s_StateIDChk.hpp b/include/s/s_StateIDChk.hpp index 41d99213..c808ad8b 100644 --- a/include/s/s_StateIDChk.hpp +++ b/include/s/s_StateIDChk.hpp @@ -1,6 +1,9 @@ #pragma once #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A default implementation of a state ID checker. /// @details ::isNormalID always returns true. class sStateIDChk_c : public sStateIDChkIf_c { diff --git a/include/s/s_StateInterfaces.hpp b/include/s/s_StateInterfaces.hpp index cb624230..0acd6f80 100644 --- a/include/s/s_StateInterfaces.hpp +++ b/include/s/s_StateInterfaces.hpp @@ -1,5 +1,8 @@ #pragma once +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @addtogroup state /// @{ diff --git a/include/s/s_StateMethod.hpp b/include/s/s_StateMethod.hpp index 8dadaa9e..4feb0c6a 100644 --- a/include/s/s_StateMethod.hpp +++ b/include/s/s_StateMethod.hpp @@ -1,6 +1,9 @@ #pragma once #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief A class that handles state execution and transition. /// @details [Presumably, sStateMethod_c actually means "methods for state interaction", or something like that]. /// @ingroup state diff --git a/include/s/s_StateMethodUsr_FI.hpp b/include/s/s_StateMethodUsr_FI.hpp index 0921f336..8104557f 100644 --- a/include/s/s_StateMethodUsr_FI.hpp +++ b/include/s/s_StateMethodUsr_FI.hpp @@ -1,6 +1,9 @@ #pragma once #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /// @brief An extension to sStateMethod_c that implements the remaining abstract methods. /// @details [Name might mean "Functionality implementation"]. /// @ingroup state diff --git a/include/s/s_StateMgr.hpp b/include/s/s_StateMgr.hpp index 3fe4c74c..66d07020 100644 --- a/include/s/s_StateMgr.hpp +++ b/include/s/s_StateMgr.hpp @@ -1,6 +1,9 @@ #pragma once #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + /** * @brief An implementation of sStateMgrIf_c. * diff --git a/src/f/f_base.cpp b/src/f/f_base.cpp index 661ec622..640f83e2 100644 --- a/src/f/f_base.cpp +++ b/src/f/f_base.cpp @@ -24,7 +24,6 @@ void (*fBase_c::sUnloadCallback)(); fBase_c::fBase_c() : unique_ID(m_rootUniqueID), params(m_tmpCtData.params), profile_name(m_tmpCtData.prof_name), group_type(m_tmpCtData.group_type), manager(this) { - fManager_c *mgr = &manager; m_rootUniqueID = (fBaseID_e)(m_rootUniqueID + 1); if (m_rootUniqueID == INVALID) { @@ -33,8 +32,8 @@ fBase_c::fBase_c() } } - fManager_c::m_connectManage.addTreeNode(&mgr->connect_node, m_tmpCtData.connect_parent); - int searchTableIdx = mgr->getSearchTableNum(); + fManager_c::m_connectManage.addTreeNode(&manager.connect_node, m_tmpCtData.connect_parent); + int searchTableIdx = manager.getSearchTableNum(); fManager_c::m_searchManage[searchTableIdx].prepend(&manager.search_node); const fProfile::fBaseProfile_c *profile = (*fProfile::sProfileList)[profile_name]; diff --git a/src/s/s_Phase.cpp b/src/s/s_Phase.cpp index 9418fbe9..734bb35e 100644 --- a/src/s/s_Phase.cpp +++ b/src/s/s_Phase.cpp @@ -1,5 +1,8 @@ #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + sPhase_c::sPhase_c(phaseMethod **methodList, int count) { mpMethodList = methodList; mPhaseLength = count; diff --git a/src/s/s_StateID.cpp b/src/s/s_StateID.cpp index 548a01e7..bf9100ec 100644 --- a/src/s/s_StateID.cpp +++ b/src/s/s_StateID.cpp @@ -4,6 +4,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + sStateID_c::NumberMemo_c sStateID_c::sm_numberMemo; sStateID_c sStateID::null(nullptr); diff --git a/src/s/s_StateMethod.cpp b/src/s/s_StateMethod.cpp index fec04f78..7c59854f 100644 --- a/src/s/s_StateMethod.cpp +++ b/src/s/s_StateMethod.cpp @@ -3,6 +3,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + sStateMethod_c::sStateMethod_c(sStateIDChkIf_c &checker, sStateFctIf_c &factory, const sStateIDIf_c &initialState) : mpStateChk(checker), mpStateFct(factory), @@ -37,6 +40,7 @@ void sStateMethod_c::initializeStateMethod() { void sStateMethod_c::executeStateMethod() { if (!mExecutionLock) { + // Skyward Sword change: Prevent runaway state changes? int i = 2; do { if (mRefreshStateMethod) { diff --git a/src/s/s_StateMethodUsr_FI.cpp b/src/s/s_StateMethodUsr_FI.cpp index cbcb5a54..9e42fc58 100644 --- a/src/s/s_StateMethodUsr_FI.cpp +++ b/src/s/s_StateMethodUsr_FI.cpp @@ -1,6 +1,9 @@ #include #include +// Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib +// See include/s/README.txt for changes made + sStateMethodUsr_FI_c::sStateMethodUsr_FI_c(sStateIDChkIf_c &check, sStateFctIf_c &factory, const sStateIDIf_c &state) : sStateMethod_c(check, factory, state) { } From 8ecaacda93da648ddc8413a77e60ca1fe32d87ee Mon Sep 17 00:00:00 2001 From: robojumper Date: Sat, 1 Jun 2024 23:57:11 +0200 Subject: [PATCH 3/5] Documentation, header guards --- include/s/README.txt | 3 ++- include/s/docgroup.h | 6 +++++- include/s/s_FState.hpp | 6 +++++- include/s/s_FStateFct.hpp | 6 +++++- include/s/s_FStateID.hpp | 6 +++++- include/s/s_FStateMgr.hpp | 6 +++++- include/s/s_Phase.hpp | 5 ++++- include/s/s_State.hpp | 6 +++++- include/s/s_StateID.hpp | 6 +++++- include/s/s_StateIDChk.hpp | 6 +++++- include/s/s_StateInterfaces.hpp | 5 ++++- include/s/s_StateMethod.hpp | 6 +++++- include/s/s_StateMethodUsr_FI.hpp | 6 +++++- include/s/s_StateMgr.hpp | 6 +++++- 14 files changed, 65 insertions(+), 14 deletions(-) diff --git a/include/s/README.txt b/include/s/README.txt index 99281a97..5be519ee 100644 --- a/include/s/README.txt +++ b/include/s/README.txt @@ -5,7 +5,8 @@ with differences/modifications outlined below: The NSMBW code uses inlined destructors. In SS, these destructors are all part of the s_StateID.cpp(?) TU, and pretty much every generic instantiation of the state manager (which for a large part are in RELs) -will call back into those destructors in the main DOL. +will call back into those destructors in the main DOL. As a result, the destructors were made not inline +and explicitly instantiated in s_StateID.cpp ## s_StateIDChk.hpp diff --git a/include/s/docgroup.h b/include/s/docgroup.h index a99aa2fb..43c81fd9 100644 --- a/include/s/docgroup.h +++ b/include/s/docgroup.h @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_DOCGROUP_H +#define S_DOCGROUP_H + // [This header file defines documentation groups for better categorization] /// @ingroup game @@ -8,3 +10,5 @@ /// @defgroup state sState /// @ingroup slib /// @brief A state system implementation. + +#endif diff --git a/include/s/s_FState.hpp b/include/s/s_FState.hpp index a883d6f3..5ce14991 100644 --- a/include/s/s_FState.hpp +++ b/include/s/s_FState.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_FSTATE_H +#define S_FSTATE_H + #include #include @@ -42,3 +44,5 @@ private: T &mpOwner; ///< The owner of this state. const sFStateID_c *mpID; ///< The state ID that runs the state methods. }; + +#endif diff --git a/include/s/s_FStateFct.hpp b/include/s/s_FStateFct.hpp index 3d349d3e..cb488d2d 100644 --- a/include/s/s_FStateFct.hpp +++ b/include/s/s_FStateFct.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_FSTATEFCT_H +#define S_FSTATEFCT_H + #include #include #include @@ -27,3 +29,5 @@ public: private: sFState_c mState; }; + +#endif diff --git a/include/s/s_FStateID.hpp b/include/s/s_FStateID.hpp index 7ea2295a..5fd05476 100644 --- a/include/s/s_FStateID.hpp +++ b/include/s/s_FStateID.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_FSTATEID_H +#define S_FSTATEID_H + #include #include @@ -59,3 +61,5 @@ private: stateFunc mpExecute; ///< The execute method for this state ID. stateFunc mpFinalize; ///< The finalize method for this state ID. }; + +#endif diff --git a/include/s/s_FStateMgr.hpp b/include/s/s_FStateMgr.hpp index f154cbb6..a001ffea 100644 --- a/include/s/s_FStateMgr.hpp +++ b/include/s/s_FStateMgr.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_FSTATEMGR_H +#define S_FSTATEMGR_H + #include #include #include @@ -18,3 +20,5 @@ public: sFStateMgr_c(T &owner, const sStateIDIf_c &initializeState) : sStateMgr_c(owner, initializeState) {} }; + +#endif diff --git a/include/s/s_Phase.hpp b/include/s/s_Phase.hpp index 4b3d6403..596484b6 100644 --- a/include/s/s_Phase.hpp +++ b/include/s/s_Phase.hpp @@ -1,4 +1,5 @@ -#pragma once +#ifndef S_PHASE_H +#define S_PHASE_H // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib // See include/s/README.txt for changes made @@ -35,3 +36,5 @@ public: unsigned short mPhaseLength; ///< The length of the method list. unsigned short mCurrMethod; ///< The index of the method to execute. }; + +#endif diff --git a/include/s/s_State.hpp b/include/s/s_State.hpp index 8a7079f9..97a5847e 100644 --- a/include/s/s_State.hpp +++ b/include/s/s_State.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATE_H +#define S_STATE_H + #include #include @@ -15,3 +17,5 @@ &class::initializeState_##name, \ &class::executeState_##name, \ &class::finalizeState_##name) + +#endif diff --git a/include/s/s_StateID.hpp b/include/s/s_StateID.hpp index e74d155e..422d9143 100644 --- a/include/s/s_StateID.hpp +++ b/include/s/s_StateID.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATEID_H +#define S_STATEID_H + #include // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib @@ -44,3 +46,5 @@ namespace sStateID { /// @ingroup state extern sStateID_c null; ///< A null state instance. } + +#endif diff --git a/include/s/s_StateIDChk.hpp b/include/s/s_StateIDChk.hpp index c808ad8b..5237cbaf 100644 --- a/include/s/s_StateIDChk.hpp +++ b/include/s/s_StateIDChk.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATEIDCHK_H +#define S_STATEIDCHK_H + #include // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib @@ -11,3 +13,5 @@ public: virtual ~sStateIDChk_c(); virtual bool isNormalID(const sStateIDIf_c &) const { return true; } }; + +#endif diff --git a/include/s/s_StateInterfaces.hpp b/include/s/s_StateInterfaces.hpp index 0acd6f80..8e28f44c 100644 --- a/include/s/s_StateInterfaces.hpp +++ b/include/s/s_StateInterfaces.hpp @@ -1,4 +1,5 @@ -#pragma once +#ifndef S_STATEINTERFACES_H +#define S_STATEINTERFACES_H // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib // See include/s/README.txt for changes made @@ -74,3 +75,5 @@ public: }; /// @} + +#endif diff --git a/include/s/s_StateMethod.hpp b/include/s/s_StateMethod.hpp index 4feb0c6a..4d7b630d 100644 --- a/include/s/s_StateMethod.hpp +++ b/include/s/s_StateMethod.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATEMETHOD_H +#define S_STATEMETHOD_H + #include // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib @@ -50,3 +52,5 @@ protected: sStateIf_c *mpState; ///< The current state holder. }; + +#endif diff --git a/include/s/s_StateMethodUsr_FI.hpp b/include/s/s_StateMethodUsr_FI.hpp index 8104557f..a18516df 100644 --- a/include/s/s_StateMethodUsr_FI.hpp +++ b/include/s/s_StateMethodUsr_FI.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATEMETHODUSR_FI_H +#define S_STATEMETHODUSR_FI_H + #include // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib @@ -17,3 +19,5 @@ public: virtual void finalizeStateLocalMethod(); virtual void changeStateLocalMethod(const sStateIDIf_c &newStateID); }; + +#endif diff --git a/include/s/s_StateMgr.hpp b/include/s/s_StateMgr.hpp index 66d07020..c043eb71 100644 --- a/include/s/s_StateMgr.hpp +++ b/include/s/s_StateMgr.hpp @@ -1,4 +1,6 @@ -#pragma once +#ifndef S_STATEMGR_H +#define S_STATEMGR_H + #include // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib @@ -38,3 +40,5 @@ private: Factory mFactory; Method mMethod; }; + +#endif From 5d9ca41e213c91629ebd6ffa9f748d81aac97489 Mon Sep 17 00:00:00 2001 From: robojumper Date: Sun, 2 Jun 2024 01:03:41 +0200 Subject: [PATCH 4/5] Fix return types --- include/d/a/obj/d_a_obj_base.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/d/a/obj/d_a_obj_base.h b/include/d/a/obj/d_a_obj_base.h index c46e92a9..77fbd8a1 100644 --- a/include/d/a/obj/d_a_obj_base.h +++ b/include/d/a/obj/d_a_obj_base.h @@ -49,9 +49,9 @@ public: /* 8002ea20 */ virtual bool drop(); public: - /* 8002e630 */ static void create(fProfile::PROFILE_NAME_e actorId, s8 roomId, u32 params1, mVec3_c *pos, + /* 8002e630 */ static dAcObjBase_c *create(fProfile::PROFILE_NAME_e actorId, s8 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2); - /* 8002e6d0 */ static void create(char *name, u32 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, + /* 8002e6d0 */ static dAcObjBase_c *create(char *name, u32 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2, u16 id, u8 viewclipId); /* 8002e770 */ static dAcObjBase_c *findObject(fProfile::PROFILE_NAME_e actorId, fLiNdBa_c *refList, dAcObjBase_c *parent); From 70dbbb1cb11cb9018b2823d7083c9db942ee7725 Mon Sep 17 00:00:00 2001 From: elijah-thomas774 Date: Sun, 9 Jun 2024 22:47:44 -0400 Subject: [PATCH 5/5] added macro for declaring state manager (used for annoying dummy funcs) --- include/d/tg/d_t_rock_boat.h | 7 +------ include/d/tg/d_t_tumble_weed.h | 5 +---- include/s/s_State.hpp | 16 ++++++++++------ 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/include/d/tg/d_t_rock_boat.h b/include/d/tg/d_t_rock_boat.h index 378593b4..28d0d669 100644 --- a/include/d/tg/d_t_rock_boat.h +++ b/include/d/tg/d_t_rock_boat.h @@ -23,14 +23,9 @@ public: STATE_FUNC_DECLARE(dTgRockBoat_c, Wait); private: - - sFStateMgr_c mStateMgr; + STATE_MGR_DECLARE(dTgRockBoat_c); int cooldown; int boatNum; - - void dummy() { - mStateMgr.getStateID(); - } }; #endif diff --git a/include/d/tg/d_t_tumble_weed.h b/include/d/tg/d_t_tumble_weed.h index e3a80dd4..5f8f9ecd 100644 --- a/include/d/tg/d_t_tumble_weed.h +++ b/include/d/tg/d_t_tumble_weed.h @@ -30,11 +30,8 @@ private: bool shouldDoWind(); void doSpawnTumbleweed(); void getWind(mVec3_c *); - void unused() { - mStateMgr.getStateID(); - } - sFStateMgr_c mStateMgr; + STATE_MGR_DECLARE(dTgTumbleWeed_c); u16 tumbleweedTimer; u16 padding; u16 windTimer; diff --git a/include/s/s_State.hpp b/include/s/s_State.hpp index 97a5847e..9ec6614a 100644 --- a/include/s/s_State.hpp +++ b/include/s/s_State.hpp @@ -7,15 +7,19 @@ // Note: Ported from https://github.com/NSMBW-Community/NSMBW-Decomp/tree/master/include/dol/sLib // See include/s/README.txt for changes made -#define STATE_FUNC_DECLARE(class, name) void initializeState_##name(); \ +#define STATE_FUNC_DECLARE(class, name) \ + void initializeState_##name(); \ void executeState_##name(); \ void finalizeState_##name(); \ static sFStateID_c StateID_##name -#define STATE_DEFINE(class, name) sFStateID_c class::StateID_##name( \ - #class "::StateID_" #name, \ - &class::initializeState_##name, \ - &class::executeState_##name, \ - &class::finalizeState_##name) +#define STATE_DEFINE(class, name) \ + sFStateID_c class ::StateID_##name(#class "::StateID_" #name, &class ::initializeState_##name, \ + &class ::executeState_##name, &class ::finalizeState_##name) +#define STATE_MGR_DECLARE(class_name) \ + sFStateMgr_c mStateMgr; \ + void dummy_GetStateID() { \ + mStateMgr.getStateID(); \ + } #endif