Some progress

README.md

@@ -1,6 +1,7 @@
 # mkdd
 WIP 1:1 Decompilation of Mario Kart Double Dash!!
 ## Building
+NOTE: Currently the debug version is hitting the character limit for PowerShell so for the time being, compile on Linux or use WSL!
 ### Requirements
 - [devkitPro](https://devkitpro.org/wiki/Getting_Started)
 - [Ninja](https://github.com/ninja-build/ninja/releases/tag/v1.11.1)

build.bat

@@ -1,3 +0,0 @@
-python ./configure.py
-ninja
-SymbolChecker

common.py

@@ -324,6 +324,7 @@ GCC_INCLUDES = ' '.join(f"-I {d}" for d in INCDIRS)
 #rework
 DEFINES = [
     "DEBUG",
+    "HIO_SCREENSHOT",
     "REGION_US",
     "MATCHING"
 ]

config/MarioClub_us/dol_slices.yml

@@ -966,6 +966,18 @@ src/Inagaki/GameAudioArcLoader.cpp:
     .data: [0x803942a8, 0x803942e8]
     .bss: [0x803c9750, 0x803c9778]
 
+src/Kameda/Task.cpp:
+    .text: [0x801323cc, 0x80132758]
+
+src/Kameda/WipeManager.cpp:
+    .text: [0x80138720, 0x8013b318]
+    .ctors: [0x803161e4, 0x803161e8]
+    .rodata: [0x8036d978, 0x8036da18]
+    .data: [0x80394598, 0x80394b70]
+    .bss: [0x803ca098, 0x803ca0c8]
+    .sbss: [0x804162c0, 0x804162d8]
+    .sdata2: [0x80418e20, 0x80418e48]
+
 src/Kameda/Scene.cpp:
     .text: [0x8013c1e8, 0x8013c2b8]
     .rodata: [0x8036da48, 0x8036da58]
@@ -1092,10 +1104,30 @@ src/Kaneshige/SimpleDrawer.cpp:
 src/Kaneshige/JugemPoint.cpp:
     .text: [0x801ba2a4, 0x801ba2b4]
 
+src/Kaneshige/RaceBGMPlayer.cpp:
+    .text: [0x801c6da0, 0x801c752c]
+    .ctors: [0x803162e4, 0x803162e8]
+    .bss: [0x803cad18, 0x803cad48]
+    .sdata: [0x804146f0, 0x804146f8]
+
+src/Kaneshige/BlurScreen.cpp:
+    .text: [0x801ccf74, 0x801cd50c]
+    .sdata2: [0x8041a458, 0x8041a468]
+
 src/Kaneshige/KartMtx.cpp:
     .text: [0x801cebdc, 0x801cec88]
     .sdata2: [0x8041a4b0, 0x8041a4b8]
 
+src/Kaneshige/GhostScreen.cpp:
+    .text: [0x801d2b40, 0x801d2ff8]
+
+src/Kaneshige/ShimmerScreen.cpp:
+    .text: [0x801d2ff8, 0x801d39e8]
+    .rodata: [0x80379898, 0x803798d0]
+    .sdata: [0x804147a0, 0x804147a8]
+    .sbss: [0x80416570, 0x80416580]
+    .sdata2: [0x8041a560, 0x8041a588]
+
 src/Kaneshige/Movie/MoviePlayer.cpp:
     .text: [0x801d8178, 0x801d85dc]
     .rodata: [0x80379b18, 0x80379b70]
@@ -1111,6 +1143,11 @@ src/Kaneshige/Movie/THPDraw.c:
 src/Kaneshige/RaceTime.cpp:
     .text: [0x801d9e4c, 0x801d9ea0]
 
+src/Kaneshige/MaskScreen.cpp:
+    .text: [0x801d9ea0, 0x801da760]
+    .rodata: [0x80379b70, 0x80379b90]
+    .sdata2: [0x8041a678, 0x8041a690]
+
 src/Kaneshige/THP/THPPlayer.c:
     .text: [0x801da760, 0x801dbf80]
     .ctors: [0x80316328, 0x8031632c]
@@ -1136,6 +1173,11 @@ src/Kaneshige/THP/THPAudioDecode.c:
     .bss: [0x803cea08, 0x803cfd90]
     .sbss: [0x80416878, 0x80416880]
 
+src/Kawano/SceneTitleLine.cpp:
+    .text: [0x801f5788, 0x801f5b40]
+    .rodata: [0x8037b370, 0x8037b3c0]
+    .sdata2: [0x8041a988, 0x8041a9b0]
+
 src/Osako/clock.cpp:
     .text: [0x801f6e04, 0x801f6e9c]
     .sbss: [0x804168c8, 0x804168d8]
@@ -1147,6 +1189,14 @@ src/Osako/testApp.cpp:
     .sbss: [0x804168d8, 0x804168e0]
     .sdata2: [0x8041aee0, 0x8041aef0]
 
+src/Osako/shadowModel.cpp:
+    .text: [0x801f7154, 0x801f74dc]
+    .ctors: [0x80316360, 0x80316364]
+    .rodata: [0x8037cc40, 0x8037cc50]
+    .data: [0x8039c418, 0x8039c460]
+    .bss: [0x803cffe0, 0x803d0010]
+    .sdata2: [0x8041aef0, 0x8041af18]
+
 src/Osako/GameApp.cpp:
     .text: [0x801f74dc, 0x801f75f4]
     .data: [0x8039c460, 0x8039c478]
@@ -1154,6 +1204,15 @@ src/Osako/GameApp.cpp:
 src/Osako/main.cpp:
     .text: [0x801f75f4, 0x801f7618]
 
+src/Osako/RaceApp.cpp:
+    .text: [0x801fae68, 0x801fc5dc]
+    .ctors: [0x80316370, 0x80316374]
+    .rodata: [0x8037cff8, 0x8037d0e8]
+    .data: [0x8039c710, 0x8039c778]
+    .bss: [0x803d0860, 0x803d0890]
+    .sbss: [0x80416918, 0x80416920]
+    .sdata2: [0x8041b358, 0x8041b370]
+
 src/Osako/ResMgr.cpp:
     .text: [0x801fc5dc, 0x801fe074]
     .ctors: [0x80316374, 0x80316378]
@@ -1257,6 +1316,13 @@ src/Osako/SequenceApp.cpp:
     .sbss: [0x80416a18, 0x80416a20]
     .sdata2: [0x8041b7a0, 0x8041b7b0] 
 
+src/Osako/TestViewApp.cpp:
+    .text: [0x80209c9c, 0x8020a324]
+    .rodata: [0x8037dc18, 0x8037dfb0]
+    .data: [0x8039cea0, 0x8039cfd8]
+    .sbss: [0x80416a28, 0x80416a30]
+    .sdata2: [0x8041b7c0, 0x8041b808]
+
 src/Osako/shadowScr.cpp:
     .text: [0x8020af10, 0x8020b458]
     .sdata2: [0x8041b818, 0x8041b820]
@@ -1299,6 +1365,11 @@ src/Osako/PadRecorder.cpp:
     .rodata: [0x8037e0c8, 0x8037e0f8]
     .sdata2: [0x8041b868, 0x8041b870]
 
+src/Osako/ForceEffectMgr.cpp:
+    .text: [0x8020d390, 0x8020d550]
+    .data: [0x8039d198, 0x8039d1a8]
+    .sbss: [0x80416a58, 0x80416a60]
+
 src/Osako/AwardApp.cpp:
     .text: [0x8020e15c, 0x8020e3ac]
     .ctors: [0x803163b0, 0x803163b4]
@@ -1364,6 +1435,79 @@ src/Sato/stMath.cpp:
     .sbss: [0x80416ac8, 0x80416ad0]
     .sdata2: [0x8041bb60, 0x8041bbb8]
 
+src/Shiraiwa/WipeSlide.cpp:
+    .text: [0x802b7d5c, 0x802b8760]
+    .ctors: [0x80316544, 0x80316548]
+    .data: [0x803a7a78, 0x803a7aa8]
+    .bss: [0x803ee838, 0x803ee868]
+    .sdata: [0x80415320, 0x80415328]
+    .sdata2: [0x8041ce80, 0x8041cea0]
+    .sbss2: [0x8041e240, 0x8041e248]
+
+src/Shiraiwa/WipeBase.cpp:
+    .text: [0x802b8760, 0x802b91e0]
+    .ctors: [0x80316548, 0x8031654c]
+    .rodata: [0x80384498, 0x80384528]
+    .data: [0x803a7aa8, 0x803a7af0]
+    .bss: [0x803ee868, 0x803ee898]
+    .sdata2: [0x8041cea0, 0x8041cec0]
+
+src/Shiraiwa/WipeCircle.cpp:
+    .text: [0x802b91e0, 0x802b9a40]
+    .ctors: [0x8031654c, 0x80316550]
+    .rodata: [0x80384528, 0x80384558]
+    .data: [0x803a7af0, 0x803a7b20]
+    .bss: [0x803ee898, 0x803ee8c8]
+    .sdata: [0x80415328, 0x80415330]
+    .sbss: [0x80416ff0, 0x80416ff8]
+    .sdata2: [0x8041cec0, 0x8041cee8]
+    .sbss2: [0x8041e248, 0x8041e250]
+
+src/Shiraiwa/WipeCheck.cpp:
+    .text: [0x802d28a4, 0x802d2e9c]
+    .ctors: [0x803165ac, 0x803165b0]
+    .data: [0x803aa9a8, 0x803aa9d8]
+    .bss: [0x803eed88, 0x803eedb8]
+    .sdata: [0x80415500, 0x80415508]
+    .sdata2: [0x8041d470, 0x8041d488]
+
+src/Shiraiwa/WipeShut.cpp:
+    .text: [0x802d2e9c, 0x802d37f4]
+    .ctors: [0x803165b0, 0x803165b4]
+    .data: [0x803aa9d8, 0x803aaa08]
+    .bss: [0x803eedb8, 0x803eede8]
+    .sdata: [0x80415508, 0x80415518]
+    .sbss: [0x80417150, 0x80417158]
+    .sdata2: [0x8041d488, 0x8041d4b0] 
+
+src/Shiraiwa/WipeLine.cpp:
+    .text: [0x802d37f4, 0x802d4100]
+    .ctors: [0x803165b4, 0x803165b8]
+    .data: [0x803aaa08, 0x803aaa68]
+    .bss: [0x803eede8, 0x803eee18]
+    .sdata: [0x80415518, 0x80415528]
+    .sbss: [0x80417158, 0x80417160]
+    .sdata2: [0x8041d4b0, 0x8041d4d0]
+
+src/Shiraiwa/WipeWave.cpp:
+    .text: [0x802d4100, 0x802d48e8]
+    .ctors: [0x803165b8, 0x803165bc]
+    .data: [0x803aaa68, 0x803aaaa0]
+    .bss: [0x803eee18, 0x803eee48]
+    .sdata: [0x80415528, 0x80415538]
+    .sbss: [0x80417160, 0x80417168]
+    .sdata2: [0x8041d4d0, 0x8041d4e8]
+
+src/Shiraiwa/WipeCurtain.cpp:
+    .text: [0x802d81bc, 0x802d8b44]
+    .ctors: [0x803165c8, 0x803165cc]
+    .data: [0x803ab0c8, 0x803ab0f8]
+    .bss: [0x803eeed8, 0x803eef08]
+    .sdata: [0x80415568, 0x80415570]
+    .sbss: [0x80417188, 0x80417190]
+    .sdata2: [0x8041d5a0, 0x8041d5c0]
+    .sbss2: [0x8041e250, 0x8041e254]
+
 src/Sato/stEfctWeed.cpp:
     .text: [0x80254ba8, 0x80254ec4]
     .ctors: [0x80316418, 0x8031641c] 
@@ -1373,6 +1517,28 @@ src/Sato/stEfctWeed.cpp:
     .sbss: [0x80416bc8, 0x80416bd0]
     .sdata2: [0x8041bf90, 0x8041bf98]
 
+src/Sato/RivalKart.cpp:
+    .text: [0x80270f9c, 0x802714b0]
+    .ctors: [0x80316458, 0x8031645c]
+    .data: [0x803a1ca0, 0x803a1cb8]
+    .bss: [0x803edc40, 0x803edc70]
+
+src/Yamamoto/kartCamera.cpp:
+    .text: [0x802e0248, 0x802e17b8]
+    .ctors: [0x803165d8, 0x803165dc]
+    .rodata: [0x803867d0, 0x80386870]
+    .data: [0x803ab3d0, 0x803ab6e0]
+    .bss: [0x803eef90, 0x803eefc0]
+    .sdata2: [0x8041d740, 0x8041d760]
+
+src/Yamamoto/kartCtrl.cpp:
+    .text: [0x802e17b8, 0x802e39e4]
+    .ctors: [0x803165dc, 0x803165e0]
+    .rodata: [0x80386870, 0x80386908]
+    .bss: [0x803eefc0, 0x803eeff0]
+    .sbss: [0x804171a0, 0x804171c0]
+    .sdata2: [0x8041d760, 0x8041d780]
+
 src/Yamamoto/kartvec.cpp:
     .text: [0x802e5210, 0x802e64e8]
     .ctors: [0x803165e4, 0x803165e8]
@@ -1385,6 +1551,19 @@ src/Yamamoto/kartLine.cpp:
     .bss: [0x803ef0e0, 0x803ef110]
     .sdata2: [0x8041db50, 0x8041db58]
 
+src/Yamamoto/KartSound.cpp:
+    .text: [0x802fec88, 0x80300308]
+    .ctors: [0x80316608, 0x8031660c]
+    .rodata: [0x80386b18, 0x80386b70]
+    .bss: [0x803ef1d0, 0x803ef200]
+    .sdata2: [0x8041dda0, 0x8041ddc0]
+
+src/Yamamoto/KartTaeget.cpp:
+    .text: [0x80300308, 0x80300878]
+    .ctors: [0x8031660c, 0x80316610]
+    .bss: [0x803ef200, 0x803ef230]
+    .sdata2: [0x8041ddc0, 0x8041ddc8]
+
 src/Yamamoto/KartStar.cpp:
     .text: [0x80307c44, 0x80307eb8]
     .ctors: [0x80316628, 0x8031662c]
@@ -1395,15 +1574,42 @@ src/Yamamoto/KartTire.cpp:
     .ctors: [0x8031662c, 0x80316630]
     .bss: [0x803ef380, 0x803ef3b0]
 
+# This file causes ninja to go over the 16bit character limit for the linking command
+#src/Yamamoto/KartDisp.cpp:
+    #.text: [0x803101d8, 0x80311ae8]
+    #.ctors: [0x80316640, 0x80316644]
+    #.rodata: [0x80386e58, 0x803879c0]
+    #.bss: [0x803ef470, 0x803ef4a0]
+    #.sdata2: [0x8041e0f0, 0x8041e160]
+
+src/Yamamoto/KartHandle.cpp:
+    .text: [0x80311ae8, 0x80312154]
+    .ctors: [0x80316644, 0x80316648]
+    .data: [0x803ae2e8, 0x803ae348]
+    .bss: [0x803ef4a0, 0x803ef4d0]
+    .sdata2: [0x8041e160, 0x8041e168]
+
 src/Yamamoto/KartApeendix.cpp: 
     .text: [0x80312154, 0x8031228c]
     .ctors: [0x80316648, 0x8031664c]
     .bss: [0x803ef4d0, 0x803ef500]
 
-# BUG: mwld aligns .ctors by 8 under certain conditions, ppcdis should take care of this normally but it doesn't use the trimmed length
+src/Yamamoto/KartPipe.cpp:
-# use an empty .s as workaround to get the correct en offset
+    .text: [0x8031228c, 0x80312ca8]
-src/ctorhack.s: 
+    .ctors: [0x8031664c, 0x80316650]
-    .ctors: [0x8031665c, 0x80316660]
+    .bss: [0x803ef500, 0x803ef530]
+
+src/Yamamoto/KartAnt.cpp:
+    .text: [0x80312ca8, 0x80313348]
+    .ctors: [0x80316650, 0x80316654]
+    .bss: [0x803ef530, 0x803ef560]
+    .sdata2: [0x8041e180, 0x8041e190]
+
+src/Yamamoto/KartPerCam.cpp:
+    .text: [0x80315160, 0x803160a0]
+    .ctors: [0x80316658, 0x80316660]
+    .bss: [0x803ef590, 0x803ef5c0]
+    .sdata2: [0x8041e1a0, 0x8041e1e0]
 
 # not required yet, but for __start it generates some data in the .init section which can't be added to the start section itself 
 #src/starthack.s:

config/MarioClub_us/symbols.yml

@@ -18226,6 +18226,8 @@ global:
     0x80416d24: sCommonFlgs__13RivalBodyCtrl
     0x80416d28: sCheckTopDistRatio__13RivalBodyCtrl
     0x80416d30: sStartRankPtr__14RivalSpeedCtrl
+    0x80416d34: sConfusedFightModeFlg__14RivalSpeedCtrl
+    0x80416d35: sComWeakPointSwapFlg__14RivalSpeedCtrl
     0x80416d38: sTexSRTKey__14J3DEfctIceRock
     0x80416d40: JPTraceHPCB
     0x80416d48: sDossunBckAnmTrans__13TMapObjDossun

config/Release_eu/dol_slices.yml

@@ -937,6 +937,18 @@ src/Inagaki/GameAudioArcLoader.cpp:
     .data: [0x803540d8, 0x80354118]
     .bss: [0x80389290, 0x803892b8]
 
+src/Kameda/Task.cpp:
+    .text: [0x80124a58, 0x80124de4]
+
+src/Kameda/WipeManager.cpp:
+    .text: [0x80129f18, 0x8012c188]
+    .ctors: [0x802d85e8, 0x802d85ec]
+    .rodata: [0x80335188, 0x80335198]
+    .data: [0x803543c8, 0x803549a0]
+    .bss: [0x80389bd8, 0x80389c08]
+    .sbss: [0x803d5540, 0x803d5558]
+    .sdata2: [0x803d7a08, 0x803d7a20]
+
 src/Kameda/Scene.cpp:
     .text: [0x8012cfbc, 0x8012d020]
     .data: [0x803549a0, 0x803549b8]
@@ -1042,10 +1054,29 @@ src/Kaneshige/SimpleDrawer.cpp:
 src/Kaneshige/JugemPoint.cpp:
     .text: [0x80190324, 0x80190334]
 
+src/Kaneshige/RaceBGMPlayer.cpp:
+    .text: [0x8019dd54, 0x8019e3cc]
+    .ctors: [0x802d86e4, 0x802d86e8]
+    .bss: [0x8038a830, 0x8038a860]
+    .sdata: [0x803d3990, 0x803d3998]
+
+src/Kaneshige/BlurScreen.cpp:
+    .text: [0x801a3f84, 0x801a451c]
+    .sdata2: [0x803d8cd8, 0x803d8ce8]
+
 src/Kaneshige/KartMtx.cpp:
     .text: [0x801a6678, 0x801a6728]
     .sdata2: [0x803d8d38, 0x803d8d40]
 
+src/Kaneshige/GhostScreen.cpp:
+    .text: [0x801ab0a0, 0x801ab4ec]
+
+src/Kaneshige/ShimmerScreen.cpp:
+    .text: [0x801ab4ec, 0x801abd70]
+    .sdata: [0x803d3a40, 0x803d3a48]
+    .sbss: [0x803d57d8, 0x803d57e8]
+    .sdata2: [0x803d8da0, 0x803d8dc0]
+
 src/Kaneshige/Movie/MoviePlayer.cpp:
     .text: [0x801b0084, 0x801b0458]
     .rodata: [0x8033dd98, 0x8033ddc0]
@@ -1060,6 +1091,10 @@ src/Kaneshige/Movie/THPDraw.c:
 src/Kaneshige/RaceTime.cpp:
     .text: [0x801b1d9c, 0x801b1df0]
 
+src/Kaneshige/MaskScreen.cpp:
+    .text: [0x801b1df0, 0x801b2558]
+    .sdata2: [0x803d8e90, 0x803d8ea0]
+
 src/Kaneshige/THP/THPPlayer.c:
     .text: [0x801b2558, 0x801b3c88]
     .ctors: [0x802d8728, 0x802d872c]
@@ -1083,6 +1118,11 @@ src/Kaneshige/THP/THPAudioDecode.c:
     .bss: [0x8038e508, 0x8038F890]
     .sbss: [0x803d5ae0, 0x803d5ae8]
 
+src/Kawano/SceneTitleLine.cpp:
+    .text: [0x801c9760, 0x801c9b18]
+    .rodata: [0x8033ee78, 0x8033eec8]
+    .sdata2: [0x803d9118, 0x803d9140]
+
 src/Osako/clock.cpp:
     .text: [0x801cbe60, 0x801cbef8]
     .sbss: [0x803d5b30, 0x803d5b40]
@@ -1094,6 +1134,14 @@ src/Osako/testApp.cpp:
     .sbss: [0x803d5b40, 0x803d5b48]
     .sdata2: [0x803d9690, 0x803d9698]
 
+src/Osako/shadowModel.cpp:
+    .text: [0x801cc11c, 0x801cc4a4]
+    .ctors: [0x802d8764, 0x802d8768]
+    .rodata: [0x803407b8, 0x803407c8]
+    .data: [0x8035c1a8, 0x8035c1f0]
+    .bss: [0x8038fb08, 0x8038fb38]
+    .sdata2: [0x803d9698, 0x803d96c0]
+
 src/Osako/GameApp.cpp:
     .text: [0x801cc4a4, 0x801cc5bc]
     .data: [0x8035c1f0, 0x8035c208]
@@ -1101,6 +1149,15 @@ src/Osako/GameApp.cpp:
 src/Osako/main.cpp:
     .text: [0x801cc5bc, 0x801cc5e0]
 
+src/Osako/RaceApp.cpp:
+    .text: [0x801ccda4, 0x801ce300]
+    .ctors: [0x802d8774, 0x802d8778]
+    .data: [0x8035c250, 0x8035c2b8]
+    .rodata: [0x80340880, 0x803408d8]
+    .bss: [0x8038fbc8, 0x8038fbf8]
+    .sbss: [0x803d5b60, 0x803d5b68]
+    .sdata2: [0x803d96d0, 0x803d96e0]
+
 src/Osako/ResMgr.cpp:
     .text: [0x801ce300, 0x801cf8c4]
     .ctors: [0x802d8778, 0x802d877c]
@@ -1200,6 +1257,12 @@ src/Osako/SequenceApp.cpp:
     .sdata: [0x803d3b08, 0x803d3b10]
     .sbss: [0x803d5c60, 0x803d5c68]
 
+src/Osako/TestViewApp.cpp:
+    .text: [0x801da324, 0x801da460]
+    .rodata: [0x80340f78, 0x80340f88]
+    .data: [0x8035c9e0, 0x8035c9f8]
+    .sbss: [0x803d5c70, 0x803d5c78]
+
 src/Osako/shadowScr.cpp:
     .text: [0x801daf04, 0x801db44c]
     .sdata2: [0x803d9ad0, 0x803d9ad8]
@@ -1232,6 +1295,11 @@ src/Osako/PadMgr.cpp:
 src/Osako/PadRecorder.cpp:
     .text: [0x801dc588, 0x801dcdf4]
 
+src/Osako/ForceEffectMgr.cpp:
+    .text: [0x801dcdf4, 0x801dcf90]
+    .data: [0x8035cbb8, 0x8035cbc8]
+    .sbss: [0x803d5ca0, 0x803d5ca8]
+
 src/Osako/AwardApp.cpp:
     .text: [0x801ddb68, 0x801dddb8]
     .ctors: [0x802d87b4, 0x802d87b8]
@@ -1283,6 +1351,78 @@ src/Osako/password.cpp:
     .text: [0x801e76a8, 0x801e7a8c]
     .rodata: [0x80341938, 0x803419a0]
 
+src/Shiraiwa/WipeSlide.cpp:
+    .text: [0x80276fa8, 0x802779ac]
+    .ctors: [0x802d8948, 0x802d894c]
+    .data: [0x80367498, 0x803674c8]
+    .bss: [0x803adb98, 0x803adbc8]
+    .sdata: [0x803d45b8, 0x803d45c0]     
+    .sdata2: [0x803dade0, 0x803dae00]
+    .sbss2: [0x803dc120, 0x803dc128]
+
+src/Shiraiwa/WipeBase.cpp:
+    .text: [0x802779ac, 0x8027837c]
+    .ctors: [0x802d894c, 0x802d8950]
+    .rodata: [0x80344518, 0x80344560]
+    .data: [0x803674c8, 0x80367510]
+    .bss: [0x803adbc8, 0x803adbf8]
+    .sdata2: [0x803dae00, 0x803dae18]
+
+src/Shiraiwa/WipeCircle.cpp:
+    .text: [0x8027837c, 0x80278b90]
+    .ctors: [0x802d8950, 0x802d8954]
+    .data: [0x80367510, 0x80367540]
+    .bss: [0x803adbf8, 0x803adc28]
+    .sdata: [0x803d45c0, 0x803d45c8]  
+    .sbss: [0x803d6218, 0x803d6220]   
+    .sdata2: [0x803dae18, 0x803dae38]
+    .sbss2: [0x803dc128, 0x803dc130]
+
+src/Shiraiwa/WipeCheck.cpp:
+    .text: [0x80290320, 0x80290918]
+    .ctors: [0x802d89b0, 0x802d89b4]
+    .data: [0x8036a3c8, 0x8036a3f8]
+    .bss: [0x803ae0e8, 0x803ae118]
+    .sdata: [0x803d4798, 0x803d47a0]
+    .sdata2: [0x803db2f0, 0x803db308]
+    
+src/Shiraiwa/WipeShut.cpp:
+    .text: [0x80290918, 0x80291270]
+    .ctors: [0x802d89b4, 0x802d89b8]
+    .data: [0x8036a3f8, 0x8036a428]
+    .bss: [0x803ae118, 0x803ae148]
+    .sdata: [0x803d47a0, 0x803d47b0]
+    .sbss: [0x803d6378, 0x803d6380]
+    .sdata2: [0x803db308, 0x803db330]
+
+src/Shiraiwa/WipeLine.cpp:
+    .text: [0x80291270, 0x80291b7c]
+    .ctors: [0x802d89b8, 0x802d89bc]
+    .data: [0x8036a428, 0x8036a488]
+    .bss: [0x803ae148, 0x803ae178]
+    .sdata: [0x803d47b0, 0x803d47c0]
+    .sbss: [0x803d6380, 0x803d6388]
+    .sdata2: [0x803db330, 0x803db350]
+
+src/Shiraiwa/WipeWave.cpp:
+    .text: [0x80291b7c, 0x80292364]
+    .ctors: [0x802d89bc, 0x802d89c0]
+    .data: [0x8036a488, 0x8036a4c0]
+    .bss: [0x803ae178, 0x803ae1a8]
+    .sdata: [0x803d47c0, 0x803d47d0]
+    .sbss: [0x803d6388, 0x803d6390]
+    .sdata2: [0x803db350, 0x803db368]
+
+src/Shiraiwa/WipeCurtain.cpp:
+    .text: [0x8029582c, 0x802961b4]
+    .ctors: [0x802d89cc, 0x802d89d0]
+    .data: [0x8036aae8, 0x8036ab18]
+    .bss: [0x803ae238, 0x803ae268]
+    .sdata: [0x803d4800, 0x803d4808]
+    .sbss: [0x803d63b0, 0x803d63b8]
+    .sdata2: [0x803db408, 0x803db428]
+    .sbss2: [0x803dc130, 0x803dc134]
+
 src/Sato/stMath.cpp:
     .text: [0x801ebb10, 0x801ed470] 
     .data: [0x8035d110, 0x8035d128]
@@ -1299,6 +1439,26 @@ src/Sato/stEfctWeed.cpp:
     .sbss: [0x803d5df0, 0x803d5df8]
     .sdata2: [0x803da100, 0x803da108]
 
+src/Sato/RivalKart.cpp:
+    .text: [0x8023586c, 0x80235d80]
+    .ctors: [0x802d885c, 0x802d8860]
+    .data: [0x803616c0, 0x803616d8]
+    .bss: [0x803acfa0, 0x803acfd0]
+
+src/Yamamoto/kartCamera.cpp:    
+    .text: [0x8029dffc, 0x8029f4b8]
+    .ctors: [0x802d89dc, 0x802d89e0]
+    .data: [0x8036adf0, 0x8036b140]
+    .bss: [0x803ae2f0, 0x803ae320]
+    .sdata2: [0x803db590, 0x803db5a8]
+
+src/Yamamoto/kartCtrl.cpp:
+    .text: [0x8029f4b8, 0x802a0a60]
+    .ctors: [0x802d89e0, 0x802d89e4]
+    .bss: [0x803ae320, 0x803ae350]
+    .sbss: [0x803d63c8, 0x803d63e0]
+    .sdata2: [0x803db5a8, 0x803db5c0]    
+
 src/Yamamoto/kartvec.cpp:
     .text: [0x802a20cc, 0x802a320c]
     .ctors: [0x802d89e8, 0x802d89ec]
@@ -1311,6 +1471,19 @@ src/Yamamoto/kartLine.cpp:
     .bss: [0x803ae440, 0x803ae470]
     .sdata2: [0x803db998, 0x803db9a0]
 
+src/Yamamoto/KartSound.cpp:
+    .text: [0x802bcf8c, 0x802be490]
+    .ctors: [0x802d8a0c, 0x802d8a10]
+    .rodata: [0x80345e60, 0x80345eb8]
+    .bss: [0x803ae530, 0x803ae560]
+    .sdata2: [0x803dbbe8, 0x803dbc08]
+
+src/Yamamoto/KartTaeget.cpp:
+    .text: [0x802be490, 0x802be9e4]
+    .ctors: [0x802d8a10, 0x802d8a14]
+    .bss: [0x803ae560, 0x803ae590]
+    .sdata2: [0x803dbc08, 0x803dbc10]
+
 src/Yamamoto/KartStar.cpp:
     .text: [0x802c796c, 0x802c7c68]
     .ctors: [0x802d8a2c, 0x802d8a30]
@@ -1321,7 +1494,38 @@ src/Yamamoto/KartTire.cpp:
     .ctors: [0x802d8a30, 0x802d8a34]
     .bss: [0x803ae6e0, 0x803ae710]
 
+src/Yamamoto/KartDisp.cpp:
+    .text: [0x802d21c0, 0x802d3fb4]
+    .ctors: [0x802d8a44, 0x802d8a48]
+    .rodata: [0x80346170, 0x80346c20]
+    .bss: [0x803ae7d0, 0x803ae800]
+    .sdata2: [0x803dbf88, 0x803dbff8]
+
+src/Yamamoto/KartHandle.cpp:
+    .text: [0x802d3fb4, 0x802d45bc]
+    .ctors: [0x802d8a48, 0x802d8a4c]
+    .data: [0x8036dd48, 0x8036dda8]
+    .bss: [0x803ae800, 0x803ae830]
+    .sdata2: [0x803dbff8, 0x803dc000]
+
 src/Yamamoto/KartApeendix.cpp:
     .text: [0x802d45bc, 0x802d46f0]
     .ctors: [0x802d8a4c, 0x802d8a50]
-    .bss: [0x803ae830, 0x803ae860]
+    .bss: [0x803ae830, 0x803ae860]
+
+src/Yamamoto/KartPipe.cpp:
+    .text: [0x802d46f0, 0x802d5248]
+    .ctors: [0x802d8a50, 0x802d8a54]
+    .bss: [0x803ae860, 0x803ae890]
+
+src/Yamamoto/KartAnt.cpp:
+    .text: [0x802d5248, 0x802d5a44]
+    .ctors: [0x802d8a54, 0x802d8a58]
+    .bss: [0x803ae890, 0x803ae8c0]
+    .sdata2: [0x803dc030, 0x803dc050]
+
+src/Yamamoto/KartPerCam.cpp:
+    .text: [0x802d7670, 0x802d84a0]
+    .ctors: [0x802d8a5c, 0x802d8a80]
+    .bss: [0x803ae8f0, 0x803ae920]
+    .sdata2: [0x803dc068, 0x803dc0c0]

config/Release_eu/symbols.yml

@@ -47,6 +47,8 @@ global:
   0x800557cc: __dt__13J3DDrawBufferFv
   0x8005582c: frameInit__13J3DDrawBufferFv
   0x80055d78: draw__13J3DDrawBufferCFv
+  # J3DModel.cpp
+  0x80056918: setDeformData__8J3DModelFP13J3DDeformDataUl
   # J3DShape.cpp
   0x80050ed0: loadPreDrawSetting__8J3DShapeCFv
   0x803d4bd0: sOldVcdVatCmd__8J3DShape
@@ -54,7 +56,11 @@ global:
   0x80057184: init__12J3DFrameCtrlFs
   0x800571b4: update__12J3DFrameCtrlFv
   # J3DUClipper.cpp
+  0x8000a24c: init__11J3DUClipperFv
+  0x8000a260: calcViewFrustum__11J3DUClipperFv
   0x8000a3c8: clip__11J3DUClipperCFPA4_Cf3Vecf
+  0x8000a4f0: __dt__11J3DUClipperFv
+  0x80347ab8: __vt__11J3DUClipper
   # JKernel
   # JKRAram.cpp
   0x8000a540: create__7JKRAramFUlUllll
@@ -794,6 +800,12 @@ global:
   0x80024c80: IsConnected__8LGWheelsFl
   0x80024de0: PlayAutoCalibAndSpringForce__8LGWheelsFl
   0x80024f1c: PlaySpringForce__8LGWheelsFlScUcs
+  0x80025858: PlayBumpyRoadEffect__8LGWheelsFlUc
+  0x80025a94: StopBumpyRoadEffect__8LGWheelsFl
+  0x80025ad8: PlaySlipperyRoadEffect__8LGWheelsFls
+  0x80025d88: StopSlipperyRoadEffect__8LGWheelsFl
+  0x80026168: PlayCarAirborne__8LGWheelsFl
+  0x80026370: StopCarAirborne__8LGWheelsFl
 
   # JMath
   # JMath.cpp
@@ -827,6 +839,9 @@ global:
   0x800275e8: getGrafType__13J2DOrthoGraphCFv
   0x800275f0: place__14J2DGrafContextFffff
   0x80348510: __vt__13J2DOrthoGraph
+
+  # J2DPerspGraph.cpp
+  0x80348538: __vt__13J2DPerspGraph
   
   # J2DGrafContext.cpp
   0x8002790c: __ct__14J2DGrafContextFffff
@@ -845,9 +860,15 @@ global:
   0x80348560: __vt__14J2DGrafContext
 
   # J2DPane.cpp
+  0x8002a57c: animationTransform__7J2DPaneFv
   0x8002a9b0: getTransform__15J2DAnmTransformCFUsP16J3DTransformInfo
   0x8002a9b4: getTypeID__7J2DPaneCFv
 
+  # J2DPicture.cpp
+  0x8002b374: __ct__10J2DPictureFP10JUTTexture
+  0x8002bc98: __dt__10J2DPictureFv
+  0x8002c97c: draw__10J2DPictureFffffbbb
+
   # J2DPrint.cpp
   0x8002e484: __ct__8J2DPrintFP7JUTFontf
   0x8002e5f4: initiate__8J2DPrintFv
@@ -968,6 +989,9 @@ global:
   # J3DTevs.cpp
   0x80054c4c: calc__9J3DTexMtxFPA4_Cf
   0x803b9c14: j3dZModeTable
+
+  # J3DCluster.cpp
+  0x8005b428: setAnm__13J3DDeformDataFP13J3DAnmCluster
   
   # JFramework
   # JFWSystem.cpp
@@ -2409,6 +2433,10 @@ global:
   0x8011226c: getEngineType__11EngineSoundF7EKartID 
 
   # Inagaki
+  # CharacterSoundMgr.cpp
+  0x80112524: setVoice__Q29GameAudio17CharacterSoundMgrFUc
+  # GameAudioCamera.cpp
+  0x801134d4: setCameraInfo__Q29GameAudio9CameraMgrFUl3VecPA4_fP7CrsArea
   # GameAudioCommon.cpp
   0x80113900: panDeform__Q29GameAudio6CommonFff
   0x80113944: setMultiPlayModePan__Q29GameAudio6CommonFUc
@@ -2416,6 +2444,7 @@ global:
   0x80113a08: setSeed__Q29GameAudio6RandomFUl
   0x80113a14: getRandomU32__Q29GameAudio6RandomFv
   0x80113a70: getSignalEngineRandomU32__Q29GameAudio6RandomFv
+  0x801158cc: stopStreamBgm__Q29GameAudio4MainFUl
   # GameAudioHostIO.cpp
   0x803d7658: GA_MULTI_CAMERA_VOL_DOWN_DISTANCE__9GameAudio
   0x803d765c: GA_MULTI_CAMERA_VOL_DOWN_RATE__9GameAudio
@@ -2426,6 +2455,10 @@ global:
   0x8011479c: initRaceSound__Q29GameAudio4MainFv
   0x801148a8: frameWork__Q29GameAudio4MainFv
   0x80114ad8: isWaveLoaded__Q29GameAudio4MainFQ39GameAudio4Main5WS_ID
+  0x80115140: startSequenceBgm__Q29GameAudio4MainFUl
+  0x801154e4: prepareStreamBgm__Q29GameAudio4MainFUl
+  0x80115688: startStreamBgm__Q29GameAudio4MainFUl
+  0x801158f8: getPlayingStreamID__Q29GameAudio4MainFv
   0x80115ea4: startSystemSe__Q29GameAudio4MainFUl
   0x80115f58: startRaceSystemSe__Q29GameAudio4MainFUl
   0x801167b0: setMasterVolume__Q29GameAudio4MainFSc
@@ -2436,9 +2469,39 @@ global:
   0x80116c70: resumeAudio__Q29GameAudio4MainFv
   0x803d5498: msBasic__Q29GameAudio4Main
   0x803d549c: mLastBaaPointer__9GameAudio
+  0x803d7660: GoalFanfareDelayFrame__9GameAudio
   # GameAudioParam.cpp
+  0x80118e64: setPlayerMode__Q29GameAudio10ParametersFUc
+  0x80119094: setRaceMode__Q29GameAudio10ParametersFUc
   0x80119294: setDemoMode__Q29GameAudio10ParametersFUc
-  0x801195c0: getDemoMode__Q29GameAudio10ParametersFv  
+  0x801195c0: getDemoMode__Q29GameAudio10ParametersFv
+  0x80119390: setRaceCourse__Q29GameAudio10ParametersF9ECourseID
+  0x80119420: setKartType__Q29GameAudio10ParametersFUc11EKartWeight
+  0x80119430: setNetworkMode__Q29GameAudio10ParametersFUcUc
+  0x8011943c: setChrType__Q29GameAudio10ParametersFUc7EKartID
+  # KartSoundMgr.cpp
+  0x801198b8: __ct__Q29GameAudio12KartSoundMgrFP3VecP7JKRHeapUcUc
+  0x80119ed0: changeDriver__Q29GameAudio12KartSoundMgrFb
+  0x80119ed4: frameWork__Q29GameAudio12KartSoundMgrFUc
+  0x8011a1e0: setWaterDepth__Q29GameAudio12KartSoundMgrFUcf
+  0x8011a1f0: setSlip__Q29GameAudio12KartSoundMgrFUcUcUcf
+  0x8011a6b0: setConductStatus__Q29GameAudio12KartSoundMgrFffbbbUcP7CrsArea
+  0x8011c42c: setCrushSe__Q29GameAudio12KartSoundMgrFQ29CrsGround4EMatf
+  0x8011c568: setCrushSe__Q29GameAudio12KartSoundMgrFUlf
+  0x8011c668: setBrakeSe__Q29GameAudio12KartSoundMgrFUl
+  0x8011c774: setDashSe__Q29GameAudio12KartSoundMgrFUl
+  0x8011c81c: setMiniturboSe__Q29GameAudio12KartSoundMgrFUl
+  0x8011c8a8: setJumpUpSe__Q29GameAudio12KartSoundMgrFUl
+  0x8011c914: setBoundSe__Q29GameAudio12KartSoundMgrFf
+  0x8011ca10: setWheelSpinSe__Q29GameAudio12KartSoundMgrFv
+  0x8011cae0: setSpinSe__Q29GameAudio12KartSoundMgrFv
+  0x8011cba8: setSpinTurnSe__Q29GameAudio12KartSoundMgrFv
+  0x8011cc78: setSe__Q29GameAudio12KartSoundMgrFUl
+  0x8011cdd4: setChibiPitch__Q29GameAudio12KartSoundMgrFP14JAISoundHandle
+  0x8011d6bc: setInvincibleBgm__Q29GameAudio12KartSoundMgrFUc
+  0x8011d7dc: clearInvincibleBgm__Q29GameAudio12KartSoundMgrFUc
+  0x8011d974: setChibiFlag__Q29GameAudio12KartSoundMgrFbb
+  
   # GameSoundTable.cpp
   0x8011fb74: getBgmSeqResourceID__Q29GameAudio16CustomSoundTableCF10JAISoundID
   0x8011fbf0: getSoundType__Q29GameAudio16CustomSoundTableCF10JAISoundID
@@ -2485,16 +2548,70 @@ global:
   0x8012415c: reset__10J2DManagerFv
   0x80124424: calc__10J2DManagerFv
   0x801245a0: calcParticle__10J2DManagerFv
+  0x801245f8: getKart2Status__10J2DManagerFi
+  0x8012460c: getStatus2Kart__10J2DManagerFi
   0x80124620: setStatus2Kart__10J2DManagerFii
+  0x80124850: isAlarm__10J2DManagerFi
   0x80124874: startLANNumAnm__10J2DManagerFv
   0x803d5508: mThis__10J2DManager
   0x803d550c: mNetFlag__10J2DManager
 
+  # Task.cpp
+  0x80124a58: __ct__4TaskFi
+  0x80124ab4: init__4TaskFv
+  0x80124c04: make__4TaskFPFv_vUs
+  0x80124ca4: run__4TaskFv
+  0x80124d48: change__4TaskFPFv_vPQ24Task3TCB
+  0x80124d90: kill__4TaskFPQ24Task3TCB
+  0x80124ddc: head__4TaskFv
+  0x80124de0: tail__4TaskFv
+
   # PauseManager.cpp
+  0x8012717c: tstPause__12PauseManagerFv
   0x801263b8: __ct__12PauseManagerFP7JKRHeap
   0x8012652c: reset__12PauseManagerFv
   0x803d5518: mThis__12PauseManager
 
+  # Pause2D.cpp
+  0x80127ee4: __ct__Q29JGeometry8TVec2<f>Fv
+
+  # WipeManager.cpp
+  0x80129f18: __ct__11WipeManagerFP7JKRHeap
+  0x8012a230: __dt__9WipeParamFv
+  #0x8012a278: unnamed class ctor
+  0x8012a284: __dt__11WipeHioNodeFv
+  0x8012a2f4: reset__11WipeManagerFv
+  0x8012a37c: draw__11WipeManagerFv
+  0x8012a4fc: drawIn__11WipeManagerFiii
+  0x8012aa60: drawOut__11WipeManagerFiii
+  0x8012afb0: calc__11WipeManagerFv
+  0x8012b0a8: calcIn__11WipeManagerFiii
+  0x8012b5b0: calcOut__11WipeManagerFiii
+  0x8012baa4: getWipeState__11WipeManagerFi
+  0x8012bab4: setWipe__11WipeManagerFiisssQ28JUtility6TColor
+  0x8012bc54: initPre__11WipeManagerFv
+  0x8012bcec: preWipe__11WipeManagerFv
+  0x8012bdb4: initMain__11WipeManagerFv
+  0x8012be4c: mainWipe__11WipeManagerFv
+  0x8012bf14: initAfter__11WipeManagerFv
+  0x8012bfac: afterWipe__11WipeManagerFv
+  0x80354984: __vt__11WipeHioNode
+  0x80354990: __vt__9WipeParam
+  0x803d5540: mThis__11WipeManager
+  0x803d5544: mTask__11WipeManager
+  0x803d5548: mMoveFlag__11WipeManager
+  0x803d5550: mKillFlag__11WipeManager
+
+  # Fade.cpp
+  0x8012c188: __ct__4FadeFP7JKRHeap
+  0x8012c5a0: init__4FadeFv
+  0x8012c5a4: draw__4FadeFifQ28JUtility6TColor
+
+  # Mario.cpp
+  0x80154aa8: __ct__5MarioFP7JKRHeap
+  0x80155068: init__5MarioFv
+  0x8015506c: draw__5MarioFfQ28JUtility6TColor
+
   # Scene.cpp
   0x8012cfbc: __ct__5SceneFP10JKRArchiveP7JKRHeap
   0x8012cfd8: __dt__5SceneFv
@@ -2702,20 +2819,38 @@ global:
   0x8017c578: patchCamDataForStaffRoll__7CrsDataF8Language9VideoMode
   0x8017c734: getAmbientColor__7CrsDataCFPQ28JUtility6TColor
   0x8017c780: getShadowColor__7CrsDataCFPQ28JUtility6TColor
+  0x8017e790: getCameraData__7CrsDataCFi
+  0x8017e7c4: getFrontDirection__Q27CrsData6CameraCFPQ29JGeometry8TVec3<f>
   0x8017e848: getPathData__7CrsDataCFUs
   0x8017e874: getPointData__7CrsDataCFUsUs
   0x8017c8b4: getStartPoint__7CrsDataCFUc
 
+  # CrsGround.cpp
+  0x8017ea48: __ct__9CrsGroundFP6Course
+  0x8017ea84: reset__9CrsGroundFv
+  0x80180370: getHeight__9CrsGroundCFv
+  0x801806b8: getPipePoint__9CrsGroundFv
+  0x80180748: getWaterHeight__9CrsGroundFv 
+
   # ExModel.cpp
-  0x80181008: __ct__7ExModelFUs
-  0x801810dc: __dt__7ExModelFv
   0x80180f38: __ct__12ExMdlDataMgrFb
+  0x80181008: __ct__7ExModelFUs
+  0x801810dc: __dt__7ExModelFv  
   0x80181184: patchModelData__7ExModelFP12J3DModelData
   0x80181228: setLODBias__7ExModelFf
   0x80181334: setFogInfo__7ExModelFP12J3DModelDataUcffffPQ28JUtility6TColor
   0x8018113c: setModelData__7ExModelFP12J3DModelData
+  0x80181604: createModel__7ExModelFP12JKRSolidHeapUlUl
+  0x8018173c: createDifferedModel__7ExModelFP12JKRSolidHeapUlUlb
+  0x80181ad0: calc__7ExModelFv
+  0x80181b00: calc__7ExModelFUs
+  0x80181c18: update__7ExModelFUs
+  0x80181e48: setCurrentViewNo__7ExModelFUl
   0x80182194: simpleDraw__7ExModelFUlPA4_fUl
   0x80182aac: setBaseTRMtx__7ExModelFPA4_f
+  0x80182cfc: viewCalc__7ExModelFUl
+  0x80355990: __vt__7ExModel
+  0x803559b4: __vt__12ExMdlDataMgr
   
   0x803d5618: sMtxCombinationOn__7ExModel
   0x803d86d8: sExModelInvalidLODBias__7ExModel
@@ -2724,6 +2859,9 @@ global:
   0x80183048: reset__10KartLoaderFv
   0x80183098: load__10KartLoaderFv
   0x80183cf4: createModel__10KartLoaderFP12JKRSolidHeapUl
+  0x80183d80: isCommonWheelModelData__10KartLoaderFv
+  0x80183da8: viewCalc__13ViewCtrlModelFUl
+  0x803559d0: __vt__13ViewCtrlModel
   # HioMgr.cpp
   0x80182d00: __ct__7HioNodeFPCcP13JORReflexibleUlUl
   0x80182d74: __dt__7HioNodeFv
@@ -2947,6 +3085,7 @@ global:
   0x8018ebc4: __ct__10KartDrawerFv
   
   0x8018f1f4: setAnimation__10KartDrawerFv
+  0x8018f704: setShadowInfo__10KartDrawerFRC7CrsArea
   0x8018fad0: update__10KartDrawerFv
   0x8018fdac: playTevAnm__10KartDrawerFi
   0x8018fdcc: stopTevAnm__10KartDrawerFv  
@@ -2978,7 +3117,10 @@ global:
   # RaceBGMPlayer.cpp
   0x8019dd54: __ct__13RaceBGMPlayerFv
   0x8019dd84: reset__13RaceBGMPlayerFv
+  0x8019de0c: getCrsDemoBGMLabel__13RaceBGMPlayerFv
   0x8019de54: calc__13RaceBGMPlayerFv
+  0x8019e170: getGoalBGMLabel__13RaceBGMPlayerFv
+  0x803d3990: sCrsBGMDelayTime__13RaceBGMPlayer
   
   # RaceDirector.cpp
   0x8019e3cc: __ct__12RaceDirectorFbP14DemoTimeKeeperi
@@ -3004,6 +3146,12 @@ global:
   0x803d5720: sSupervisorCreateNum__13GeoRabbitMark
   0x803d5724: sSupervisor__13GeoRabbitMark
 
+  # Blurscreen.cpp
+  0x801a3f84: __ct__10BlurScreenFv
+  0x801a402c: draw__10BlurScreenFRCQ28JUtility6TColorUcUcff
+  0x801a448c: captureScene__10BlurScreenFv
+  0x801a44cc: captureBlur__10BlurScreenFv
+
   # KartMtx.cpp
   0x801a6678: KartMtxPerspective__FPA4_fffffb
 
@@ -3011,8 +3159,38 @@ global:
   0x801a681c: __ct__19AwardDemoTimeKeeperFv
   0x801a6f94: __ct__19StaffRollTimeKeeperFv
 
+  # GhostScreen.cpp
+  0x801ab0a0: __ct__11GhostScreenFv
+  0x801ab13c: reset__11GhostScreenFv
+  0x801ab148: captureScene__11GhostScreenFv
+  0x801ab1bc: captureGhost__11GhostScreenFv
+  0x801ab208: draw__11GhostScreenFv
+
+  # ShimmerScreen.cpp
+  0x801ab4ec: __ct__13ShimmerScreenFP7ResTIMG
+  0x801ab65c: calc__13ShimmerScreenFv
+  0x801ab6c0: draw__13ShimmerScreenFv
+  0x801ab770: drawInit__13ShimmerScreenFv
+  0x801ab8bc: drawEnd__13ShimmerScreenFv
+  0x801ab8f8: levelDraw__13ShimmerScreenFi
+  0x803d3a40: sIndSinedOfs__13ShimmerScreen
+  0x803d3a42: sIndScaleExp__13ShimmerScreen
+  0x803d57d8: sIndTexScaleS__13ShimmerScreen
+  0x803d57dc: sIndTexScaleT__13ShimmerScreen
+  0x803d57e0: sIndReplace__13ShimmerScreen
+
+  # RaceTime.cpp
   0x801b1d9c: get__8RaceTimeCFPiPiPi
 
+  # MaskScreen.cpp
+  0x801b1df0: draw__14MaskScreenNodeFv
+  0x801b2060: __ct__10MaskScreenFv
+  0x801b2150: reset__10MaskScreenFv
+  0x801b2190: resetAllMask__10MaskScreenFv
+  0x801b21d0: requestMask__10MaskScreenFffb 
+  0x801b2298: capture__10MaskScreenFv
+  0x801b2314: draw__10MaskScreenFv
+
   # MovieApp.cpp
   0x801af940: create__8MovieAppFv
   0x801af9f4: call__8MovieAppFv
@@ -3103,9 +3281,22 @@ global:
   0x801b4878: PushDecodedAudioBuffer
   
   # Kawano
+  # driverData.cpp
+  0x801b48a8: __ct__15DriverDataChildFv
+  0x801b48f4: create__10DriverDataFv
+  0x801b49ec: __dt__10DriverDataFv
+  0x801b4a4c: __dt__15DriverDataChildFv
   # accessory.cpp
   0x801c86c8: ptr__12AccessoryMgrFv
   0x801c88f4: update__12AccessoryMgrFv
+  # SceneTitleLine.cpp
+  0x801c9760: __ct__14SceneTitleLineFP10JKRArchiveP7JKRHeapPc
+  0x801c98d0: __dt__14SceneTitleLineFv
+  0x801c9934: init_titleline__14SceneTitleLineFi
+  0x801c9994: drawTitleLine__14SceneTitleLineFP13J2DOrthoGraph
+  0x801c99e8: calcAnmTitleLine__14SceneTitleLineFi
+  0x801c9ab0: calcMatAnmTitleLine__14SceneTitleLineFv
+  0x8033ee78: mTag_Titleline__14SceneTitleLine
   # StaffRoll2D.cpp
   0x801cab9c: __ct__11StaffRoll2DFP7JKRHeap8Language9VideoModei
   0x801cb6f0: reset__11StaffRoll2DFv
@@ -3134,6 +3325,12 @@ global:
   0x801cc118: calc__7TestAppFv
   0x8035c190: __vt__7TestApp
   0x803d5b40: mspTestApp__7TestApp
+  # shadowModel.cpp
+  0x801cc11c: createModel__11ShadowModelFP12JKRSolidHeapUlUl
+  0x801cc198: calc__15KartShadowModelFv
+  0x801cc2f4: createModel__15KartShadowModelFP12JKRSolidHeapUlUl
+  0x8035c1a8: __vt__15KartShadowModel
+  0x8035c1cc: __vt__11ShadowModel
   # GameApp.cpp
   0x801cc4a4: __ct__7GameAppFUlPCcPv
   0x801cc548: __dt__7GameAppFv
@@ -3475,6 +3672,8 @@ global:
   0x801d8a18: adjustFrame__10NetGameMgrFv
   0x801d8c10: progressReadData__10NetGameMgrFv
   0x801d8d70: fetchPadData__10NetGameMgrFv
+  0x801d8e30: sleep__10NetGameMgrFv
+  0x801d8e48: awake__10NetGameMgrFv
 
   0x803d5c58: mspNetGameMgr__10NetGameMgr
   # SequenceApp.cpp
@@ -3496,15 +3695,29 @@ global:
   0x803d5c60: mspSequenceApp__11SequenceApp
   # NetGateApp.cpp
   0x801d9aec: create__10NetGateAppFv
+  0x801d9b3c: call__10NetGateAppFb
   0x803d5c68: mspNetGateApp__10NetGateApp
   0x803d5c6c: msSkip__10NetGateApp
   # TestViewApp.cpp
   0x801da324: create__11TestViewAppFv
+  0x801da374: __ct__11TestViewAppFv
+  0x801da3d4: __dt__11TestViewAppFv
+  0x801da434: reset__11TestViewAppFv
+  0x801da458: draw__11TestViewAppFv
+  0x801da45c: calc__11TestViewAppFv
+  0x8035c9e0: __vt__11TestViewApp
   0x803d5c70: mspTestViewApp__11TestViewApp
 
   # shadowMgr.cpp
   0x801da460: __ct__13ShadowManagerFv
+  0x801da544: getShadowModelList__13ShadowManagerFQ211ShadowModel10ShadowKind
+  0x801da594: regist__13ShadowManagerFP11ShadowModel
+  0x801da664: draw__13ShadowManagerFUlRQ27JGadget60TList
+  0x801da988: calc__13ShadowManagerFv
   0x801daaa0: viewCalc__13ShadowManagerFUl
+  0x801dab90: setDstAlpha__13ShadowManagerFv
+  0x801dabec: __dt__13ShadowManagerFv
+  0x8035c9f8: __vt__13ShadowManager
   0x803d5c78: mspShadowManager__13ShadowManager
   0x801da988: calc__13ShadowManagerFv
   # shadowScr.cpp
@@ -3563,6 +3776,13 @@ global:
   0x801dc900: line__11PadRecorderFUcP11KartPadData
   0x801dcacc: framework__11PadRecorderFv
   0x801dcc2c: nextFrame__11PadRecorderFv
+  # ForceEffectMgr.cpp
+  0x801dcdf4: __ct__14ForceEffectMgrFv
+  0x801dce40: __dt__14ForceEffectMgrFv
+  0x801dcea8: start__14ForceEffectMgrFv
+  0x801dcf1c: end__14ForceEffectMgrFv
+  0x8035cbb8: __vt__14ForceEffectMgr
+  0x803d5ca0: mspForceEffectMgr__14ForceEffectMgr
   # BBAMgr.cpp
   0x801dd058: create__6BBAMgrFP7JKRHeap
   # AwardApp.cpp
@@ -3739,6 +3959,7 @@ global:
   0x803d5e1c: sJ3DKartAnmMgr__17J3DEfctKartAnmMgr
   # ObjUtility.cpp
   0x802255b8: getPtrCourseArc__10ObjUtilityFPc
+  0x8022581c: getKartPos__10ObjUtilityFiPQ29JGeometry8TVec3<f>
   # JPEffectPerformer.cpp
   0x8022c340: setEffect__17JPEffectPerformerFQ217JPEffectPerformer10EffectTypeiRCQ29JGeometry8TVec3<f>Uc
   0x802307d8: initFrameCtrl__13J3DAnmObjBaseFP10J3DAnmBase
@@ -3751,29 +3972,262 @@ global:
   0x80231ec4: calc__15EffectScreenMgrFv
   0x803d5ec0: ThisMgr__15EffectScreenMgr
   # RivalKart.cpp
+  0x8023586c: __ct__9RivalKartFP8KartBody
+  0x80235a4c: __dt__9RivalKartFv
+  0x80235ab0: Init__9RivalKartFv
+  0x80235af8: StartInit__9RivalKartFv
   0x80235b20: Reset__9RivalKartFv
+  0x80235b44: ResetInit__9RivalKartFv
+  0x80235b8c: setRankAry__9RivalKartFv
+  0x80235bb0: getMaxSpeed__9RivalKartCFv
+  0x80235bbc: getOffsetMaxSpeed__9RivalKartCFv
+  0x80235bc8: setMaxSpeed__9RivalKartFRCf
+  0x80235bd8: ContempLate__9RivalKartFv
+  0x80235c68: ActiveCtrl__9RivalKartFv
+  0x803616c0: __vt__9RivalKart
   # StateObserver.cpp
   0x80235e54: setState__13StateObserverFUs
   # NeckCtrl.cpp
   0x8023a3a0: __ct__14CharIKParamMgrFv
   0x803d5ee8: mMgr__14CharIKParamMgr
 
+  # RivalItemCtrl.cpp
+  0x80241868: __ct__13RivalItemCtrlFP9RivalKart
+  0x80241974: init__13RivalItemCtrlFv
+  0x80241994: reset__13RivalItemCtrlFv
+  0x802419d0: doItemCtrl__13RivalItemCtrlFv
+
+  # RivalBodyCtrl.cpp
+  0x80243288: __ct__13RivalBodyCtrlFP9RivalKart
+  0x80243378: init__13RivalBodyCtrlFv
+  0x80243454: reset__13RivalBodyCtrlFv
+  0x80243530: setRankArray__13RivalBodyCtrlFv
+  0x80243710: chkPlayerKartCondition__13RivalBodyCtrlFv
+  0x8024378c: chkBodyCondition__13RivalBodyCtrlFv
+  0x80245190: doColWallCtrl__13RivalBodyCtrlFv
+  0x80245548: comebackRescure__13RivalBodyCtrlFP7CLPointb
+  0x8024630c: __ct__18RivalAwardBodyCtrlFP9RivalKart
+  0x80246560: __ct__21RivalAward2ndBodyCtrlFP9RivalKart
+
+  # RivalSpeedCtrl.cpp
+  0x80246ab4: __ct__14RivalSpeedCtrlFP9RivalKart
+  0x80246dbc: StartInit__14RivalSpeedCtrlFv
+  0x80246ef8: ResetInit__14RivalSpeedCtrlFv
+  0x80246f54: LoadCrsLevelParam__14RivalSpeedCtrlFv  
+  0x802472e0: init__14RivalSpeedCtrlFv
+  0x80247e4c: __ct__23RivalAwardDemoSpeedCtrlFP9RivalKart
+  0x8024808c: __ct__26RivalAwardDemo2ndSpeedCtrlFP9RivalKart
+  0x80248390: __ct__27RivalStaffRollDemoSpeedCtrlFP9RivalKart
+  
+  0x803d5f58: sStartRankPtr__14RivalSpeedCtrl
+  0x803d5f5c: sConfusedFightModeFlg__14RivalSpeedCtrl
+  0x803d5f5d: sComWeakPointSwapFlg__14RivalSpeedCtrl
+
   # Shiraiwa
   # JugemMain.cpp
   0x802505e4: isAbleStart__6TJugemFv
+  0x80253468: getSignalState__6TJugemFv
+
+  # SiUtil.cpp
+  0x80266f14: checkPassFrame__6SiUtilFfff
+  0x80266f78: getViewport__6SiUtilFPQ29JGeometry8TBox2<f>UcUc
+  0x80267088: getViewport__6SiUtilFPQ29JGeometry8TBox2<f>Uc
+  0x8026712c: getScreenPosCheckMirror__6SiUtilFiRCQ29JGeometry8TVec3<f>PQ29JGeometry8TVec2<f>
+  0x80267168: getScreenPos__6SiUtilFiRCQ29JGeometry8TVec3<f>PQ29JGeometry8TVec2<f>b
+  0x802672a8: setItemReaction__6SiUtilFPCvP12GeographyObj
+  0x80267438: clampVec__6SiUtilFRCQ29JGeometry8TVec3<f>RQ29JGeometry8TVec3<f>RCQ29JGeometry8TVec3<f>RCQ29JGeometry8TVec3<f>
+  0x802674c0: getNormalRange__6SiUtilFfff
+  0x802674ec: getConsoleNum__6SiUtilFv
+  0x80267500: getDrawConsoleNum__6SiUtilFv
+  0x80267528: getCourseHeight__6SiUtilFRQ29JGeometry8TVec3<f>
+  0x80267574: searchNearKartBall__6SiUtilFRCQ29JGeometry8TVec3<f>f
+  0x80267650: searchNearKartCircle__6SiUtilFRCQ29JGeometry8TVec3<f>f
+  0x8026778c: setRandomStartFrame__6SiUtilFP12J3DFrameCtrlP8stRandom
+
+  # WipeSlide.cpp
+  0x80276fa8: __ct__10TWipeSlideFP7JKRHeap
+  0x80276ff8: __dt__10TWipeSlideFv
+  0x80277050: init__10TWipeSlideFv
+  0x80277088: calcMain__10TWipeSlideFifQ28JUtility6TColor
+  0x802771b8: drawMain__10TWipeSlideFifQ28JUtility6TColor
+  0x8027759c: drawQuad__10TWipeSlideFffffRCQ28JUtility6TColor
+  0x802775c8: drawImage__10TWipeSlideFP10JUTTexturebffff
+  0x802776cc: initGXForTex__10TWipeSlideFQ28JUtility6TColor
+  0x8027789c: drawPreOut__9TWipeBaseFiQ28JUtility6TColor
+  0x80367498: __vt__10TWipeSlide
+  0x803d45b8: sWipePatternMask__10TWipeSlide
+
+  # WipeBase.cpp
+  0x802779ac: __ct__9TWipeBaseFP7JKRHeap
+  0x80277dec: getTexture__9TWipeBaseFUl
+  0x80277e00: __dt__9TWipeBaseFv
+  0x80277e9c: createBuffer__9TWipeBaseFiP7JKRHeap
+  0x80277f60: init__9TWipeBaseFv
+  0x80277f8c: reset__9TWipeBaseFv
+  0x80277fb0: calc__9TWipeBaseFifQ28JUtility6TColor
+  0x80278080: changeState__9TWipeBaseFii
+  0x80278084: draw__9TWipeBaseFifQ28JUtility6TColor
+  0x80278168: drawPreIn__9TWipeBaseFiQ28JUtility6TColor
+
+  0x803674c8: scTextureName__9TWipeBase
+  0x803674d4: sTexture__9TWipeBase
+  0x803674e0: __vt__9TWipeBase
+
+  # WipeCircle.cpp
+  0x8027837c: __ct__11TWipeCircleFP7JKRHeap
+  0x802783e8: __dt__11TWipeCircleFv
+  0x80278440: init__11TWipeCircleFv
+  0x802784c0: calcMain__11TWipeCircleFifQ28JUtility6TColor
+  0x8027866c: drawMain__11TWipeCircleFifQ28JUtility6TColor
+  0x802787e8: initGX__11TWipeCircleFv
+  0x80278918: drawBufferImage__11TWipeCircleFP10JUTTextureRQ29JGeometry8TBox2
+  0x80367510: __vt__11TWipeCircle
+  0x803d45c0: sAlphaMaxRate__11TWipeCircle
+  0x803d6218: sAlphaMinRate__11TWipeCircle
+
   # Balloon.cpp
   0x8027e158: robRivalOfBalloon__15TBalloonManagerFUl
   0x803da818: scSignalInterval__15TJugemRodSignal
   0x803d62a4: sSupervisor__14TBalloonString
 
+  # MapObjAntLion.cpp
+  0x8028c4a0: getZDir__14TMapObjAntLionFPQ29JGeometry8TVec3<f>
+
+  # WipeCheck.cpp
+  0x80290320: __ct__10TWipeCheckFP7JKRHeap
+  0x80290380: __dt__10TWipeCheckFv
+  0x802903d8: init__10TWipeCheckFv
+  0x802903fc: calcMain__10TWipeCheckFifQ28JUtility6TColor
+  0x80290494: drawPreIn__10TWipeCheckFiQ28JUtility6TColor
+  0x80290594: drawMain__10TWipeCheckFifQ28JUtility6TColor
+  0x802907e0: drawQuad__10TWipeCheckFffffRCQ28JUtility6TColor
+  0x8036a3c8: __vt__10TWipeCheck
+  0x803d4798: sWipeHeightOrg__10TWipeCheck
+  0x803d479a: sWipeWidthOrg__10TWipeCheck
+  0x803d479c: sAlphaDiffRate__10TWipeCheck
+
+  # WipeShut.cpp
+  0x80290918: __ct__9TWipeShutFP7JKRHeap
+  0x80290968: __dt__9TWipeShutFv
+  0x802909c0: init__9TWipeShutFv
+  0x802909e4: calcMain__9TWipeShutFifQ28JUtility6TColor
+  0x80290b6c: drawMain__9TWipeShutFifQ28JUtility6TColor
+  0x80290e44: initGX__9TWipeShutFv
+  0x80290f98: drawQuad__9TWipeShutFffffRCQ28JUtility6TColor
+  0x802910a8: drawTriangle__9TWipeShutFPQ29JGeometry8TVec2<f>RCQ28JUtility6TColor
+  0x8036a3f8: __vt__9TWipeShut
+  0x803d47a0: scWipeHeadHeight__9TWipeShut
+  0x803d47a2: scWipeHeadWidth__9TWipeShut
+  0x803d47a4: sChangeRate__9TWipeShut
+  0x803d47a8: sSecondWidthOrg__9TWipeShut
+  0x803d47ac: sAlphaMaxRate__9TWipeShut
+  0x803d6378: sAlphaMinRate__9TWipeShut
+
+  # WipeLine.cpp
+  0x80291270: __ct__10TWipeLineAFP7JKRHeap
+  0x802912c0: __dt__10TWipeLineAFv
+  0x80291318: init__10TWipeLineAFv
+  0x8029133c: calcMain__10TWipeLineAFifQ28JUtility6TColor
+  0x80291434: drawMain__10TWipeLineAFifQ28JUtility6TColor
+  0x80291638: drawQuad__10TWipeLineAFffffRCQ28JUtility6TColor
+  0x80291670: __ct__10TWipeLineBFP7JKRHeap
+  0x802916c0: __dt__10TWipeLineBFv
+  0x80291718: init__10TWipeLineBFv
+  0x8029173c: calcMain__10TWipeLineBFifQ28JUtility6TColor
+  0x80291834: drawMain__10TWipeLineBFifQ28JUtility6TColor
+  0x80291a38: drawQuad__10TWipeLineBFffffRCQ28JUtility6TColor
+  0x8036a428: __vt__10TWipeLineA
+  0x8036a458: __vt__10TWipeLineB
+  0x803d47b0: sWipeLineWidth__10TWipeLineA
+  0x803d47b2: sWipeProgressLines__10TWipeLineA
+  0x803d47b4: sAlphaMaxRate__10TWipeLineA
+  0x803d47b8: sWipeLineHeight__10TWipeLineB
+  0x803d47ba: sWipeProgressLines__10TWipeLineB
+  0x803d47bc: sAlphaMaxRate__10TWipeLineB
+  0x803d6380: sAlphaMinRate__10TWipeLineA
+  0x803d6384: sAlphaMinRate__10TWipeLineB
+
+  # WipeWave.cpp
+  0x80291b7c: __ct__10TWipeWaveAFP7JKRHeap
+  0x80291bcc: __dt__10TWipeWaveAFv
+  0x80291c24: init__10TWipeWaveAFv
+  0x80291c48: calcMain__10TWipeWaveAFifQ28JUtility6TColor
+  0x80291d60: drawMain__10TWipeWaveAFifQ28JUtility6TColor
+  0x80291f30: drawQuad__10TWipeWaveAFffffRCQ28JUtility6TColor
+  0x80291f5c: initGX__10TWipeWaveAFRCQ28JUtility6TColor
+  0x8029215c: drawTex__10TWipeWaveAFffffff
+  0x8036a488: __vt__10TWipeWaveA
+  0x803d47c0: sWipeMoveRateMax__10TWipeWaveA
+  0x803d47c4: sWipeHeadWidth__10TWipeWaveA
+  0x803d47c8: sWipeHeadHeight__10TWipeWaveA
+  0x803d47cc: sAlphaMaxRate__10TWipeWaveA
+  0x803d6388: sWipeStartPos__10TWipeWaveA
+  0x803d638c: sAlphaMinRate__10TWipeWaveA
+
+  # WipeCurtain.cpp
+  0x8029582c: __ct__12TWipeCurtainFP7JKRHeap
+  0x8029587c: __dt__12TWipeCurtainFv
+  0x802958d4: init__12TWipeCurtainFv
+  0x802958f8: calcMain__12TWipeCurtainFifQ28JUtility6TColor
+  0x802959cc: drawPreIn__12TWipeCurtainFiQ28JUtility6TColor
+  0x80295adc: drawMain__12TWipeCurtainFifQ28JUtility6TColor
+  0x80295e00: drawQuad__12TWipeCurtainFffffRCQ28JUtility6TColor
+  0x80295e2c: drawImage__12TWipeCurtainFP10JUTTextureffff
+  0x80295f08: initGXForTex__12TWipeCurtainFQ28JUtility6TColor
+  0x8036aae8: __vt__12TWipeCurtain
+  0x803d4800: sLineWidth__12TWipeCurtain
+  0x803d4804: sAlphaMaxRate__12TWipeCurtain
+  0x803d63b0: sAlphaMinRate__12TWipeCurtain
+
   # Yamamoto
+  # kartBody.cpp
+  0x80298648: DegubBody__8KartBodyFUl
+  0x802987ec: SetUpRigidBodyStartGridPose__8KartBodyFv
+  0x80298ce0: DoGForce__8KartBodyFv
+  0x8029918c: DoPose__8KartBodyFv
+  0x8029b1dc: CheckObjectReflection__8KartBodyFv
+  0x8029bbf0: CheckRoofReflection__8KartBodyFv
+  0x8029bcbc: WallReflection__8KartBodyFPQ29JGeometry8TVec3<f>fff
+  0x8029be8c: CheckVertexReflection__8KartBodyFv
+  0x8029c528: CheckBodyHit__8KartBodyFP8KartBodyP8KartBody
+  0x8029d6b0: Init__8KartBodyFi
+  # kartCamera.cpp
+  0x8029dffc: __ct__7KartCamFP8KartBodyP8KartCtrlUcUc
+  0x8029e080: DegubCamera__7KartCamFPcUl
+  0x8029e084: DoPort__7KartCamFi
+  0x8029eb08: Init__7KartCamFb
+  0x8029ef4c: DoInit__7KartCamFv
+  0x8029efb8: DoResetInit__7KartCamFv
+  0x8029efdc: DoRaceCtrl__7KartCamFv
+  0x8029f190: DoCameraMode__7KartCamFv
+  0x8029f254: DoCamera__7KartCamFv
+  0x8036adf0: viewdata
+  0x8036af30: balloonMinidata
+  0x8036af60: turtleMinidata
+  0x8036af90: bombMinidata
+  0x8036afc0: devilMinidata
+  0x8036aff0: balloonPakkunMinidata
+  0x8036b020: bombPakkunMinidata
+  0x8036b050: devilPakkunMinidata
   # kartCtrl.cpp
+  0x8029f4b8: Init__8KartCtrlFP8KartBodyPP7KartSusPP12KartAppendixP9KartSoundP10KartTargetP8KartDispi
   0x8029f614: makeKartCtrl__8KartCtrlFv
   0x8029f63c: DynamicsInit__8KartCtrlFb
   0x8029fb60: DynamicsReset__8KartCtrlFv  
   0x8029fd1c: DynamicsStage1__8KartCtrlFv
   0x802a01b4: DynamicsStage2__8KartCtrlFv
+  0x802a02b4: DrawKartInit__8KartCtrlFi
+  0x802a03cc: __dt__8GrafPortFv
+  0x802a0438: SetGrafPort__8KartCtrlFv
+  0x802a05dc: DrwaBody__8KartCtrlFiUlPA4_f
+  0x802a0668: DrwaParts__8KartCtrlFiUlPA4_f
   0x803d63c8: mCtrl__8KartCtrl
+  # Kartsus.cpp
+  0x802a10f0: Init__7KartSusFi
+  0x802a1270: NormalInit__7KartSusFi
+  0x802a12d4: ResetInit__7KartSusFi
+  0x802a12f4: DoSusAction__7KartSusFi
+  0x802a197c: DoTireAction__7KartSusFv
   # kartvec.cpp
   0x802a20cc: SetVector__7KartVecFP3Vecfff
   0x802a20dc: AddVector__7KartVecFP3Vecfff
@@ -3807,21 +4261,190 @@ global:
   0x802a2e38: AddMatrix__7KartMatFPA4_fPA4_f
   0x802a2ecc: NormalizeMatrix__7KartMatFPA4_f
   0x802a30a4: OmegaMatrix__7KartMatFPA4_fP3Vecf
+  # kartCtrlStrat.cpp
+  0x802ad274: MakeClear__8KartGameFv
+  0x802ae8f0: DoElementForce__8KartGameFv
+  0x802afcb0: DoStatus__8KartGameFv
   # kartLine.cpp
   0x802b075c: getBezierPoint__6SplineFPQ29JGeometry8TVec3<f>f
   # kartCtrlInfo.cpp
+  0x802b09ac: PadAllClear__8KartCtrlFi
+  0x802b0a18: DoContCtl__8KartCtrlFi
+  0x802b0c20: DoContCopy__8KartCtrlFi
+  0x802b0cdc: DoContPaste__8KartCtrlFi
+  0x802b0d98: GetItemStickY__8KartCtrlFi
+  0x802b0dac: GetItemStickX__8KartCtrlFi
+  0x802b0dd4: GetItemButton__8KartCtrlFi
+  0x802b0e04: DoLod__8KartCtrlFv
   0x802b12ec: GetLeftFTirePos__8KartCtrlFiP3Vec
   0x802b1314: GetRightFTirePos__8KartCtrlFiP3Vec
+  0x802b1430: GetCarSpeed__8KartCtrlFi
+  0x802b1460: GetCarRpm__8KartCtrlFi
+  0x802b148c: GetKartRpm__8KartCtrlFi
+  0x802b14a0: GetDriveCont__8KartCtrlFi
+  0x802b1520: GetCoDriveCont__8KartCtrlFi
+  0x802b15a0: GetCarStatus__8KartCtrlFi
+  0x802b1cd8: CheckTandemItmGet__8KartCtrlFi
+  0x802b1d58: CheckTandemItmRollingGet__8KartCtrlFi
+  0x802b15b8: GetGameStatus__8KartCtrlFi
+  0x802b16b0: CheckCamera__8KartCtrlFi
+  0x802b16d0: GetCameraNum__8KartCtrlFi
   0x802b1ad4: GetKartSoundMgr__8KartCtrlFi
+  0x802b1ae8: GetKartBodyOffset__8KartCtrlFi
   0x802b1284: GetBodyPos__8KartCtrlFiPQ29JGeometry8TVec3<f>
+  0x802b214c: EnemyInit__8KartCtrlFi
+  0x802b2178: EnemyResetInit__8KartCtrlFi
+  0x802b1f24: IsMiniGame__8KartCtrlFv
+  0x802b2128: getKartEnemy__8KartCtrlFi
   0x802b3134: SetTargetNum__7KartCamFUc
+  0x802b2534: DoSterr__9KartStratFv
+  0x802b2a2c: DoAccel__9KartStratFv
+  0x802b2f3c: HaveRabbit__8KartCtrlFv
+
+  # kartParams.cpp
+  0x8036b98c: BodyFullHeightData
+  0x8036b9e0: BodyFullBumpData
+  0x8036ba34: SusPowerData
+  0x8036ba88: ThunderOffet
+  0x8036bb30: SusDushDive
+  0x8036bb84: SetEngineClassData
+  0x8036bb90: SusParamsData
+  0x8036bbe4: TireParamsData
+  0x8036bc38: BodyParamsData
+
+  # kartBodyStrat.cpp
+  0x802a3318: Init__9KartStratFi
+  0x802a3330: GetBodySpeed__9KartStratFv
+  0x802a3368: GetBodyRoll__9KartStratFv
+  0x802a3538: GetRoadBodyRoll__9KartStratFv
+  0x802a38ec: GetBodyNorm__9KartStratFv
+
+  0x802a8aac: DoMotor__9KartStratFQ212MotorManager9MotorType
 
   # kartCamStrat.cpp
+  0x802b3134: SetTargetNum__7KartCamFUc
+  0x802b3154: SetClipper__7KartCamFv
+  0x802b31c4: CheckClipper__7KartCamFv
+  0x802b3260: __ct__8GrafPortFiiiifff
+  0x802b3314: setPort__8GrafPortFv
+  0x802b3370: SetParam__8GrafPortFfff
+  0x802b3380: MakeShaker__7KartCamFf
+  0x802b33c8: SetPtr__7KartCamFv
   0x802b34f8: GetCameraPos__7KartCamFv
+  0x802b3500: GetCameraLookPos__7KartCamFv
+  0x802b3508: SetFovyData__7KartCamFv
+  0x802b36f0: First4ScreenPort__7KartCamFUc
+  0x802b3cb0: Second4ScreenPort__7KartCamFUc
+  0x802b4270: Third4ScreenPort__7KartCamFUc
+  0x802b4830: Fourth4ScreenPort__7KartCamFUc
+  0x802b4df0: SetVictoryScreenPort__7KartCamFUc
+  0x802b5348: DoMoveCamera__7KartCamFPQ29JGeometry8TVec3<f>PQ29JGeometry8TVec3<f>
+  0x802b5628: DoSea__7KartCamFPQ29JGeometry8TVec3<f>P9CrsGround
+  0x802b5b68: DoGround__7KartCamFPQ29JGeometry8TVec3<f>P9CrsGround
+  0x802b60a0: InitOutView__7KartCamFv
+  0x802b6240: DoLookChase__7KartCamFv
+  0x802b6324: DoXRotation__7KartCamFv
+  0x802b6874: DoCamPos__7KartCamFfPQ29JGeometry8TVec3<f>
+  0x802b6b98: OutView__7KartCamFv
+  0x802b7490: InitRaceBackView__7KartCamFv
+  0x802b7580: ParallelView__7KartCamFv
+  0x802b7714: InitBackView__7KartCamFv
+  0x802b789c: BackView__7KartCamFv
+  0x802b78c4: HangRescueView__7KartCamFv
+  0x802b7a90: InitDropRescueView__7KartCamFv
+  0x802b7bf8: DropRescueView__7KartCamFv
+  0x802b7e94: LaunchView__7KartCamFv
+  0x802b8064: LandView__7KartCamFv
+  0x802b8234: InitPipeView__7KartCamFv
+  0x802b83c4: PipeView__7KartCamFv
+
+  0x8036be10: __vt__8GrafPort
+
+  # KartAnime.cpp
+  0x802b862c: IsAppeal__9KartAnimeFi
+  0x802b86ec: IsDamage__9KartAnimeFi
+  0x802b8ba8: IsBurnAnime__9KartAnimeFi
+  0x802b8e4c: Init__9KartAnimeFv
+
+  # KartItemStrat.cpp
+  0x802baf94: CheckHitItem__8KartItemFv
+  0x802bb880: ReleseWanWan__8KartItemFv
 
   # KartSound.cpp
+  0x802bcf8c: Init__9KartSoundFi
+  0x802bd088: DoInfo__9KartSoundFi
+  0x802bd2cc: DoFinishSound__9KartSoundFi
+  0x802bd31c: DoSlipSound__9KartSoundFi
+  0x802bd454: DoWallHitSound__9KartSoundFfQ29CrsGround4EMat
+  0x802bd478: DoHorn__9KartSoundFv
+  0x802bd5bc: DoKartHitSound__9KartSoundFf
+  0x802bd5e8: DoMashDashSound__9KartSoundFv
+  0x802bd614: DoDashSound__9KartSoundFv
+  0x802bd640: DoRollCrashStartSound__9KartSoundFv
+  0x802bd678: DoRollCrashSound__9KartSoundFv
+  0x802bd6b0: DoRollCrashEndSound__9KartSoundFv
+  0x802bd6e8: DoBrakeSound__9KartSoundFv
+  0x802bd714: DoStrikeSound__9KartSoundFv
   0x802bd74c: DoStarStartSound__9KartSoundFv
   0x802bd774: DoStarStopSound__9KartSoundFv
+  0x802bd79c: DoWanWanStartSound__9KartSoundFv
+  0x802bd7c4: DoWanWanStopSound__9KartSoundFv
+  0x802bd804: DoChangeStarSound__9KartSoundFv
+  0x802bd82c: DoChibiSound__9KartSoundFb
+  0x802bd854: DoGoalSound__9KartSoundFv
+  0x802bd88c: DoLapSound__9KartSoundFv
+  0x802bd8c4: DoThunderSound__9KartSoundFv
+  0x802bd8f0: DoShootSound__9KartSoundFv
+  0x802bd91c: DoFireBall__9KartSoundFv
+  0x802bd954: DoHitFireBall__9KartSoundFv
+  0x802bd98c: DoKartDiveSound__9KartSoundFv
+  0x802bd9c4: DoKartMiniTuroboSound__9KartSoundFv
+  0x802bd9f0: DoKartsetSeSound__9KartSoundFUl
+  0x802bda20: DoLandingSound__9KartSoundFf
+  0x802bda44: DoWheelSpin__9KartSoundFv
+  0x802bda68: DoShineStartBGM__9KartSoundFv
+  0x802bda94: DoShineStopBGM__9KartSoundFv
+  0x802bdacc: DoWallObjectSound__9KartSoundFUl
+  0x802bdb40: DoItemAlarm__9KartSoundFv
+  0x802bdbbc: DoSpinSound__9KartSoundFv
+  0x802bdbe0: DoSpinTurnSound__9KartSoundFv
+  0x802bdc04: DoStrikeVoice__9KartSoundFv
+  0x802bdc34: DoStaggerVoice__9KartSoundFv
+  0x802bdc64: DoCannonVoice__9KartSoundFv
+  0x802bdc94: DoDragVoice__9KartSoundFv
+  0x802bdcc4: DoGoalVoice__9KartSoundFv
+  0x802bde78: DoDriverGoalVoice__9KartSoundFv
+  0x802be02c: DoSpinVoice__9KartSoundFv
+  0x802be05c: DoFallVoice__9KartSoundFv
+  0x802be0a4: DoDashVoice__9KartSoundFv
+  0x802be0d4: DoGoldenDashVoice__9KartSoundFv
+  0x802be104: DoThrowVoice__9KartSoundFv
+  0x802be134: DoPutVoice__9KartSoundFv
+  0x802be164: DoChangeVoice__9KartSoundFv
+  0x802be194: DoWanwanVoice__9KartSoundFv
+  0x802be1c4: DoItmHitVoice__9KartSoundFv
+  0x802be1f4: DoPathVoice__9KartSoundFv
+  0x802be224: DoShootVoice__9KartSoundFv
+  0x802be26c: DoRollCrashVoice__9KartSoundFv
+  0x802be2b4: DoHeartVoice__9KartSoundFv
+  0x802be2e4: DoTandemVoice__9KartSoundFUc
+  0x802be310: DoDriverVoice__9KartSoundFUc
+  0x802be33c: DoAllVoice__9KartSoundFUc
+  
+  # KartTarget.cpp
+  0x802be490: Init__10KartTargetFv
+  0x802be4dc: DoSearchTarget__10KartTargetFi
+  0x802be898: DoSearchRescueTarget__10KartTargetFP7CLPoint
+
+  # KartChecker.cpp
+  0x802c6368: CheckOnlyTandemPartsClearKey__9KartCheckFi
+  0x802c6504: CheckPlayer__9KartCheckFv  
+  0x802c6564: CheckDraw__9KartCheckFUli
+  0x802c65b0: CheckIndication__9KartCheckFv
+
+  # KartDamage.cpp
+  0x802c66f8: ClrAllDamage__10KartDamageFv
+  0x802c6798: SetDriverEndDamageAnime__10KartDamageFv
 
   # KartStar.cpp
   0x802c796c: Init__8KartStarFi
@@ -3832,5 +4455,94 @@ global:
   # KartTire.cpp
   0x802c7c68: Init__8KartTireFi
 
+  # KartDemoCam.cpp
+  0x802ca1c4: Init__11KartDemoCamFP7KartCam
+  0x802ca204: DoCol__11KartDemoCamFv
+  0x802ca338: InitFixChaseCam__11KartDemoCamFv
+  0x802ca5bc: DoFixChaseCam__11KartDemoCamFv
+  0x802ca870: InitChaseCam__11KartDemoCamFv
+  0x802caa94: DoChaseCam__11KartDemoCamFv
+  0x802cae20: DoFixPathCam__11KartDemoCamFv
+  0x802cb0f4: DoChasePathCam__11KartDemoCamFv
+  0x802cb4c4: DoFixSplCam__11KartDemoCamFv
+  0x802cb6f4: DoChaseSplCam__11KartDemoCamFv
+  0x802cba30: InitFixPalaCam__11KartDemoCamFv
+  0x802cbdac: DoFixPalaCam__11KartDemoCamFv
+  0x802cc218: DoDemoPathCam__11KartDemoCamFv
+  0x802cc5bc: InitDemoGoalView__11KartDemoCamFv
+  0x802cca14: DemoGoalView__11KartDemoCamFv
+  0x802cce7c: MapView__11KartDemoCamFv
+  0x802cd298: ObjectView__11KartDemoCamFv
+  0x802cd55c: DemoInitID__11KartDemoCamFv
+  0x802cde58: InitID__11KartDemoCamFv
+  0x802ce140: DoDemoView__11KartDemoCamFv
+  0x802ce51c: DemoView__11KartDemoCamFv
+  0x802ce8e8: DoStartFixPathCam__11KartDemoCamFv
+  0x802cec2c: DoStartPathCam__11KartDemoCamFv
+  0x802cf098: DoStartLookPathCam__11KartDemoCamFv
+  0x802cf3c4: DoStartOnlyPathCam__11KartDemoCamFv
+  0x802cf758: DoStartFixCam__11KartDemoCamFv
+  0x802cf97c: DoStartChasePathCam__11KartDemoCamFv
+  0x802cfe58: VsLastCam__11KartDemoCamFv
+  0x802d0044: InitLastCam__11KartDemoCamFv
+  0x802d0404: LastCam__11KartDemoCamFv
+  0x802d0aa4: InitStartDemoCam__11KartDemoCamFv
+  0x802d0ea4: StartDemoCam__11KartDemoCamFv
+  0x802d0f98: SetLastDemo__11KartDemoCamFv
+  0x802d0ff4: SetNextID__11KartDemoCamFv
+  0x802d1078: DoExecution__11KartDemoCamFv
+  0x802d110c: GetStartID__11KartDemoCamFv
+  0x802d1170: InitStartID__11KartDemoCamFb
+  0x802d11a8: StartDemoView__11KartDemoCamFv
+  0x802d11c8: InitStartMapCam__11KartDemoCamFv
+  0x802d15c8: StartMapCam__11KartDemoCamFv
+  0x802d16a4: SetMapNextID__11KartDemoCamFv
+  0x802d170c: SetUpMapID__11KartDemoCamFv
+  0x802d1768: InitStaffView__11KartDemoCamFv
+  0x802d1d74: StaffView__11KartDemoCamFv
+  0x802d1f00: SetStaffNextID__11KartDemoCamFv
+  0x802d1f60: SetUpStaffID__11KartDemoCamFv
+
+  # KartFitParam.cpp
+  0x8036cb50: TireOpData
+  0x8036cf24: ArmOpData
+  0x8036d388: DumpOpData
+  0x8036d514: BodyOpData
+
+  # KartDisp.cpp
+  0x802d21c0: Init__8KartDispFi
+  0x802d21d8: DoShake__8KartDispFv
+  0x802d2490: MakeDispBodyPos__8KartDispFv
+  0x802d2760: MakeSusMatrix__8KartDispFi
+  0x802d3160: MatrixScale__8KartDispFPA4_ff
+  0x802d31d0: MakeTireDispMatrix__8KartDispFv
+  0x802d3624: MakeScaleMatrix__8KartDispFv
+  0x802d3c24: MakeKartDisp__8KartDispFv
+
+  # KartHandle.cpp
+  0x802d3fb4: Init__10KartHandleFi
+  0x802d3fdc: DoMotor__10KartHandleFQ212MotorManager9MotorType
+  0x802d410c: DoPowerMotor__10KartHandleFfUcUc
+  0x802d4250: StopMotor__10KartHandleFv
+  0x802d42bc: WatchFrontalCollisionForce__10KartHandleFv
+
   # KartApeendix.cpp
-  0x802d45bc: Init__12KartAppendixFi
+  0x802d45bc: Init__12KartAppendixFi
+
+  # KartPipe.cpp
+  0x802d46f0: Init__8KartPipeFi
+  0x802d4714: MakePipe__8KartPipeFv
+  0x802d4894: SetPose__8KartPipeFv
+  0x802d4d44: DoPipeCrl__8KartPipeFv
+  0x802d50c4: DoAfterPipeCrl__8KartPipeFv
+
+  # KartAnt.cpp
+  0x802d5248: Init__7KartAntFi
+  0x802d526c: SetPose__7KartAntFv
+  0x802d5600: DoAntCrl__7KartAntFv
+  0x802d5828: DoAfterAntCrl__7KartAntFv
+
+  # KartPerCam.cpp
+  0x802d7670: Init__10KartPerCamFi
+  0x802d76e8: InitFixPalaCam__10KartPerCamFv
+  0x802d79c4: InitID__10KartPerCamFv

include/Inagaki/CharacterSoundMgr.h

@@ -0,0 +1,30 @@
+#ifndef CHARACTERSOUNDMGR_H
+#define CHARACTERSOUNDMGR_H
+
+#include "types.h"
+#include "kartEnums.h"
+#include "Inagaki/SoundMgr.h"
+
+namespace GameAudio 
+{
+class CharacterSoundMgr : public SoundMgr<CharacterSoundMgr>
+{ // Autogenerated
+public:
+    CharacterSoundMgr(Vec *, JKRHeap *, unsigned char, ECharID); // 0x80118d1c
+    void init();                                                 // 0x80118e50
+    void loop();                                                 // 0x80118ea8
+    void frameWork(float, float);                                // 0x80118f48
+    void setVoice(unsigned char);                                // 0x80118fb0
+    void setSe(unsigned long);                                   // 0x801195e0
+    void isSpeak();                                              // 0x80119774
+    void setVoicePitch(bool);                                    // 0x80119800
+    void getKartSound();                                         // 0x80119980
+    void checkEcho();                                            // 0x801199d8
+    // Inline/Unused
+    // void JASGlobalInstance<JAWSpeAna>::sInstance;
+    // void JASGlobalInstance<JAWSeqEdit>::sInstance;
+    // Inline
+    virtual ~CharacterSoundMgr(); // 0x80118df0
+};                                           // class CharacterSoundMgr
+}
+#endif

include/Inagaki/GameAudioMain.h

@@ -4,14 +4,20 @@
 #include <JSystem/JKernel/JKRHeap.h>
 #include <JSystem/JAudio/JAUSectionHeap.h>
 
+#include "kartEnums.h"
 #include "Inagaki/GameAudioFxConfig.h"
 #include "Inagaki/GameSoundTable.h"
 #include "types.h"
 
+class CrsArea;
+
 namespace GameAudio
 {
     class CustomMgr;
-    class CameraMgr;
+    class CameraMgr {
+    public:
+        void setCameraInfo(u32, Vec, Mtx,  CrsArea *);
+    };
 
     class Main
     {
@@ -45,7 +51,7 @@ namespace GameAudio
         void prepareStreamBgm(u32);
         void startStreamBgm(u32);
         void stopStreamBgm(u32);
-        void getPlayingStreamID();
+        u32 getPlayingStreamID();
         void setInvincibleBgm(u8, u8);
         void clearInvincibleBgm(u8, u8);
         void startInvincibleBgm(u8, bool);
@@ -86,6 +92,13 @@ namespace GameAudio
         // void setSeVolume(f32);
         // void checkReset();
 
+
+
+        CameraMgr *getCamera() {
+#line 157
+            JUT_ASSERT_MSG(mCamera, "GameAudioMain : カメラが初期化されていません。\n");
+            return mCamera;
+        }
         // static sJAudio; // TODO: type
         static Main *getAudio() { return msBasic; };
 
@@ -109,10 +122,41 @@ namespace GameAudio
 
     namespace Parameters
     {
-        extern u8 getDemoMode();
+        void setPlayerMode(u8);
-        extern void setDemoMode(u8);
+        void setRaceMode(u8);
+        void setDemoMode(u8);
+        void setKillSwAllObject(bool);
+        void setRaceCourse(ECourseID);
+        void setKartType(u8, EKartWeight);
+        void setNetworkMode(u8, u8);
+        void setChrType(u8, EKartID);
+        void setChibiFlag(u8, bool);
+        void setMirrorSwitch(bool);
+        ERaceMode getRaceMode();
+        u8 getPlayerMode();
+        int getEngineType(u8);
+        int getCharacterType(u8);
+        int getRaceCourse();
+        int getChibiPitch(u32);
+        int getNetworkCubes();
+        int getChibiFlag(u8);
+        u8 getDemoMode();
+        int getMirrorSwitch();
+        extern f32 sChibiPitch[4];
+        extern u8 sDemoMode;
+        extern u8 sMirrorSwitch;
+        extern u8 sKartType[8];
+        extern u8 sChrType[8];
+        extern u8 sEngType[8];
+        extern u8 sKartChibiFlag[8];
+        extern u8 sPlayerMode;
+        extern u8 sRaceMode;
+        extern u8 sNetworkCubes;
+        extern u8 sNetworkNumber;
+        extern ECourseID sRaceCourse;
     }
 
+    extern int GoalFanfareDelayFrame;
     extern int ParadeBgmMuteFrame;
     extern f32 ParadeBgmMuteVolume;
 }

include/Inagaki/KartSoundMgr.h

@@ -3,17 +3,58 @@
 
 #include "types.h"
 #include "Inagaki/SoundMgr.h"
+#include "Kaneshige/Course/CrsGround.h"
+#include "Kaneshige/Course/CrsArea.h"
 
 namespace GameAudio
 {
-    class KartSoundMgr : SoundMgr<KartSoundMgr>
+    class KartSoundMgr : public SoundMgr<KartSoundMgr>
     {
     public:
-        KartSoundMgr();
+        KartSoundMgr(Vec *, JKRHeap *, u8, u8);                           // 0x80123118
-        virtual void dispose();
+        void startSoundHandleNumber(u8, u32, u32);                        // 0x801233fc
-        virtual ~KartSoundMgr();
+        virtual void dispose();                                           // 0x801236d0
-        virtual void init();
+        virtual void init();                                              // 0x80123708
-        virtual void setSe(u32 id);
+        void changeDriver(bool);                                          // 0x80123ad4
+        void frameWork(u8 rank);                                          // 0x80123ad8
+        void checkAfterGoalVolume();                                      // 0x80123c50
+        void setWaterDepth(u8, f32);                                      // 0x80123ee4
+        void setSlip(u8, u8, u8, f32);                                    // 0x80123ef4
+        void setConductStatus(f32, f32, bool, bool, bool, u8, CrsArea *); // 0x80124400
+        void setWaterCutoffPort(unsigned short);                          // 0x8012485c
+        void countGoalKart();                                             // 0x80124930
+        void setConductLocomotiveAccel();                                 // 0x8012495c
+        void setConductLocomotiveSpeed(bool);                             // 0x80124d9c
+        void setConductPressed();                                         // 0x80125194
+        void setConductSignal();                                          // 0x80125490
+        void setConductOutOfCourse(u8);                                   // 0x80125b04
+        void setConductTrouble(f32, u8);                                  // 0x80125f60
+        void setConductRace(bool);                                        // 0x801263cc
+        void setConductAfterGoal(bool);                                   // 0x80127188
+        void setCrushSe(CrsGround::EMat, f32);                            // 0x801271a8
+        void setCrushSe(u32, f32);                                        // 0x801272e4
+        void setBrakeSe(u32);                                             // 0x80127474
+        void setDashSe(u32);                                              // 0x8012763c
+        void setMiniturboSe(u32);                                         // 0x801276e4
+        void setJumpUpSe(u32);                                            // 0x80127770
+        void setBoundSe(f32);                                             // 0x801277dc
+        void setWheelSpinSe();                                            // 0x8012798c
+        void setSpinSe();                                                 // 0x80127aa4
+        void setSpinTurnSe();                                             // 0x80127bb4
+        virtual void setSe(u32);                                          // 0x80127ccc
+        void setChibiPitch(JAISoundHandle *);                             // 0x80127ec8
+        void adjustEngine();                                              // 0x80127fb8
+        void crushRenzokuTaisaku();                                       // 0x80128140
+        void slipParamSet();                                              // 0x8012816c
+        void checkEcho();                                                 // 0x801288f8
+        void setInvincibleBgm(u8);                                        // 0x80128aac
+        void clearInvincibleBgm(u8);                                      // 0x80128c30
+        void setChibiFlag(bool, bool);                                    // 0x80128e98
+
+        virtual ~KartSoundMgr() {}
+
+    private:
+        u8 _30[0x134 - 0x30]; // TODO: place in correct struct
     };
 }
 

include/Inagaki/SoundMgr.h

@@ -11,8 +11,9 @@
 namespace GameAudio
 {
     template <typename T>
-    class SoundMgr : JAUDopplerSoundObject, JKRDisposer
+    class SoundMgr : public JAUDopplerSoundObject, public JKRDisposer
     {
+    public:
         SoundMgr(Vec *, JKRHeap *, u8);
         virtual ~SoundMgr();
         virtual void init();

include/JSystem/J2D/J2DGrafContext.h

@@ -53,6 +53,13 @@ struct J2DGrafContext
 	// inlined
 	void line(JGeometry::TVec2f, JGeometry::TVec2f);
 
+	void scissor(f32 x, f32 y, f32 w, f32 h) {
+		 JGeometry::TBox2f box(x, y, x + w, y + h);
+		 scissor(box);
+	}
+
+	JGeometry::TBox2f &getBounds() { return mBounds; }
+
 	// _00 VTBL
 	JGeometry::TBox2f mBounds;		  // _04
 	JGeometry::TBox2f mScissorBounds; // _14
@@ -71,6 +78,8 @@ struct J2DGrafContext
 
 struct J2DPerspGraph : public J2DGrafContext
 {
+	J2DPerspGraph(f32 x, f32 y, f32 w, f32 h, f32 fovY, f32 near, f32 far);
+
 	J2DPerspGraph();
 
 	virtual ~J2DPerspGraph() {}										  // _08 (weak)
@@ -85,15 +94,15 @@ struct J2DPerspGraph : public J2DGrafContext
 	// _00 		= VTBL
 	// _00-_BC	= J2DGrafContext
 	f32 mFovY; // _BC
-	f32 _C0;   // _C0
+	f32 mNear; // _C0
-	f32 _C4;   // _C4
+	f32 mFar;  // _C4
 	f32 _C8;   // _C8
 };
 
 struct J2DOrthoGraph : public J2DGrafContext
 {
 	J2DOrthoGraph();
-	J2DOrthoGraph(f32, f32, f32, f32, f32, f32);
+	J2DOrthoGraph(f32 l, f32 t, f32 r, f32 b, f32 n, f32 f);
 
 	virtual ~J2DOrthoGraph(){};										   // _08 (weak)
 	virtual void setPort();											   // _14
@@ -106,12 +115,14 @@ struct J2DOrthoGraph : public J2DGrafContext
 	f32 getWidthPower() const { return mBounds.getWidth() / mOrtho.getWidth(); }
 	f32 getHeightPower() const { return mBounds.getHeight() / mOrtho.getHeight(); }
 
-	void setOrtho(f32 param_0, f32 param_1, f32 param_2, f32 param_3, f32 param_4, f32 param_5)
+	void setOrtho(f32 l, f32 t, f32 w, f32 h, f32 n, f32 f)
 	{
-		JGeometry::TBox2<f32> ortho(param_0, param_1, param_0 + param_2, param_1 + param_3);
+		JGeometry::TBox2<f32> ortho(l, t, l + w, t + h);
-		setOrtho(ortho, param_4, param_5);
+		setOrtho(ortho, n, f);
 	}
 
+	const JGeometry::TBox2f &getOrtho() const { return mOrtho; }
+
 	// _00 		= VTBL
 	// _00-_BC	= J2DGrafContext
 	JGeometry::TBox2f mOrtho; // _BC

include/JSystem/J2D/J2DPane.h

@@ -564,6 +564,16 @@ struct J2DPicture : public J2DPane
     u8 getTlutID(const ResTIMG *, unsigned char);
     void operator=(const J2DPicture &);
 
+    void setCornerColor(JUtility::TColor color) {  setCornerColor(color, color, color, color); }
+
+    void setCornerColor(JUtility::TColor color0, JUtility::TColor color1, JUtility::TColor color2, JUtility::TColor color3)
+    {
+        mCornerColors.mColor0 = color0;
+        mCornerColors.mColor1 = color1;
+        mCornerColors.mColor2 = color2;
+        mCornerColors.mColor3 = color3;
+    }
+
     inline void setCornerColor(TCornerColor colors)
     {
         mCornerColors.mColor0.set(colors.mColor0);

include/JSystem/J3D/J3DModel.h

@@ -195,6 +195,7 @@ struct J3DModel
 	void calcBumpMtx();
 	void calcBBoardMtx();
 	void prepareShapePackets();
+	void setDeformData(J3DDeformData *, u32);
 
 	inline J3DModelData *getModelData() { return mModelData; }
 
@@ -205,7 +206,7 @@ struct J3DModel
 	bool isCpuSkinningOn() const { return (mFlags & J3DMODEL_Unk3) && (mFlags & J3DMODEL_Unk4); }
 
 	Mtx &getBaseTRMtx() { return mPosMtx; }
-	void i_setBaseTRMtx(Mtx m) { PSMTXCopy(m, mPosMtx); }
+	void setBaseTRMtx(Mtx m) { PSMTXCopy(m, mPosMtx); }
 	u32 getMtxCalcMode() const { return mFlags & J3DMODEL_Unk3; }
 	J3DVertexBuffer *getVertexBuffer() const { return (J3DVertexBuffer *)&mVertexBuffer; }
 	J3DMatPacket *getMatPacket(u16 idx) const { return &mMatPackets[idx]; }

include/JSystem/J3D/J3DSkinDeform.h

@@ -5,28 +5,42 @@
 #include "JSystem/J3D/J3DCluster.h"
 
 struct J3DAnmCluster;
+class J3DClusterVertex;
 
 enum J3DSkinDeformFlags {
 	J3DSKIN_Unk1 = 0x1,
 	J3DSKIN_Unk2 = 0x2,
 };
 
-struct J3DDeformData {
+class J3DDeformData
+{
+public:
 	J3DDeformData();
+	void offAllFlag(u32);
+	void deform(J3DVertexBuffer *);
+	void deform(J3DModel *);
+	void setAnm(J3DAnmCluster *);
 
-	u16 mClusterNum;              // _00
+	J3DCluster *getClusterPointer(u16 index) { return &mClusterPointer[index]; }
-	u16 mClusterKeyNum;           // _02
+	u16 getClusterNum() const { return mClusterNum; }
-	u16 _04;                      // _04
+	u16 getClusterKeyNum() const { return mClusterKeyNum; }
-	J3DCluster** mClusters;       // _08
+	J3DClusterKey *getClusterKeyPointer(u16 i) { return &mClusterKeyPointer[i]; }
-	J3DClusterKey** mClusterKeys; // _0C
+	f32 *getVtxPos() { return mVtxPos; }
-	int _10;                      // _10
+	f32 *getVtxNrm() { return mVtxNrm; }
-	u16 _14;                      // _14
+
-	u16 _16;                      // _16
+	u16 mClusterNum;				   // 00
-	void* mVtxPos;                // _18, check type
+	u16 mClusterKeyNum;				   // 02
-	void* mVtxNorm;               // _1C, check type
+	u16 mClusterVertexNum;			   // 04
-	int _20;                      // _20
+	J3DCluster *mClusterPointer;	   // 08
-	int _24;                      // _24
+	J3DClusterKey *mClusterKeyPointer; // 0c
-};
+	J3DClusterVertex *mClusterVertex;  // 10
+	u16 mVtxPosNum;					   // 14
+	u16 mVtxNrmNum;					   // 16
+	f32 *mVtxPos;					   // 18
+	f32 *mVtxNrm;					   // 1C
+	JUTNameTab *mClusterName;		   // 20
+	JUTNameTab *mClusterKeyName;	   // 24
+}; // Size: 0x28
 
 struct J3DDeformer {
 	J3DDeformer(J3DDeformData*);
@@ -44,7 +58,7 @@ struct J3DDeformer {
 	u32 mFlags;                 // _10
 };
 
-struct J3DSkinDeform {
+/*struct J3DSkinDeform {
 	J3DSkinDeform();
 
 	virtual void deform(J3DVertexBuffer*, J3DMtxBuffer*); // _08
@@ -58,10 +72,10 @@ struct J3DSkinDeform {
 
 	// _00 VTBL
 	void* mPosData;      // _04
-	BitFlag<u32> _08;    // _08 /* bitfield of some sort */
+	//BitFlag<u32> _08;    // _08 // bitfield of some sort
 	unknown _0C;         // _0C
 	unknown _10;         // _10
 	BitFlag<u32> mFlags; // _14
-};
+};*/
 
 #endif

include/JSystem/JAudio/System/JASMemPool.h

@@ -7,6 +7,7 @@
 struct JASGenericMemPool
 {
     JASGenericMemPool();
+    ~JASGenericMemPool();
     void free(void *, u32);
 
     void *mRunner;
@@ -19,7 +20,7 @@ template <typename T>
 struct JASMemPool : public JASGenericMemPool
 {
     JASMemPool<T>() : JASGenericMemPool() {}
-    ~JASMemPool<T>();
+    ~JASMemPool<T>() {}
 };
 
 template <u32 ChunkSize, typename T>
@@ -164,6 +165,7 @@ public:
 template <typename T>
 struct JASPoolAllocObject
 {
+    ~JASPoolAllocObject();
     static void operator delete(void *mem, u32 n)
     {
         BOOL inter = OSDisableInterrupts();
@@ -177,7 +179,7 @@ template <typename T>
 struct JASMemPool_MultiThreaded : public JASGenericMemPool
 {
     JASMemPool_MultiThreaded<T>() : JASGenericMemPool() { }
-    ~JASMemPool_MultiThreaded<T>();
+    ~JASMemPool_MultiThreaded<T>() {}
 };
 
 

include/JSystem/JFramework/JFWDisplay.h

@@ -87,11 +87,11 @@ public:
 
     static JFWDisplay *getManager() { return sManager; }
 
-    u32 getEfbHeight() const {
+    int getEfbHeight() const {
         return JUTVideo::getManager()->getEfbHeight();
     }
 
-    u32 getEfbWidth() const {
+    int getEfbWidth() const {
         return JUTVideo::getManager()->getFbWidth();
     }
 
@@ -124,6 +124,15 @@ public:
         return mClearColor;
     }
 
+    void setClearColor(u8 r, u8 g, u8 b, u8 a) {
+        mClearColor.set(r, g, b, a);
+    }
+
+    void setClearColor(JUtility::TColor color)
+    {
+        mClearColor.set(color);
+    }
+
     void setFBAlpha(bool enable) {
         mEnableAlpha = enable;
     }
@@ -133,6 +142,8 @@ public:
         return mEnableAlpha;
     }
 
+    bool isWaiting() { return mIsWaiting; }
+
     static JFWDisplay *sManager; // 0x80415718
 
 private:
@@ -152,7 +163,7 @@ private:
     /* 0x34 */ u32 _34;
     /* 0x38 */ int _38;
     /* 0x3C */ int _3C;
-    /* 0x40 */ bool _40;
+    /* 0x40 */ bool mIsWaiting;
     /* 0x44 */ JFWDisplayUnkFunc _44;
     /* 0x48 */ s16 _48;
     /* 0x4A */ u8 _4a;

include/JSystem/JGeometry/Box.h

@@ -51,7 +51,7 @@ struct TBox2 : TBox<TVec2<T> > {
     TBox2() {}
     TBox2(const TVec2<f32>& i, const TVec2<f32> f) { set(i, f); }
     TBox2(f32 x0, f32 y0, f32 x1, f32 y1) { set(x0, y0, x1, y1); }
-	TBox2(f32 x0, f32 y0, TVec2<f32>& f) { set(x0, y0, x0 + f.x, y0 + f.y);	}
+	TBox2(f32 x0, f32 y0, const TVec2<f32>& f) { set(x0, y0, x0 + f.x, y0 + f.y);	}
 	TBox2(f32 val)
 	{
 		f.y = val;
@@ -81,8 +81,6 @@ struct TBox2 : TBox<TVec2<T> > {
 };
 
     // clang-format on
-
-
     template <typename T>
     struct TBox3
     {

include/JSystem/JGeometry/Util.h

@@ -10,7 +10,7 @@ namespace JGeometry {
     class TUtil
     {
     public:
-        static f32 abs(f32 x) { return __fabs(x); }
+        static f32 abs(f32 x) { return __fabsf(x); }
         static f32 atan2(f32 y, f32 x) { return JMAAtan2Radian(y, x); }
         static const f32 epsilon() { return 32.0f * FLT_EPSILON; }
 

include/JSystem/JGeometry/Vec.h

@@ -263,12 +263,13 @@ namespace JGeometry {
         f32 dotZX(const TVec3 &operand) const { return x * operand.x + z * operand.z; }
         f32 length() const { return PSVECMag((Vec *)this); }
 
-        f32 angle(TVec3 vec2)
+        f32 angle(const TVec3 &vec2) const
         {
             TVec3 crossp;
             crossp.cross(*this, vec2);
-
+            f32 len = crossp.length();
-            f32 ang = TUtilf::atan2(crossp.length(), dot(vec2));
+            f32 dp = dot(vec2);
+            f32 ang = TUtilf::atan2(len, dp);
 
             return TUtilf::abs(ang);
         }

include/JSystem/JORReflexible.h

@@ -1,8 +1,9 @@
 #ifndef JOR_REFLEXIBLE_H
 #define JOR_REFLEXIBLE_H
 
-class JORReflexible {
+class JORReflexible
-    
+{
+
 };
 
 #endif

include/JSystem/JUtility/JUTException.h

@@ -11,7 +11,7 @@
 struct JUTConsole;
 struct JUTDirectPrint;
 
-typedef void (*JUTErrorHandler)(OSError error, OSContext *context, u32 p3, u32 p4);
+typedef void (*JUTErrorHandler)(OSError error, OSContext *context, u32 dsisr, u32 dar);
 
 enum ExPrintFlags
 {

include/JSystem/JUtility/JUTTexture.h

@@ -40,6 +40,13 @@ struct JUTTexture : public GXTexObj
         mFlags &= TEXFLAG_Unk2;
     }
 
+    inline JUTTexture(const ResTIMG *timg, u8 lutid)
+    {
+        mEmbPalette = nullptr;
+        storeTIMG(timg, lutid);
+        setCaptureFlag(false);
+    }
+
     ~JUTTexture();
 
     void attachPalette(JUTPalette *);
@@ -54,22 +61,21 @@ struct JUTTexture : public GXTexObj
     void storeTIMG(const ResTIMG *, JUTPalette *);
     void storeTIMG(const ResTIMG *, JUTPalette *, _GXTlut);
 
-    /** @fabricated */
+    ResTIMG *getTexInfo() const { return mTexInfo; }
-    inline int getSizeX() const { return mTexInfo->mSizeX; }
+    void setCaptureFlag(bool flag) { mFlags = mFlags & TEXFLAG_Unk2 | flag; }
-    /** @fabricated */
-    inline int getSizeY() const { return mTexInfo->mSizeY; }
-
-    const ResTIMG *getTexInfo() const { return mTexInfo; }
-    void setCaptureFlag(bool flag) { mFlags &= TEXFLAG_Unk2 | flag; }
     u8 getCaptureFlag() const { return mFlags & TEXFLAG_Unk1; }
     int getEmbPaletteDelFlag() const { return (mFlags & TEXFLAG_Unk2) != 0; }
     void setEmbPaletteDelFlag(bool del) {
-        mFlags &= 1 | del << 1;
+        mFlags &= TEXFLAG_Unk1 | del << 1;
     }
     u8 getTlutName() const { return mTlut; }
 
     void setTlutName(u8 tlut) { mTlut = tlut; }
 
+    GXTexFmt getFormat() const {return (GXTexFmt)mTexInfo->mTextureFormat; }
+    int getWidth() const { return mTexInfo->mSizeX; }
+    int getHeight() const { return mTexInfo->mSizeY; }
+
     ResTIMG *mTexInfo;          // _20
     void *mTexData;             // _24
     JUTPalette *mEmbPalette;    // _28

include/JSystem/JUtility/TColor.h

@@ -20,9 +20,9 @@ namespace JUtility
 
         TColor(GXColor color) { set(color); }
 
-        TColor &operator=(const TColor &other)
+        TColor &operator=(const TColor &other) // is this actually needed?
         {
-            ((GXColor *)this)->operator=(other);
+            *((GXColor *)&r) = (other);
             return *this;
         }
 
@@ -69,8 +69,17 @@ namespace JUtility
             a = other.a;
         }
 
+        // fabricated. but helped solve regswaps in a function
+        void setRGBA(const TColor &RGB, u8 _a)
+        {
+            setRGB(RGB);
+            a = _a;
+        }
+
         // _00 = GXColor (_00 = r, _01 = g, _02 = b, _03 = a)
     };
 } // namespace JUtility
 
+typedef JUtility::TColor JUTColor;
+
 #endif

include/Kameda/Demo2D.h

@@ -0,0 +1,28 @@
+#ifndef DEMO2D_H
+#define DEMO2D_H
+
+#include "Kaneshige/HioMgr.h"
+
+class Demo2D
+{ // Autogenerated
+    // Global
+    Demo2D(JKRHeap *); // 0x8018313c
+    void init();       // 0x8018325c
+    void draw();       // 0x801832d0
+    void calc();       // 0x80183344
+
+    class Demo2DParam : public JORReflexible
+    {
+        // Inline/Unused
+        Demo2DParam();
+        virtual ~Demo2DParam() {}
+    };
+
+    class Demo2DHioNode 
+    {
+    };
+
+    // Inline/Unused
+    ~Demo2D();
+};     // class Demo2D
+#endif // DEMO2D_H

include/Kameda/Fade.h

@@ -0,0 +1,24 @@
+#ifndef _FADE_H
+#define _FADE_H
+
+#include <JSystem/JKernel/JKRHeap.h>
+#include <JSystem/JUtility/TColor.h>
+
+#include "types.h"
+
+// Considering this is similar to Mario.h, the might be some sort of inheritance going on?
+
+class Fade
+{ // Autogenerated
+public:
+    Fade(JKRHeap *);                       // 0x8013b318
+    void init();                           // 0x8013b76c
+    void draw(int, f32, JUtility::TColor); // 0x8013b770
+    // Inline/Unused
+    ~Fade();
+
+private:
+    u8 _0[0x34];
+}; // class Fade
+
+#endif

include/Kameda/J2DManager.h

@@ -2,33 +2,89 @@
 #define J2DMANAGER_H
 
 #include "JSystem/JKernel/JKRHeap.h"
+
+#include "Kameda/Demo2D.h"
+#include "Kameda/Race2D.h"
+#include "Kameda/WipeManager.h"
+
 #include "types.h"
 
+// TODO: implement these
+class PreRace2D;
+class Go3212D;
+class Go2D;
+class Goal2D;
+class LANNum2D;
+class LANResult2D;
+
 class J2DManager
 {
 public:
-    J2DManager(JKRHeap *);
+    J2DManager(JKRHeap *);          // 0x8013156c
-    void calc();
+    void reset();                   // 0x801317cc
-    void calcParticle();
+    void draw();                    // 0x801319bc
-    void reset();
+    void calc();                    // 0x80131a94
-    void startLANNumAnm();
+    void calcParticle();            // 0x80131c10
+    static int getKart2Status(int); // 0x80131c68
+    static int getStatus2Kart(int); // 0x80131d00
+    void setStatus2Kart(int, int);  // 0x80131d98
+    void setUsisi(int, ECharID);    // 0x80131f40
+    void startPreRace();            // 0x80132034
+    void getPreRaceStatus();        // 0x80132058
+    int getPreRaceWipeType();       // 0x80132064
+    void setRace2DDrawFlag(bool);   // 0x80132070
+    void hideRace2D();              // 0x80132084
+    void getHideFrameRace2D();      // 0x80132094
+    bool isHideRace2D();            // 0x801320a0
+    bool isRaceEnd();               // 0x801320c0
+    bool isGoalAnmEnd(int);         // 0x80132120
+    void getGoalAnmFrame(int);      // 0x801321b0
+    bool isAlarm(int);              // 0x801321c4
+    void startLANNumAnm();          // 0x801321e8
+    void startLANNumResultAnm();    // 0x8013220c
+    void startLANResultAnm(int);    // 0x80132230
+    void startBombDemo();           // 0x80132254
+    void endBombDemo();             // 0x80132278
+    bool isLANDemo();               // 0x80132288
+    bool isStartGo321();            // 0x801322b4
 
-    void setStatus2Kart(int, int);
+    // Inline/Unused
+    ~J2DManager();
+    bool isMiniGameAnmEnd(int);
 
-    void setDrawFlag(bool flag)
+    void startWinnerAnm(int idx) { mWinnerAnmFlag[idx] = true; }
-    {
+    void startLoserAnm(int idx) { mLoserAnmFlag[idx] = true; }
-        mDrawFlag = flag;
+    void setDrawFlag(bool flag) { mDrawFlag = flag; }
-    }
-    static J2DManager *getManager()
-    {
-        return mThis;
-    }
 
-    static J2DManager *mThis;
+    JKRArchive *getArchive() const { return mArchive; }
 
-    u8 _00[0x8];
+    static J2DManager *getManager() { return mThis; }
+
+    static const char *mKartNumberName[8]; // 0x80394378
+    static int mKart2Status[8];            // 0x803fb9a0
+    static int mStatus2Kart[8];            // 0x803fba10
+    static J2DManager *mThis;              // 0x80416288
+    static bool mNetFlag;                  // 0x8041628c
+
+    JKRArchive *mArchive;
+    J2DOrthoGraph *mOrtho;
     bool mDrawFlag;
-    u8 _0A[0x48 - 0x9];
+    bool mInit;
+    int mAnmFrame;
+    bool mWinnerAnmFlag[8];
+    bool mLoserAnmFlag[8];
+    int mDuration;
+    Demo2D *mDemo2D;
+    PreRace2D *mPreRace;
+    Go3212D *mGo321;
+    Go2D *mGo;
+    Race2D *mRace;
+    Goal2D *mGoal;
+    LANNum2D *mLANNumAnm;
+    LANResult2D *mLANResultAnm;
+    WipeManager *mWipeMgr;
 }; // Size 0x48;
 
+inline J2DManager *GETJ2DManager() { return J2DManager::getManager(); }
+
 #endif

include/Kameda/Mario.h

@@ -0,0 +1,23 @@
+#ifndef _MARIO_H
+#define _MARIO_H
+
+#include <JSystem/JKernel/JKRHeap.h>
+#include <JSystem/JUtility/TColor.h>
+
+#include "types.h"
+
+class Mario
+{ // Autogenerated
+public:
+    Mario(JKRHeap *heap);                   // 0x8016eed0
+    void init();                            // 0x8016f4cc
+    void draw(f32, JUtility::TColor color); // 0x8016f4d0
+    // Inline/Unused
+    ~Mario();
+    void draw(int, f32, JUtility::TColor color);
+
+private:
+    u8 _0[0x30];
+}; // class Mario
+
+#endif

include/Kameda/MotorManager.h

@@ -11,7 +11,29 @@ public:
     // Global
     enum MotorType
     {
-        // TODO
+        MotorType_0,
+        MotorType_1,
+        MotorType_2,
+        MotorType_3,
+        MotorType_4,
+        MotorType_5,
+        MotorType_6,
+        MotorType_7,
+        MotorType_8,
+        MotorType_9,
+        MotorType_10,
+        MotorType_11,
+        MotorType_12,
+        MotorType_13,
+        MotorType_14,
+        MotorType_15,
+        MotorType_16,
+        MotorType_17,
+        MotorType_18,
+        MotorType_19,
+        MotorType_20,
+        MotorType_21,
+        MotorType_22
     };
 
     MotorManager(JKRHeap *);                // 0x80130e58

include/Kameda/PauseManager.h

@@ -6,7 +6,8 @@
 
 class PauseManager {
 public:
-    PauseManager(JKRHeap *);    
+    PauseManager(JKRHeap *);
+    static bool tstPause(); // 0x80135288;
     void setExecFlag(bool flag) {
         mExecFlag = flag;
     }

include/Kameda/SceneMenu.h

@@ -0,0 +1,113 @@
+#ifndef SCENEMENU_H
+#define SCENEMENU_H
+
+#include "Kameda/Scene.h"
+
+class SceneMenu : public Scene
+{
+public:
+    struct BckData
+    {
+    };
+
+    struct BrkData
+    {
+    };
+
+    enum Cursor
+    {
+
+    };
+
+    SceneMenu(JKRArchive *, JKRHeap *);  // 0x8016f78c
+    void reset();                        // 0x801725b8
+    void init();                         // 0x80172e6c
+    ~SceneMenu();                        // 0x80173908
+    void draw();                         // 0x80173960
+    void calc();                         // 0x80173f08
+    void calcModeAnm();                  // 0x801750b0
+    void caleEngine(BckData *);          // 0x801751ac
+    void calcEngineMoji(BckData *);      // 0x801751ec
+    void calcEnginePic(BckData *);       // 0x801752f0
+    void calcEngineBrkAnm(BrkData *);    // 0x801753f4
+    void calcModeOrder();                // 0x80175434
+    void entry_init();                   // 0x801755b4
+    void entry();                        // 0x80175970
+    void entry_end();                    // 0x80176268
+    void vs_init();                      // 0x801762ec
+    void vs();                           // 0x80176c5c
+    void vs_end();                       // 0x801780bc
+    void mode_init();                    // 0x8017836c
+    void mode();                         // 0x801797d0
+    void mode_end();                     // 0x8017b78c
+    void battle_init();                  // 0x8017c834
+    void battle();                       // 0x8017cd14
+    void battle_end();                   // 0x8017d39c
+    void character_init();               // 0x8017d4a0
+    void character();                    // 0x8017e3b8
+    void character_end();                // 0x8017e86c
+    void nextScene();                    // 0x8017ebf4
+    void selectA(int);                   // 0x8017ece8
+    void selectB(int);                   // 0x8017eefc
+    void selectUp(int);                  // 0x8017f17c
+    void selectDown(int);                // 0x8017f28c
+    void selectLeft(int);                // 0x8017f39c
+    void selectRight(int);               // 0x8017f4a0
+    void selectZ(int);                   // 0x8017f5a4
+    void isSelectAnm(int);               // 0x8017f6f0
+    void moveCursor(int, Cursor);        // 0x8017f754
+    void isRndRoulette();                // 0x8017fb78
+    void rndRoulette();                  // 0x8017fc50
+    void rndSelect();                    // 0x8017fce0
+    void setCharacterFlag();             // 0x8017fe00
+    void getKart(int, int);              // 0x8017ff04
+    void changeKart(int, int, int, int); // 0x80180060
+    void characterAnm();                 // 0x8018029c
+    void characterOkWaitAnm();           // 0x80180ef8
+    void setChar1Plus();                 // 0x80181450
+    void setRaceData();                  // 0x801817f0
+    void setCharSelFlag();               // 0x801828f8
+    void useCharSel(int, int);           // 0x80182954
+    void getCharSel(int &, int &);       // 0x8018296c
+    void getRndCharSel(int &, int &);    // 0x80182d14
+    void changeText();                   // 0x80182e8c
+private:
+    static int mCharVoice;             // 0x80371338
+    static int mCharGoVoice;           // 0x80371388
+    static int mCharIndex;             // 0x803713d8
+    static int mKartIndex;             // 0x803715d4
+    static int mKartPerf;              // 0x80371628
+    static int mLevelID;               // 0x80371668
+    static int mPlayerIconBckTag;      // 0x80371678
+    static int mHowManyDriversBckTag;  // 0x803717b0
+    static int mHowManyDriversBrkTag;  // 0x80371818
+    static int mSingleTagSelectBckTag; // 0x803718c8
+    static int mSingleTagSelectBtkTag; // 0x80371a20
+    static int mSingleTagSelectBrkTag; // 0x80371ae0
+    static int mSingleTagSelectBpkTag; // 0x80371d50
+    static int mModeBckTag;            // 0x80371d88
+    static int mModeBtkTag;            // 0x80371fe0
+    static int mModeBrkTag;            // 0x803720b0
+    static int mModeBpkTag;            // 0x803721a0
+    static int mBattleBckTag;          // 0x803722a0
+    static int mBattleBrkTag;          // 0x80372318
+    static int mCharCCBckTag;          // 0x80372330
+    static int mCharCCBrkTag;          // 0x80372340
+    static int mCharCCBpkTag;          // 0x80372360
+    static int mChar1BckTag;           // 0x803723f0
+    static int mChar1PlusBckTag;       // 0x80372438
+    static int mChar1PlusBrkTag;       // 0x803724d0
+    static int mChar2BckTag;           // 0x803724e0
+    static int mChar2BrkTag;           // 0x80372580
+    static int mChar3BckTag;           // 0x803725a8
+    static int mChar3BrkTag;           // 0x80372680
+    static int mChar4BckTag;           // 0x803726c0
+    static int mCharName;              // 0x80395648
+    static int mPlayerIconPlayerName;  // 0x80395698
+    static int mPowerMojiName;         // 0x803956a8
+    static int mPowerPicName;          // 0x803956b8
+    static int mBattleName;            // 0x803956c8
+    static int mCharCCName;            // 0x803956d4
+}; // Size: 0x22c0
+
+#endif

include/Kameda/SequenceInfo.h

@@ -4,14 +4,16 @@
 #include "Kaneshige/KartInfo.h"
 #include "types.h"
 
-struct DemoKart { // most likely a placeholder struct
+struct DemoKart
+{ // most likely a placeholder struct
     ECharID char1;
     ECharID char2;
     EKartID kart;
 };
 
-class SequenceInfo {
+class SequenceInfo
-    public:
+{
+public:
     void rndDemo(u32);
     void getDemoKart(int no, ECharID &charID1, ECharID &charID2, EKartID &kartID)
     {
@@ -23,8 +25,12 @@ class SequenceInfo {
         kartID = mDemoKart[no].kart;
     }
 
-    private:
+    void setGhostFlag(u8 flags) { mGhostFlags = flags; }
-    u8 _0[0x36c];
+
+private:
+    u8 _0[0x34];
+    u8 mGhostFlags;
+    u8 _35[0x36c - 0x35];
     DemoKart mDemoKart[8];
     u8 _0x390[0x44c - 0x390];
 };

include/Kameda/Task.h

@@ -0,0 +1,47 @@
+#ifndef TASK_H
+#define TASK_H
+
+#include "types.h"
+
+class Task {
+public:
+    typedef void (*TaskFunc)();
+
+    struct TCB
+    {        
+        TaskFunc mFunc;
+        TCB *mPrev;
+        TCB *mNext;
+        u32 _c;
+        u32 _10;
+        u32 _14;
+        u16 mStackSize;
+        bool mRequestKill;
+        int mExecIdx; // The amount of times a function has to be executed before it gets killed?
+        int _20;
+        s16 _24; // pre
+        s16 _26; // main
+        s16 _28; // after
+        u8 _2a[0x3c - 0x2a]; // unknown
+    }; // Size: 0x3c
+
+    Task(int cnt);
+    ~Task();
+    void init();
+    TCB *make(TaskFunc func, u16 stackSize);
+    void run();
+    void change(TaskFunc func, TCB *cb);
+    void kill(TCB *cb);
+
+    static void head();
+    static void tail();
+
+    int mTaskCnt;
+    TCB *mCBs;
+    TCB **mCBArr;
+    int mTaskIdx;
+    int mKillCnt;
+    TCB *mCurCB;
+};
+
+#endif

include/Kameda/WipeManager.h

@@ -0,0 +1,138 @@
+#ifndef WIPEMANAGER_H
+#define WIPEMANAGER_H
+
+#include <JSystem/JKernel/JKRHeap.h>
+#include <JSystem/JUtility/TColor.h>
+
+#include "Kameda/Fade.h"
+#include "Kameda/Mario.h"
+#include "Kameda/Task.h"
+#include "Kaneshige/HioMgr.h"
+#include "Shiraiwa/Wipe.h"
+
+// Not sure if this is correct
+class WipeParam : public JORReflexible
+{
+public:
+    // Inline/Unused
+    WipeParam();
+    virtual ~WipeParam() {}
+
+    // fabricated
+    bool isDrawEnabled() const { return mDrawFlag & 1; }
+
+    u8 _4;
+    u8 mDrawFlag;
+    u8 _6;
+    u8 _7;
+    u8 _8;
+    u8 _9;
+    u16 _a;
+    u16 _c;
+    u16 _e;
+    u16 _10;
+};
+
+class WipeHioNode : public HioNode
+{
+public:
+    virtual ~WipeHioNode() {}
+    // no idea if the \\ is a workaround
+    WipeHioNode() : HioNode("ƒ<EFBFBD>ƒCƒv•\\\Ž¦", &mParam, 0, 0) {}
+
+    WipeParam mParam;
+};
+
+class WipeManager
+{
+public:
+    WipeManager(JKRHeap *);                                             // 0x80138720
+    void reset();                                                       // 0x80138b38
+    void draw();                                                        // 0x80138bc0
+    void drawIn(int kart, int status, int);                             // 0x80138e34
+    void drawOut(int kart, int status, int);                            // 0x80139534
+    void calc();                                                        // 0x80139c28
+    void calcIn(int kart, int status, int);                             // 0x80139d5c
+    void calcOut(int kart, int status, int);                            // 0x8013a400
+    int getWipeState(int kart);                                         // 0x8013aa98
+    void setWipe(int kart, int, short, short, short, JUtility::TColor); // 0x8013ab30
+    
+    // The tasks
+    static void initPre();                                              // 0x8013ad30
+    static void preWipe();                                              // 0x8013ae04
+    static void initMain();                                             // 0x8013aecc
+    static void mainWipe();                                             // 0x8013afa0
+    static void initAfter();                                            // 0x8013b068
+    static void afterWipe();                                            // 0x8013b13c
+
+    // Unused
+    ~WipeManager();
+
+    void killWipe(int idx) { mKillFlag[idx] = true; }
+    void startWipe(int idx) { mMoveFlag[idx] = true; }
+    void stopWipe(int idx) { mMoveFlag[idx] = false; }
+    static WipeManager *getManager() { return mThis; }
+
+private:
+    static WipeManager *mThis; // 0x804162c0
+    static Task *mTask;        // 0x804162c4
+    static bool mMoveFlag[8];  // 0x804162c8
+    static bool mKillFlag[8];  // 0x804162d0
+
+    class
+    {
+    public:
+        void reset()
+        {
+            mWipeType = 0;
+            mWipeState = 6;
+            _8 = 0;
+            _a = 0;
+            _c = 0;
+            _e = 0;
+            mColor.set(0, 0, 0, 0);
+        }
+
+        // fabricated inlines, only setColor should be needed?(fixed something in setWipe)
+        void setWipeType(int type) { mWipeType = type; }
+        void setColor(JUtility::TColor color)
+        {
+            mColor.r = color.r;
+            mColor.g = color.g;
+            mColor.b = color.b;
+            mColor.a = color.a;
+        }
+
+        void setPreMainAfter(s16 pre, s16 main, s16 after)
+        {
+            _a = pre;
+            _c = main;
+            _e = after;
+        }
+
+        int mWipeType;
+        int mWipeState;
+        s16 _8;
+        s16 _a; // pre
+        s16 _c; // main
+        s16 _e; // after
+        JUtility::TColor mColor;
+    } _0[8];
+    int mScrnCount;
+    WipeHioNode *mNode;
+    Fade *mFade;
+    Mario *mMario;
+    TWipeSlide *mWipeSlide;
+    TWipeCheck *mWipeCheck;
+    TWipeShut *mWipeShut;
+    TWipeLineA *mWipeLineA;
+    TWipeLineB *mWipeLineB;
+    TWipeWaveA *mWipeWaveA;
+    TWipeCircle *mWipeCircle;
+    TWipeCurtain *mWipeCurtain;
+    int mKartNum;
+}; // class WipeManager
+
+inline WipeManager *GETWipeManager() { return WipeManager::getManager(); }
+
+#endif // WIPEMANAGER_H

include/Kaneshige/Blurscreen.h

@@ -0,0 +1,25 @@
+#ifndef BLURSCREEN_H
+#define BLURSCREEN_H
+
+#include <JSystem/JUtility/JUTTexture.h>
+#include "types.h"
+
+class BlurScreen
+{
+public:
+    BlurScreen();                                                                    // 0x801ccf74
+    void draw(const JUtility::TColor &color, u8, u8, f32, f32); // 0x801cd030
+    void captureScene();                                                             // 0x801cd46c
+    void captureBlur();                                                              // 0x801cd4b8
+private:
+    u16 mStartX;
+    u16 mStartY;
+    u16 mEndX;
+    u16 mEndY;
+    bool mFlush;
+    bool mFlushBlur;
+    JUTTexture mBlurTex;
+    JUTTexture mSceneTex;
+};
+
+#endif // BLURSCREEN_H

include/Kaneshige/Course/CrsData.h

@@ -161,6 +161,40 @@ public:
         s16 next[4]; // The indices of up to 4 group links to follow after this one. Unneeded slots are set to value -1.
     };
 
+    class Camera
+    {
+    public:
+        void getFrontDirection(JGeometry::TVec3f *out) const;
+
+        void getPosition(JGeometry::TVec3f *out) const { out->set(mPos); }
+        void getTargetPos(JGeometry::TVec3f *out) const { out->set(mTargetPos); }
+        void getTargetPos2(JGeometry::TVec3f *out) const { out->set(mTargetPos2); }
+
+        f32 getFovy() const { return mFovY; }
+        f32 getFovy2() const { return mFovY2; }
+        u32 getKind() const { return mKind; }
+        s16 getPathSpeed() const { return mPathSpeed; }
+        s16 getPathID() const { return mPathID; }
+
+
+    private:
+        JGeometry::TVec3f mPos;
+        JGeometry::TVec3f mDir;
+        JGeometry::TVec3f mTargetPos2;
+        JGeometry::TVec3f mTargetPos;
+        u16 mKind;
+        u16 mFovY; // start
+        s16 mTime;
+        s16 mID;
+        s16 mShimmerZ0;
+        s16 mShimmerZ1;
+        s16 mPathID;
+        s16 mPathSpeed;
+        u16 mFovY2; // end
+        s16 mNextID;
+        char mName[4];
+    }; // 48
+
     class Ground
     {
     public:
@@ -251,6 +285,7 @@ public:
     u8 getShadowDepth() const { return mObjectData->shadowDepth; }
     u8 getShaking() const { return mObjectData->shaking; }
     int getAreaNumber() const { return mObjectData->areaNum; }
+    int getCameraNumber() const { return mObjectData->cameraNum; }
     int getCheckPathNumber() const { return mObjectData->checkPathNum; }
     int getCLPointNumber() const { return mObjectData->clPointNum; }
     int getJugemPointNumber() const { return mObjectData->jugemPointNum; }
@@ -269,13 +304,13 @@ public:
 
     // Read from file offset
 
-    /*Camera *getCameraData(int camIdx) const
+    Camera *getCameraData(int camIdx) const;
-    {
+    /*{
         Camera *camData = nullptr;
 
         if (camIdx >= 0 && camIdx < getCameraNumber())
         {
-            camData = reinterpret_cast<Camera *>(reinterpret_cast<char *>(mObjectData) + mObjectData->mCameraOffset) + camIdx;
+            camData = reinterpret_cast<Camera *>(reinterpret_cast<char *>(mObjectData) + mObjectData->cameraOffset) + camIdx;
         }
         return camData;
     }*/

include/Kaneshige/Course/CrsGround.h

@@ -24,7 +24,7 @@ public:
     void checkPolygonCoverMain(const JGeometry::TVec3f &, const CrsData::SColInfoSphere &, u32, f32, f32, f32, const CrsData::Ground *); // 0x801a2d20
     void isInsideGrid(const JGeometry::TVec3f &, f32, f32, f32, f32);                                                                            // 0x801a2ec0
     void searchGridIndex(int *, int *, Course *, const JGeometry::TVec3f &, f32, f32, f32, f32, int, int);                                       // 0x801a3004
-    void getHeight() const;                                                                                                                              // 0x801a3168
+    f32 getHeight() const;                                                                                                                              // 0x801a3168
     void getNormal(JGeometry::TVec3f *) const;                                                                                                           // 0x801a3170
     u8 getCameraCode() const;                                                                                                                            // 0x801a319c
     void isItemInvalGround() const;                                                                                                                      // 0x801a3204
@@ -36,9 +36,9 @@ public:
     void getSplashID();                                                                                                                                  // 0x801a3520
     void getJugemPoint();                                                                                                                                // 0x801a35ec
     void getCannonPoint();                                                                                                                               // 0x801a36d4
-    void getPipePoint();                                                                                                                                 // 0x801a3728
+    JugemPoint *getPipePoint();                                                                                                                                 // 0x801a3728
     void getGeoCannon();                                                                                                                                 // 0x801a377c
-    void getWaterHeight();                                                                                                                               // 0x801a37e8
+    f32 getWaterHeight();                                                                                                                               // 0x801a37e8
     void isShaking() const;                                                                                                                              // 0x801a3848
     void isAttributeCollision();                                                                                                                         // 0x801a38a8
     void getWallNormal(JGeometry::TVec3f *, JGeometry::TVec3f *);                                                                                        // 0x801a38f4

include/Kaneshige/DrawBuffer.h

@@ -45,7 +45,7 @@ private:
     u16 mDrawFlag;          // 0x6
     J3DDrawBuffer *mOpaBuf; // 0x8
     J3DDrawBuffer *mXluBuf; // 0xc
-    
+
-};                          // Size 0x10
+}; // Size 0x10
 
 #endif

include/Kaneshige/ExModel.h

@@ -41,17 +41,17 @@ public:
     void clipAll(u32, bool);                                                            // 0x801a5fc8
     void clipBySphere(u32, J3DUClipper *, const Mtx44, f32);                            // 0x801a6040
     void clipJoint(u32, s16, bool);                                                     // 0x801a6254
-    void setBaseTRMtx(Mtx44);                                                           // 0x801a63c8
+    void setBaseTRMtx(Mtx);                                                             // 0x801a63c8
     void setBaseScale(JGeometry::TVec3f &);                                             // 0x801a6474
     void tstDiffTexMtxMode();                                                           // 0x801a6550
     void setEffectMtx(Mtx44, u32);                                                      // 0x801a65a4
 
     // Vtable
-    virtual void createModel(JKRSolidHeap *, u32, u32);               // 0x801a4c70
+    virtual bool createModel(JKRSolidHeap *, u32, u32);               // 0x801a4c70
     virtual void createDifferedModel(JKRSolidHeap *, u32, u32, bool); // 0x801a4e6c
     virtual void calc();                                              // 0x801a5288
-    virtual void calc(s16);                                           // 0x801a52b8
+    virtual void calc(u16);                                           // 0x801a52b8
-    virtual void update(s16);                                         // 0x801a5434
+    virtual void update(u16);                                         // 0x801a5434
     virtual void viewCalc(u32) {}                                     // 0x801a6824
     virtual void setCurrentViewNo(u32);                               // 0x801a5614
 
@@ -76,7 +76,7 @@ public:
     static bool sDrawingOnlyUpdZMat;   // 0x80416399
     static f32 sExModelInvalidLODBias; // 0x80419d90
 
-private:
+protected:
     // Vtable 0x0
     u16 mLevelCnt;
     J3DModelData **mModelData;

include/Kaneshige/GhostScreen.h

@@ -0,0 +1,26 @@
+#ifndef GHOSTSCREEN_H
+#define GHOSTSCREEN_H
+
+#include <JSystem/JUtility/JUTTexture.h>
+#include "types.h"
+
+class GhostScreen
+{
+public:
+    GhostScreen();       // 0x801d2b40
+    void reset();        // 0x801d2bf0
+    void captureScene(); // 0x801d2bfc
+    void captureGhost(); // 0x801d2c78
+    void draw();         // 0x801d2cc4
+private:
+    u16 mStartX;
+    u16 mStartY;
+    u16 mEndX;
+    u16 mEndY;
+    bool mFlush;
+    bool mIsHide;
+    JUTTexture mSceneTex;
+    JUTTexture mGhostTex;
+};
+
+#endif // GHOSTSCREEN_H

include/Kaneshige/JugemPoint.h

@@ -15,7 +15,10 @@ public:
     bool isSameCPointID(u16 id) const { return mPointData->cPointID == id; }
     bool isSameJPointID(u16 id) const { return mPointData->id == id; }
 
+    CLPoint *getCLPoint() { return mCLPoint; }
+
     u16 getID() const { return mPointData->id; }
+    int getCameraID() const { return mPointData->cameraID; }
 
     void getPosition(JGeometry::TVec3f *pos)
     {

include/Kaneshige/KartChecker.h

@@ -61,6 +61,13 @@ public:
             JUTReport(x, (y + 16) + (i * 16), "[%d]:%08X", i, mPassedSectors[i]);
     }
 
+    const RaceTime &getLapSplit(int lap)
+    {
+#line 199
+        JUT_MINMAX_ASSERT(0, lap, mMaxLap);
+        return mLapSplits[lap];
+    }
+
     const RaceTime &getLapTime(int no)
     {
 #line 206
@@ -108,6 +115,7 @@ public:
     void setDemoRank() { mRaceFlags |= 16; }
     void setDead() { mBattleFlags |= 4; }
     void setRank(int rank) { mRank = rank; }
+    void stillRabbitTimer() { mBattleFlags |= 1; }
     inline bool setPass(int index); // ??? function is weak yet in cpp file itself
     void clrRank() { mRank = 0; }
     void resumeRabbitTimer() { mBattleFlags &= 0xfffe; }
@@ -170,6 +178,23 @@ public:
 
     void setBombEvent(EBombEvent, ItemObj *);
 
+    void beginWarp(JugemPoint *point)
+    {
+        if (mWarpState == 0)
+        {
+            mWarpState = 1;
+            mJugemPoint = point;
+        }
+    }
+
+    void endWarp()
+    {
+        if (mWarpState == 2)
+        {
+            mWarpState = 3;
+        }
+    }
+
     static int sPlayerKartColorTable[];
     static short sBalForbiddenTime;
 

include/Kaneshige/KartInfo.h

@@ -10,17 +10,6 @@
 
 #include "kartEnums.h"
 
-extern "C" {
-#include <ppcdis.h>
-}
-
-enum EKartWeight 
-{
-    LIGHT = 0,
-    NORMAL = 1,
-    HEAVY = 2
-};
-
 class KartInfo 
 {
 public:
@@ -68,14 +57,10 @@ public:
         }
         ECharID getCharID() const
         {
-            if (mCharDB != nullptr)
+            return (mCharDB) ? (ECharID)mCharDB->id : cCharIDNone;
-                return (ECharID)mCharDB->id;
-            return cCharIDNone;
         }
         ECharID getPartnerID() const {
-            if (mCharDB != nullptr)
+            return (mCharDB) ? (ECharID)mCharDB->defaultPartnerID : cCharIDNone;
-                return (ECharID)mCharDB->defaultPartnerID;
-            return cCharIDNone;
         }
         bool isAvailable() const;
         static int convPlayerKind(KartGamePad *);
@@ -104,7 +89,11 @@ public:
     static EKartID getPartnerKartID(ECharID);
     bool isDefaultCharCombi();
     KartGamePad * getYoungestPad();
+
+    void setGhostKind(EGhostKind kind) { mGhostKind = kind; }
+    EGhostKind getGhostKind() { return mGhostKind; }
     // TODO: not important but move to "correct" location
+    // Comment 05-03-2024(DD-MM-YYYY): did i already do this?
     bool isComDriver(int driverNo) const {
 #line 113
         JUT_MINMAX_ASSERT(0, driverNo, 2);
@@ -117,7 +106,7 @@ public:
         return mKartCharacters[driverNo].getPlayerKind();
     }
 
-    KartGamePad* getPad(int driverNo) {
+    KartGamePad *getPad(int driverNo) {
 #line 126
         JUT_MINMAX_ASSERT(0, driverNo, 2);
         return mKartCharacters[driverNo].getPad();
@@ -129,6 +118,16 @@ public:
         return mKartCharacters[driverNo].getCharID();
     }
 
+    EKartID getKartID() const
+    {
+        return (mKartDB) ? mKartDB->id : cKartIDNone;
+    }
+
+    EKartWeight getKartWeight() const
+    {
+        return mKartDB ? mKartDB->weight : UNK_3;
+    }
+
     bool isComKart() const {
         return isComDriver(0);
     }

include/Kaneshige/KartLoader.h

@@ -20,7 +20,7 @@ public:
     void entryTevRegAnimator(int);         // 0x801a7a10
     void removeTevRegAnimator(int);        // 0x801a83b8
     void createModel(JKRSolidHeap *, u32); // 0x801a8598
-    void isCommonWheelModelData();         // 0x801a8624
+    bool isCommonWheelModelData();         // 0x801a8624
 
     // Inline/Unused
     // void KartShadowModel::~KartShadowModel();
@@ -29,7 +29,7 @@ public:
     // ~KartLoader();
     //  Inline
     void setDemoBodyBmd(void *ptr) { mDemoBmd = ptr; }
-    bool isShockExist() const; /* { return mShockModels[0].getModelData() != 0; } */ // 0x801a7720
+    bool isShockExist() const { return mShockModels[0].getModelData() != 0; } // 0x801a7720
     bool isKartTevAnmEnable(int wheel);                                              // 0x801a8094
     bool isDriverTevAnmEnable(int);                                                  // 0x801a8378
     ExModel *getExModelDriver(int driver)                                            // 0x801a81e8

include/Kaneshige/KartMtx.h

@@ -3,10 +3,13 @@
 
 #include <dolphin/mtx.h>
 
+#include "types.h"
+
 extern void KartMtxPerspective(Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f, bool flip);
 
 // Unused class
-class KartOrthoGraph {
+class KartOrthoGraph
+{
 public:
     KartOrthoGraph(f32, f32, f32, f32, f32, f32, bool);
     ~KartOrthoGraph();

include/Kaneshige/LightMgr.h

@@ -31,7 +31,7 @@ private:
 
 class LtObjAmbient : public LightObj {
 public:
-    LtObjAmbient(JUtility::TColor color) : LightObj("アンビエント", 0xffffffff)
+    LtObjAmbient(JUtility::TColor color) : LightObj("アンビエント", 0xffffffff)
     {
         GXColor gxColor = color;
         mColor.set(gxColor);

include/Kaneshige/MaskScreen.h

@@ -0,0 +1,50 @@
+#ifndef MASKSCREEN_H
+#define MASKSCREEN_H
+
+#include <JSystem/JUtility/JUTTexture.h>
+#include "types.h"
+
+#define NUM_NODES 20
+
+class MaskScreenNode
+{
+public:
+    MaskScreenNode();
+    void reset();
+    void set(f32, f32, bool);
+    void capture();
+    void draw();
+
+    bool isActive() const { return mActive; }
+
+private:
+    bool _0;
+    s16 mStartX;
+    s16 mStartY;
+    s16 mEndX;
+    s16 mEndY;
+    bool mFlush;
+    bool mActive;
+    JUTTexture *mTex;
+};
+
+class MaskScreen
+{
+public:
+    MaskScreen();
+    void reset();
+    void set(f32, f32, bool);
+    void resetAllMask();
+    void requestMask(f32, f32, bool);
+    void capture();
+    void draw();
+
+private:
+    u16 mStartX;
+    u16 mStartY;
+    u16 mEndX;
+    u16 mEndY;
+    MaskScreenNode *mNodes[NUM_NODES];
+};
+
+#endif

include/Kaneshige/RaceBGMPlayer.h

@@ -5,44 +5,48 @@
 
 class RaceBGMPlayer
 { // Autogenerated
-    // Global
+  // Global
-    public:
+public:
-    RaceBGMPlayer();               // 0x801c6da0
+    RaceBGMPlayer();             // 0x801c6da0
-    void reset();                  // 0x801c6dd0
+    void reset();                // 0x801c6dd0
-    int getCrsDemoBGMLabel();      // 0x801c6e64
+    u32 getCrsDemoBGMLabel();    // 0x801c6e64
-    int getRaceStartBGMLabel();    // 0x801c6eac
+    u32 getRaceStartBGMLabel();  // 0x801c6eac
-    void calc();                   // 0x801c6f84
+    void calc();                 // 0x801c6f84
-    int getGoalBGMLabel();         // 0x801c72e0
+    u32 getGoalBGMLabel();       // 0x801c72e0
-    static short sCrsBGMDelayTime; // 0x804146f0
+    static s16 sCrsBGMDelayTime; // 0x804146f0
     // Inline/Unused
     // void stop();
     // Inline
-    void stopCrsDemo();         // 0x801c6e54
+    void stopCrsDemo() { mFlags |= 4; }                // 0x801c6e54
-    bool isMiniGameEnd() const; // 0x801c7288
+    bool isMiniGameEnd() const { return mFlags & 16; } // 0x801c7288
-    bool isLastTime() const;    // 0x801c7294
+    bool isLastTime() const { return mFlags & 8; }     // 0x801c7294
-    bool isExecPrepare() const; // 0x801c72a0
+    bool isExecPrepare() const { return mFlags & 32; } // 0x801c72a0
-    bool isPlay() const;        // 0x801c72ac
+    bool isPlay() const { return mFlags & 2; }         // 0x801c72ac
-    void execPrepare();         // 0x801c72b8
+    void execPrepare() { mFlags |= 32; }               // 0x801c72b8
-    bool isPrepare() const;     // 0x801c72c8
+    bool isPrepare() const { return mFlags & 1; };     // 0x801c72c8
-    bool isCrsDemoEnd() const;  // 0x801c72d4
+    bool isCrsDemoEnd() const { return mFlags & 4; }   // 0x801c72d4
 
-    void setLowestKartNo(int kartNo) {
+    void setLowestKartNo(int kartNo)
+    {
         if (mLowestKartNo < 0)
-            mLowestKartNo = kartNo; 
+            mLowestKartNo = kartNo;
     };
-    void setGoalKartNo(int kartNo) {
+    void setGoalKartNo(int kartNo)
+    {
         if (mGoalKartNo < 0)
-            mGoalKartNo = kartNo; 
+            mGoalKartNo = kartNo;
     };
     void setFinalLapKartNo(int kartNo) { mFinalLapKartNo = kartNo; };
 
 private:
-    u8 _0[0x8];
+    u32 mState;
+    u16 mFlags;
+    s16 mDelay;
     s16 mFinalLapKartNo;
     s16 mGoalKartNo;
     s16 mLowestKartNo;
-    s16 _pad;
+    bool _e;
-};                              // class RaceBGMPlayer
+}; // class RaceBGMPlayer
 // void RaceMgr::isRaceModeVs() const // RaceMgr.h; // 0x801c6f2c
 // void RaceMgr::isRaceModeTA() const // RaceMgr.h; // 0x801c6f58
 #endif // RACEBGMPLAYER_H

include/Kaneshige/RaceInfo.h

@@ -41,6 +41,7 @@ public:
     int getLANLapNumber() const { return mLapNumLAN; }
     int getVSLapNumber() const { return mVsLapNum; }
     int getKartNumber() const { return mKartNum; }
+    int getPlayerKartNumber() const { return mPlayerNum; }
     int getConsoleNumber() const { return mConsoleNum; }
     int getStatusNumber() const { return mStatusNum; }
     ERaceMode getRaceMode() const { return mRaceMode; }
@@ -79,7 +80,7 @@ public:
     KartInfo *getKartInfo(int kartNo) {
 #line 173
         JUT_MINMAX_ASSERT(0, kartNo, 8);
-        return &mKartInfo[kartNo];
+        return mKartInfo + kartNo;
     }
 
 //private:

include/Kaneshige/RaceMgr.h

@@ -4,7 +4,7 @@
 #include "kartEnums.h"
 #include "JSystem/JKernel/JKRDisposer.h"
 #include "JSystem/JUtility/JUTDbg.h"
-#include "Kawano/StaffRoll2D.h"
+#include "Kameda/PauseManager.h"
 #include "Kaneshige/Course/Course.h"
 #include "Kaneshige/RaceBGMPlayer.h"
 #include "Kaneshige/RaceDirector.h"
@@ -14,6 +14,7 @@
 #include "Kaneshige/KartLoader.h"
 #include "Kaneshige/RaceDrawer.h"
 #include "Kaneshige/SysDebug.h"
+#include "Kawano/StaffRoll2D.h"
 #include "Osako/Award2D.h"
 #include "Yamamoto/kartCtrl.h"
 #include "types.h"
@@ -133,9 +134,17 @@ public:
     int getKartNumber() const { return mRaceInfo->getKartNumber(); }
     int getAwardKartNo() const { return mRaceInfo->getAwardKartNo(); }
     int getConsoleNumber() const { return mRaceInfo->getConsoleNumber(); }
+    int getStatusNumber() const { return mRaceInfo->getStatusNumber(); }
     // why did this not use a getter?
     ERaceMode getRaceMode() const { return mRaceInfo->mRaceMode; }
 
+    bool isDemoCamera(int camNo) const
+    {
+#line 162
+        JUT_MINMAX_ASSERT(0, camNo, 4)
+        return mRaceInfo->mIsDemoKart[camNo];
+    }
+
     KartInfo *getKartInfo(int index)
     {
 #line 170
@@ -164,9 +173,12 @@ public:
     bool isRaceModeVs() const { return getRaceMode() == VERSUS_RACE; }
     bool isStaffRoll() { return getRaceMode() == STAFF_ROLL; } // pls don't tell me it's stored as local variable
     bool isAwardDemoMode() { return getRaceMode() == AWARD_DEMO; }
+    bool isReplayMode() const { return mReplayMode & 1; }
     bool isActiveAreaLight() const { return mAreaLight & 1; }
     void activeAreaLight() { mAreaLight |= 1; }
 
+    bool isSubScrExist() const { return false; }
+
     KartLoader *getKartLoader(int index) const
     {
 #line 257
@@ -184,6 +196,13 @@ public:
         return mKartChecker[index];
     }
 
+    int getTargetKartNo(u32 viewNo) const
+    {
+#line 283
+        JUT_MINMAX_ASSERT(0, viewNo, 4);
+        return mRaceInfo->mTargetKarts[viewNo];
+    }
+
     const RaceTime &getBestTotalTime(int recID)
     {
 #line 328
@@ -228,4 +247,6 @@ inline KartCam *RCMGetCamera(int index) { return RaceMgr::getManager()->getCamer
 inline KartChecker *RCMGetKartChecker(int index) { return RaceMgr::getManager()->getKartChecker(index); }
 inline KartLoader *RCMGetKartLoader(int index) { return RaceMgr::getManager()->getKartLoader(index); }
 
+inline bool RCMIsPause() { return PauseManager::tstPause(); }
+
 #endif // RACEMGR_H

include/Kaneshige/RaceTime.h

@@ -23,6 +23,9 @@ public:
 
     void reset() { mTime = MAX_TIME; }
 
+    // fabricated
+    void round() { mTime = mTime / 1000 * 1000; }
+
     void set(int frame)
     {
         mTime = frame; // no idea why framecount is used here,

include/Kaneshige/ShimmerScreen.h

@@ -0,0 +1,72 @@
+#ifndef SHIMMERSCREEN_H
+#define SHIMMERSCREEN_H
+
+#include <JSystem/JUtility/JUTTexture.h>
+#include <JSystem/JUtility/JUTAssert.h>
+
+#include "types.h"
+
+#define NUM_LEVELS 2
+
+class ShimmerScreen
+{
+public:
+    // Global
+    ShimmerScreen(ResTIMG *timg);       // 0x801d2ff8
+    void calc();                        // 0x801d31e0
+    void capture();                     // 0x801d3244
+    void draw();                        // 0x801d32cc
+    void drawInit();                    // 0x801d3324
+    void drawEnd();                     // 0x801d34a4
+    void levelDraw(int);                // 0x801d34e0
+    static u8 sIndSinedOfs;             // 0x804147a0
+    static s16 sIndScaleExp;            // 0x804147a2
+    static GXIndTexScale sIndTexScaleS; // 0x80416570
+    static GXIndTexScale sIndTexScaleT; // 0x80416574
+    static u8 sIndReplace;              // 0x80416578
+    // Inline/Unused
+    // void drawForDebug();
+    // void sTestR;
+    // void sTestG;
+    // void sTestB;
+    // void sTestA;
+    // void sIsDrawDebug;
+    // Inline
+    bool isIndActive() const { return mIndImg != nullptr; } // 0x801d3494
+
+    void setOffsetZ(int level, s32 z)
+    {
+#line 47
+        JUT_MINMAX_ASSERT(0, level, NUM_LEVELS)
+        JUT_MINMAX_ASSERT(0, z, 0x1000)
+        if (!_0)
+            mOffsetZ - z;
+    }
+
+    void setBlendRate(int level, u8 blendRate)
+    {
+#line 56
+        JUT_MINMAX_ASSERT(0, level, NUM_LEVELS)
+        mBlendRate[level] = blendRate;
+    }
+
+private:
+    bool _0;
+    s32 mOffsetZ[2];
+    u8 mBlendRate[2];
+    ResTIMG *mIndImg;
+    JUTTexture mTex1;
+    JUTTexture mTex2;
+    JUTTexture mTex3;
+    u16 mStartX;
+    u16 mStartY;
+    u16 mEndX;
+    u16 mEndY;
+    bool mFlush;
+    f32 _e0[2][3];
+    Mtx mIndMtx;
+    s16 _128;
+    s16 _12a;
+}; // class ShimmerScreen
+
+#endif // SHIMMERSCREEN_H

include/Kawano/SceneTitleLine.h

@@ -0,0 +1,34 @@
+#ifndef SCENETITLELINE_H
+#define SCENETITLELINE_H
+
+#include <JSystem/J2D/J2DPane.h>
+#include <JSystem/J2D/J2DGrafContext.h>
+#include <JSystem/JKernel/JKRArchive.h>
+
+#define NUM_TAGS 10
+
+class SceneTitleLine
+{
+public:
+    // Global
+    SceneTitleLine(JKRArchive *arc, JKRHeap *heap, char *name); // 0x801f5788
+    ~SceneTitleLine();                                          // 0x801f58f8
+    void init_titleline(int);                                   // 0x801f595c
+    void drawTitleLine(J2DOrthoGraph *ortho);                   // 0x801f59bc
+    void calcAnmTitleLine(int);                                 // 0x801f5a10
+    void calcMatAnmTitleLine();                                 // 0x801f5ad8
+    // Inline/Unused
+    SceneTitleLine(JKRHeap *);
+private:
+    J2DScreen *mScreen;              // 0
+    J2DPane *mPane[NUM_TAGS];        // 4;
+    J2DAnmTransform *mTransform;     // 2c
+    J2DAnmTextureSRTKey *mTexSRTKey; // 30
+    int mAnmFrame;                   // 34
+    int mMatAnmFrame;                // 38
+
+    static const u64 mTag_Titleline[NUM_TAGS]; // 0x8037b370
+
+}; // Size: unk
+
+#endif // SCENETITLELINE_H

include/Kawano/driverMgr.h

@@ -1,6 +1,8 @@
 #ifndef DRIVER_H
 #define DRIVER_H
 
+#include "Inagaki/CharacterSoundMgr.h"
+
 #include "Kaneshige/ExModel.h"
 #include "Kaneshige/KartInfo.h"
 #include "Kaneshige/KartLoader.h"
@@ -8,6 +10,32 @@
 
 class J3DAnmTransform; // TODO: JSystem
 
+class DriverDataChild
+{
+    static int mInitCounter;
+    static f32 mDriverDataDefault[91][14];
+
+    f32 data[91][14];
+
+public:
+    DriverDataChild();
+    virtual ~DriverDataChild();
+
+}; // Size: 0x180
+
+class DriverData : public JKRDisposer
+{
+    u8 _18[0x7c - 0x18];
+
+public:
+    DriverData(); // Auto Inlined
+    virtual ~DriverData();
+    static DriverData *create();
+
+    static DriverDataChild msDriverData[14];
+    static DriverData *mspDriverData;
+}; // Size: 0x7c
+
 class DriversAnimator // TODO
 {
 public:
@@ -94,8 +122,13 @@ public:
     void setLODLevel(int);
     void IsARAMDMAFinished();
     //void msAnmSabunList;
-};
 
+    GameAudio::CharacterSoundMgr* getGameAudioCharacterSoundMgr() { return mCharSoundMgr; }
+private:
+    u8 _8c[0x6c0 - 0x8c];
+    GameAudio::CharacterSoundMgr *mCharSoundMgr; // _6C0
+    u8 _6C4[0x7a8 - 0x6c0];
+}; // Size: 0x7a8
 
 
 #endif DRIVER_H

include/Osako/Award2D.h

@@ -12,6 +12,15 @@ public:
         _10 = 0;
     }
 
+    class OKButton {
+        int _0;
+        s16 _4;
+        s16 _6;
+        f32 _8;
+        f32 _c;
+        f32 _10;
+    };
+
     u8 _00[0x10];
     u32 _10;
     u8 _14[0x58 - 0x14];

include/Osako/AwardApp.h

@@ -17,6 +17,7 @@ public:
 
     // Inline Functions
     static AwardApp *ptr() { return mspAwardApp; }
+    static void destroy() { delete mspAwardApp; }
 
 private:
     static AwardApp *mspAwardApp; // 0x80416a68

include/Osako/ErrorViewApp.h

@@ -24,6 +24,7 @@ public:
         ERROR_LA_CONNECTION, // check lan cable connection and settings
         ERROR_LA_DISCONNECT,
         ERROR_LA_DISCONNECT_LINK,
+        ERROR_MAX
     };
 
     static ErrorViewApp *create(); // 0x802011cc
@@ -34,9 +35,13 @@ public:
     virtual void calc();           // 0x80201408, override
     virtual void reset();          // 0x802015a8, override
 
+    PrintDvdError *getPrintDvdError() { return mDvdError; }
+
+    static ErrorViewApp *ptr() { return mspErrorViewApp; };
+
     static ErrorViewApp *mspErrorViewApp; // 0x804169c0
     static ErrorId msErrorId;             // 0x804169c4
-
+ 
     int mErrorState;
     JUTFader::EStatus mFadeStatus;
     s16 _14;

include/Osako/ForceEffectMgr.h

@@ -0,0 +1,32 @@
+#ifndef FORCEEFFECTMGR_H
+#define FORCEEFFECTMGR_H
+
+#include <JSystem/JKernel/JKRDisposer.h>
+
+#include "types.h"
+
+class ForceEffectMgr : JKRDisposer
+{
+public:
+    ForceEffectMgr();          // 0x8020d390
+    virtual ~ForceEffectMgr(); // 0x8020d3dc
+    void start();              // 0x8020d444
+    void end();                // 0x8020d4b8
+
+    static void create()
+    {
+        if (!mspForceEffectMgr)
+            mspForceEffectMgr = new ForceEffectMgr();
+    }
+
+    static void destroy() { delete mspForceEffectMgr; }
+    static ForceEffectMgr *ptr() { return mspForceEffectMgr; }
+
+private:
+    static ForceEffectMgr *mspForceEffectMgr; // 0x80416a58
+
+    u8 _18;
+    s16 _1a;
+}; // 1c
+
+#endif // FORCEEFFECTMGR_H

include/Osako/GhostFile.h

@@ -18,7 +18,7 @@ union UUData
         u32 bit3 : 6;
         u32 bit4 : 6;
     } s;
-    u8 arr[0x3];
+    u8 arr[4];
 };
 
 class GhostFile : public SaveFile

include/Osako/KartPadRecord.h

@@ -14,6 +14,7 @@ class KartPadRecord : public TARecord
 {
 public:
     KartPadRecord() : mFrame(0) {}
+    KartPadRecord(u8 charId1, u8 charId2, u8 kartId, u8 courseId) : TARecord(charId1, charId2, kartId, courseId), mFrame(0) {}
     void reset() { mFrame = 0; }
 
     // fabricated
@@ -50,11 +51,11 @@ public:
 
     bool isFrameValid() const { return mFrame > 0 && mFrame < MAX_INPUT_FRAME_COUNT; }
 
-    const RaceTime &getLapSlit(int lap)
+    const RaceTime &setLapSlit(int lap, const RaceTime &other)
     {
 #line 102
         JUT_MINMAX_ASSERT(0, lap, NUM_LAP_SPLITS)
-        return mLapSplits[lap];
+        mLapSplits[lap] = other;
     }
 
     void calcLapTime(int lap, RaceTime nextSplit)

include/Osako/LogoApp.h

@@ -62,6 +62,8 @@ public:
     void setLoading(bool loading) { mIsLoadingMovie = loading; }
     bool isLoading() { return mIsLoadingMovie; }
 
+    PRINTAPP_TYPE *getPrintApp() { return mPrintApp; }
+
 private:
     static LogoApp *mspLogoApp; // 0x80416960
     PRINTAPP_TYPE *mPrintApp;   // 0xc

include/Osako/NetGameMgr.h

@@ -94,8 +94,10 @@ public:
 
     static NetGameMgr *ptr() { return mspNetGameMgr; }
 
+    void setState(int state) { mState = state; }
     int getState() { return mState; }
     int getNetworkNum() { return mNetworkNum; }
+    int getNetworkCubes() { return mNetworkCubes; }
 
     // Fabricated
     u8 getPadConvNum(u8 idx)
@@ -110,12 +112,20 @@ public:
         return (temp % 4);
     }
 
+    u8 get12ee() { return _12EE; }
+
+    void set12ee(int val) { _12EE = val; }
+
 private:
     u8 _0[0x96c];              //
-    int mState;                // 6C
+    int mState;                // 96C
     u8 _970[0xC58 - 0x970];    //
     u8 mNetworkNum;            // C58
-    u8 _C59[0x12f4 - 0xC59];   //
+    u8 _C59[0x12e8 - 0xC59];   //
+    u8 mNetworkCubes;          // 12e8
+    u8 _12e9[0x12ee - 0x12e9]; //
+    u8 _12EE;                  //
+    u8 _12EF[0x12f4 - 0x12EF]; //
     u8 mPadConvData[16];       // this might be a double sided array and a union?
     u8 _1304[0x1308 - 0x1304]; //
 

include/Osako/PadMgr.h

@@ -18,7 +18,11 @@ namespace PadMgr
     void getPadData(unsigned char, KartPadInput, KartPadData *); // 0x8020c588
     void setKartPadInput(KartPadInput);                          // 0x8020c74c
     void resetPort();                                            // 0x8020c77c
+
     extern KartPadInput msKartPadInput;                          // 0x80416a50
     extern PadRecorder *mspRecorder;                             // 0x80416a54
+
+    inline void destroy() { mspRecorder = nullptr; }
+
 };                                                               // namespace PadMgr
 #endif                                                           // PADMGR_H

include/Osako/PadRecorder.h

@@ -41,7 +41,9 @@ public:
     void playGhost();
     // Inline
     u32 getFrame() { return mFrame; };
+    void setFrame(u32 frame) { mFrame = frame; }
 
+    static PadRecorder *mspRecorder;
 private:
     u32 mFrame;
     PadState mState;

include/Osako/RaceApp.h

@@ -1,19 +1,32 @@
 #ifndef RACEAPP_H
 #define RACEAPP_H
 
+#include "Kaneshige/RaceMgr.h"
+#include "Kameda/Scene.h"
+
+#include "Osako/GhostFile.h"
 #include "Osako/GameApp.h"
 #include "Osako/PadRecorder.h"
+#include "Osako/ResMgr.h"
+#include "Osako/SystemRecord.h"
 #include "types.h"
 
-#include "Kaneshige/RaceMgr.h"
 
 class RaceApp : public GameApp
 {
 public:
     static RaceApp *create();
     static void call();
+
+    void ctrlRace();         // 0x801fbcc0
+    void ctrlRecorder();     // 0x801fbfb8
+    void setAudioRaceMode(); // 0x801fc444
+
     static RaceApp *ptr() { return mspRaceApp; };
-    PadRecorder *getPadRecorder() { return mPadRecorder; }
+    PadRecorder *getPadRecorder() { return mRecorder; }
+
+    // TODO: unlocked, or loaded?
+    bool isStaffGhostLoaded() { return msStaffGhostFlag & 1 << SystemRecord::convCourseID(ResMgr::msCourseID); }
 
     RaceApp();
     virtual ~RaceApp();  // override
@@ -21,16 +34,22 @@ public:
     virtual void calc(); // override
 
     static RaceApp *mspRaceApp;
-    static PadRecorder *mspRecorder;
+    static volatile u16 msStaffGhostFlag;
 
 private:
     RaceMgr *mRaceMgr;
     u32 mState;
     u32 mDrawFlags;
-    u8 _18[0x28 - 0x18];
+    u32 _18;
-    PadRecorder *mPadRecorder;
+    u32 _1C;
+    u8 _20;
+    Scene::SceneType mNextScene;
+    PadRecorder *mRecorder;
     KartPadRecord *mPadRecord[4];
     KartPadRecord *mGhostRecord;
+    KartPadRecord *mStaffGhostRecord;
+    KartGamePad *_44[3];
+    u8 _50;
 }; // Size: 0x54
 
-#endif
+#endif

include/Osako/SystemRecord.h

@@ -31,6 +31,7 @@ struct SystemRecord
 
     void setDefaultName(const char *name);
 
+    bool isRumble() { return !(mOptions & 4); } 
     /*union
     {
     struct

include/Osako/TARecord.h

@@ -16,14 +16,14 @@ public:
         mTime.reset();
     }
 
-    TARecord(u8, u8, u8, u8);
+    TARecord(u8 charId1, u8 charId2, u8 kartId, u8 courseId);
-    void setName(const char *);
+    void setName(const char *name);
-    void setStatus(u8, u8, u8, u8);
+    void setStatus(u8 charId1, u8 charId2, u8 kartId, u8 courseId);
-    void setRaceTime(RaceTime);
+    void setRaceTime(RaceTime time);
-    bool less(const TARecord &);
+    bool less(const TARecord &rec);
 
     // probably Inlined(auto)
-    void set(u8, u8, u8, u8, const char *, RaceTime);
+    void set(u8 charId1, u8 charId2, u8 kartId, u8 courseId, const char *name, RaceTime time);
 
     // Inline
     bool isValid() { return ((mKartID < 0x15) &&
@@ -31,6 +31,8 @@ public:
                              ((mCharIDs[1] != 0) && mCharIDs[1] < 0x15)); }
     RaceTime getRaceTime() const { return mTime; }
     ECourseID getCourseID() const { return (ECourseID)mCourseID; }
+    EKartID getKartID() const { return (EKartID)mKartID; }
+    ECharID getCharID(int no) const { return (ECharID)mCharIDs[no]; }
 
 private:
     u8 mCharIDs[2]; // 00

include/Osako/TestViewApp.h

@@ -7,7 +7,7 @@ class TestViewApp : public GameApp
 { // Autogenerated
 public:
     static TestViewApp *create(); // 0x80209c9c
-    static void call();           // 0x80209cec
+    static bool call();           // 0x80209cec
     TestViewApp();                // 0x80209d10
     virtual ~TestViewApp();       // 0x80209d70, overide
     virtual void reset();         // 0x80209dd0, overide
@@ -18,5 +18,13 @@ public:
 
 private:
     static TestViewApp *mspTestViewApp; // 0x80416a28
-};
+
+    int mMenuIndex;
+    BOOL mJ2DInitialized;  // 10
+    int mMenuOption;       // 14
+    int mDvdError;         // 18
+    int mPrintOption;      // 1c
+    int mMemoryCardOption; // 20
+
+};     // 24;
 #endif // TESTVIEWAPP_H

include/Osako/shadowMgr.h

@@ -31,6 +31,18 @@ public:
     void setShadowDepth(u8 depth) {
         mDepth[1] = depth;
     }
+    void setDepthMode(u8 depth)
+    {
+        mDepthMode = depth;
+    }
+
+    int getDstAlpha() {
+        if (mDepthMode == 1) {
+            return 0xff - (mDepth[1] & 0xfc);
+        }
+        return 0xff;
+    }
+
     static ShadowManager* mspShadowManager;
 
 //private:

include/Osako/shadowModel.h

@@ -3,6 +3,7 @@
 
 #include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/J3D/J3DAnmCluster.h"
+#include "JSystem/J3D/J3DSkinDeform.h"
 #include "Kaneshige/ViewCtrlModel.h"
 
 class ShadowModel : public ViewCtrlModel
@@ -16,8 +17,14 @@ public:
         cShadowKind_SkyShip // based of TMapObjSkyShip::getShadowKind() const
     };
 
-    ShadowModel(u8, ShadowModel::ShadowKind, u8);       // 0x801a6e6c
+    ShadowModel(u8 flags, ShadowKind kind, u8 p3) : ViewCtrlModel(flags)
-    virtual void createModel(JKRSolidHeap *, u32, u32); // 0x801f7154, override
+    {
+        mKind = kind;
+        _94 = p3;
+        _95 = 0;
+    }
+
+    virtual bool createModel(JKRSolidHeap *, u32, u32); // 0x801f7154, override
 private:
     ShadowKind mKind;
     u8 _94;
@@ -34,12 +41,21 @@ public:
     }
 
     virtual void calc();                                // 0x801f71d0
-    virtual void createModel(JKRSolidHeap *, u32, u32); // 0x801f732c, override
+    virtual bool createModel(JKRSolidHeap *, u32, u32); // 0x801f732c, override
+
+    void setScale(f32 x, f32 y)
+    {
+        mScaleX = x;
+        mScaleY = y;
+    }
+    void setRoll(f32 roll) { mRoll = roll; }
+    void setPosY(f32 y) { mPosY = y; }
 
     // Inline Functions
     void setAnmCluster(J3DAnmCluster *anmCluster) { mAnmCluster = anmCluster; }; // 0x801a738c
     void setDeformData(J3DDeformData *deformData) { mDeformData = deformData; }; // 0x801a7394
-private:
+
+protected:
     J3DDeformData *mDeformData; // 0x98
     J3DAnmCluster *mAnmCluster; // 0x9c
     f32 mRoll;                  // 0xa0

include/Osako/system.h

@@ -71,7 +71,7 @@ namespace System
     u32 get2DScisY();
     u32 get2DScisW();
     u32 get2DScisH();
-    u32 get3DScisX();
+    u32 get3DScisX(); // TODO: return types might be int for get3DScisX and get3DScisY
     u32 get3DScisY();
     u32 get3DScisW();
     u32 get3DScisH();
@@ -122,7 +122,6 @@ namespace System
     inline JKRTask *getAramTask() { return mspAramTask; }
 };
 
-
 #ifndef REGION_EU
     #define SYSTEM_ChangeVideoMode() \
         System::changeProgressive()

include/Sato/GeographyObj.h

@@ -1,8 +1,10 @@
 #ifndef GEOGRAPHYOBJ_H
 #define GEOGRAPHYOBJ_H
 
-#include <JSystem/JKernel/JKRHeap.h>
 #include <JSystem/J3D/J3DModel.h>
+#include <JSystem/JKernel/JKRHeap.h>
+#include <JSystem/JGeometry/Vec.h>
+
 #include "Kaneshige/Course/CrsData.h"
 #include "Kaneshige/Course/CrsGround.h"
 #include "Osako/shadowModel.h"
@@ -49,7 +51,7 @@ public:
     bool tstUserFlg1(int kart_index) const;                                                     // 0x8022a0ec
     void clrUserFlg1(int);                                                                      // 0x8022a190
     void setUserFlg1(int);                                                                      // 0x8022a230
-    void getHitSoundDegree();                                                                   // 0x8022a2d0                                                                   
+    void getHitSoundDegree();                                                                   // 0x8022a2d0
     void createMultiBoundsPtrAll(u8);                                                           // 0x8022a314
     void calcBoundsGlPos();                                                                     // 0x8022a420
     void createBoundsSphere(f32, f32);                                                          // 0x8022a57c
@@ -82,6 +84,8 @@ public:
     void setLODBias();
     void getColRadius();
 
+    void getPosition(JGeometry::TVec3f *pos) const { *pos = mPos; } 
+
     // Vtable
     virtual ~GeographyObj() {}                                                                // 0x801b48cc, TODO?
     virtual void loadmodel(J3DModelData *modelData);                                          // 0x801b4c28, TODO
@@ -99,8 +103,8 @@ public:
     virtual void setCurrentViewNo(u32);                                                       // 0x80229700
     virtual u32 getMotorType() const { return 1; }                                            // 0x801b4cf0, probably an Enum
     virtual u32 getSoundID() const;                                                           // 0x8022a308, probably a define
-    virtual char *getBmdFileName() { return nullptr; }                                        // 0x801c59a8
+    virtual const char *getBmdFileName() { return nullptr; }                                  // 0x801c59a8
-    virtual char *getShadowBmdFileName() { return nullptr; }                                  // 0x801b4cf8
+    virtual const char *getShadowBmdFileName() { return nullptr; }                            // 0x801b4cf8
     virtual u32 getJ3DModelDataTevStageNum() const { return 0x20000; }                        // 0x801b4d00
     virtual void createColModel(J3DModelData *);                                              // 0x8022ab5c
     virtual void createBoundsSphere(J3DModelData *);                                          // 0x8022a498
@@ -114,7 +118,10 @@ public:
     virtual void initClassCreateNum();                                                        // 0x801b4d5c
     virtual void setModelMatrixAndScale();                                                    // 0x802297e0
 private:
+
+    JGeometry::TVec3f mPos; // 04
+    u8 _10[0x13c];
     // TODO
-}; // class GeographyObj
+}; // Size: 0x14c
 
 #endif

include/Sato/GeographyObjMgr.h

@@ -9,21 +9,26 @@
 class GeographyObjManager : JKRDisposer
 {
 public:
-    GeographyObjManager(const CrsData & );   
+    GeographyObjManager(const CrsData &);
-    static void createMgr(const CrsData & crsData) {
+
-        gMgr = new GeographyObjManager(crsData);
-    }
     void calc();
     void createModel(JKRSolidHeap *, u32);
-    void reset(const CrsData&);
+    void reset(const CrsData &);
-    static GeographyObjManager *getGeographyObjManager() { return gMgr; }
+    
     TJugem *getJugem(int camera_index) const;
-    TBalloonManager* getBalloonMgr(int kart_index) const;
+    TBalloonManager *getBalloonMgr(int kart_index) const;
-    static GeographyObjManager * gMgr;
 
-    u8 _18[0x3FC - 0x18];
+    f32 getKartHitDepthNormalObj(int kart_index) const { return mHitDepth[kart_index]; }
-    TJugem * mJugem[4]; // 0x3FC
+    static void createMgr(const CrsData &crsData) { gMgr = new GeographyObjManager(crsData); }
-    u8 _40C[0x4A4 - 0x40C];
+    static GeographyObjManager *getGeographyObjManager() { return gMgr; }
+
+    static GeographyObjManager *gMgr;
+
+    u8 _18[0x2A8 - 0x18];   //
+    f32 mHitDepth[8];       // 2A8
+    u8 _328[0x3FC - 0x2C8]; //
+    TJugem *mJugem[4];      // 3FC
+    u8 _40C[0x4A4 - 0x40C]; //
 
 }; // size 0x4A4
 

include/Sato/ItemObjMgr.h

@@ -4,7 +4,8 @@
 #include "JSystem/JKernel/JKRHeap.h"
 #include "types.h"
 
-class ItemObjMgr {
+class ItemObjMgr
+{
 public:
     ItemObjMgr();
     virtual ~ItemObjMgr();
@@ -23,40 +24,47 @@ public:
 
     static ItemObjMgr *getItemObjMgr() { return gItemMgr; }
 
-    static ItemObjMgr * gItemMgr;
+    static ItemObjMgr *gItemMgr;
 
     static bool sTempSlotUseItem[18];
     static int sTempSpecialRatio[9];
+
 private:
     unsigned char _0x4[0x828 - 0x4];
 };
 
-inline ItemObjMgr *GetItemObjMgr() {
+inline ItemObjMgr *GetItemObjMgr()
+{
     return ItemObjMgr::getItemObjMgr();
 }
 
-class ItemShuffleMgr {
+class ItemShuffleMgr
+{
 public:
-    struct SlotTable {
+    struct SlotTable
+    {
         u8 chance[27];
         u8 total; // i don't know wheter or not this is used but 1 byte is not always enough to store this
     };
 
-    class KartSlotList {
+    class KartSlotList
+    {
     public:
         KartSlotList();
-        SlotTable * slotTable[2];
+        SlotTable *slotTable[2];
     };
 
-    struct KartSlotData {
+    struct KartSlotData
+    {
         u8 kartCount;
         u8 useableSlots;
         u8 totalSlots;
-        KartSlotList* mList;
+        KartSlotList *mList;
     };
 
-    struct KartSlotRankDataSet {
+    struct KartSlotRankDataSet
-        KartSlotData* data;
+    {
+        KartSlotData *data;
         u32 specialItemIndex;
         u32 specialItemChance;
         int kart_rank;
@@ -66,16 +74,17 @@ public:
     static KartSlotData mSlotList;
     static KartSlotData mSlotListEnemy;
 
-    static u8 sSlotNormalItemNum; // 9
+    static u8 sSlotNormalItemNum;  // 9
     static u8 sSlotSpecialItemNum; // 9
     static u32 *sSlotKindIndexArray;
 
-    ItemShuffleMgr() {
+    ItemShuffleMgr()
+    {
         _0x4 = 0;
         _0x5 = 0;
     }
 
-    int calcSlot(KartSlotRankDataSet & slotRankData, int p2, int p3, bool p4);
+    int calcSlot(KartSlotRankDataSet &slotRankData, int p2, int p3, bool p4);
 
     virtual ~ItemShuffleMgr();
     virtual void calcRaceUseNormalItem(u32 *, KartSlotRankDataSet *, int);
@@ -90,7 +99,8 @@ private:
     int idx;
 };
 
-class ItemRndSpecialShuffleMgr : public ItemShuffleMgr {
+class ItemRndSpecialShuffleMgr : public ItemShuffleMgr
+{
 public:
     virtual ~ItemRndSpecialShuffleMgr();
     virtual void calcRaceUseNormalItem(u32 *, KartSlotRankDataSet *, int);

include/Sato/ObjUtility.h

@@ -1,9 +1,31 @@
 #ifndef OBJUTILITY_H
 #define OBJUTILITY_H
 
+#include <JSystem/JGeometry.h>
+
+#include "types.h"
+
 namespace ObjUtility
 {
-    extern void *getPtrCourseArc(char *);
+    void getPtrMainArc(char *);                                                             // 0x8025dc08
+    void *getPtrCourseArc(char *);                                                          // 0x8025dc30
+    void getPtrMainLocaleArc(char *);                                                       // 0x8025dc58
+    void setRMtx(Mtx, const JGeometry::TVec3f &, const JGeometry::TVec3f &);                // 0x8025dc80
+    void executeShakeCamera(const JGeometry::TVec3f &, f32, f32, f32);                      // 0x8025dcf4
+    void getKartBodyMtx(int);                                                               // 0x8025de7c
+    void getKartPos(int, JGeometry::TVec3f *);                                              // 0x8025df6c
+    void getKartXdir(int, JGeometry::TVec3f *);                                             // 0x8025e0cc
+    void getKartYdir(int, JGeometry::TVec3f *);                                             // 0x8025e234
+    void getKartZdir(int, JGeometry::TVec3f *);                                             // 0x8025e39c
+    void getKartVel(int, JGeometry::TVec3f *);                                              // 0x8025e504
+    void getKartEfctVel(int, JGeometry::TVec3f *);                                          // 0x8025e5a0
+    void findNearKart(const JGeometry::TVec3f &, f32, int);                                 // 0x8025e63c
+    void findNearKartAngle(const JGeometry::TVec3f &, const JGeometry::TVec3f &, f32, f32); // 0x8025e868
+    void getCamDependLightMtx(u32, const JGeometry::TVec3f &, Mtx);                         // 0x8025ec6c
+    bool isPlayerDriver(const int &);                                                       // 0x8025edb0
+    void getReflectVec(JGeometry::TVec3f, JGeometry::TVec3f, JGeometry::TVec3f *, bool);    // 0x8025eeb4
+    void chkAvailableEnemyByDistande(bool *, f32);                                          // 0x8025f118
+    void concatSimpleFileName(char *, u8);                                                  // 0x8025f514
 }
 
 #endif

include/Sato/RivalBodyCtrl.h

@@ -0,0 +1,116 @@
+#ifndef RIVALBODYCTRL_H
+#define RIVALBODYCTRL_H
+
+#include <JSystem/JKernel/JKRDisposer.h>
+
+#include "Kaneshige/Course/CrsGround.h"
+#include "Sato/RivalCtrlBase.h"
+
+class RivalBodyCtrl : public RivalCtrlBase, JKRDisposer
+{
+public:
+    RivalBodyCtrl(RivalKart *);                    // 0x802804f4
+    void init();                                   // 0x802805e4
+    static void reset();                           // 0x80280724
+    static void setRankArray();                    // 0x80280864
+    static void chkPlayerKartCondition();          // 0x80280aec
+    void chkBodyCondition();                       // 0x80280bec
+    void getKartIndexByRank(int);                  // 0x80280ca0
+    void calcTargetPosDrift();                     // 0x80280ea4
+    void calcTargetPosNormal(float);               // 0x80280ea8
+    void getFwPointPos(JGeometry::TVec3f *);       // 0x80281068
+    void getPointRSideDir(JGeometry::TVec3f *);    // 0x802810ac
+    void getLengthFCenter();                       // 0x802811b4
+    void isNeighborhoodCenter(float);              // 0x8028135c
+    void getDriftTargetDir(JGeometry::TVec3f *);   // 0x802813d0
+    void getTargetCurveLR(float *, short);         // 0x80281558
+    void chkDriftPoint();                          // 0x802818a8
+    void chkArrivePoint(CLPoint *);                // 0x80281a54
+    void initDrift(bool, CLPoint *);               // 0x80281b24    
+    void reviseAfterDriftVtTargetPos();            // 0x80282364    
+    void doColWallCtrl();                          // 0x80282888
+    void calcMaxChangeWaitCnt();                   // 0x80282cb4    
+    void comebackRescure(CLPoint *, bool);         // 0x80282cf8
+    void resetBodyData();                          // 0x80283054
+    void isOneUpperLowerPlayer(bool);              // 0x802830e4
+    void getLowestPlayerDist(float *);             // 0x802831f4
+    void findMyRankOnlyCom();                      // 0x802832cc
+    int getTopComKartIndex(RivalBodyCtrl *);       // 0x80283324
+    void getMyFowardComKartIndex();                // 0x802833e0
+    void getMyBackwardComKartIndex(unsigned char); // 0x802834e0
+    void setDriftInfo();                           // 0x802835f4
+    void doRotPose(JGeometry::TVec3f, float);      // 0x80283858
+
+    // Vtable
+    virtual ~RivalBodyCtrl();                              // 0x8028056c, 14
+    virtual void doSterrCtrl();                            // 0x8028251c, 18
+    virtual void doDriftCtrl();                            // 0x80282070, 1c
+    virtual void doStateFlgCtrl();                         // 0x80282cf4, 20
+    virtual void doChangeDriverCtrl();                     // 0x80282aa8, 24
+    virtual void doRotPosSterr(const JGeometry::TVec3f &); // 0x80282650, 28
+    virtual void doNextPoint(bool);                        // 0x80280d5c, 2c
+    virtual void resetPointData();                         // 0x80282dd4, 30
+
+    // void sKartRankArray;                                 // 0x804138d4
+    // void sComKartRankArray;                              // 0x80413994
+    // void sKartTotalDist;                                 // 0x804139b4
+    // void sPlayerRank;                                    // 0x804139d4
+    // void sTopPlayerIndex;                                // 0x8041503c
+    // void sLowestPlayerKartIndex;                         // 0x80415040
+    // void sLowestComKartIndex;                            // 0x80415044
+    // void sCrsStdDistRatio;                               // 0x80415048
+    // void sEngineBParamPtr;                               // 0x80416d20
+    // void sCommonFlgs;                                    // 0x80416d24
+    // void sCheckTopDistRatio;                             // 0x80416d28
+
+    // void getNthCLPoint(CLPoint *, short);
+    // void getVtLengthFCenter();
+    // void calcDriftTargetDir();
+    // void getPointDir(const CLPoint *, JGeometry::TVec3f *);
+    // void getLRKartTargetDir();
+    // void getAngleKartZdirTargetDir();
+    // void doDriftStageCount();
+    // void setDriftStageWaitFrame();
+    // void doRotTurnAndChangeState(RivalCtrlBase::RivalMoveState);
+    // void isRank1st();
+    // void isLowerPlayer(const float &);
+    // void isLowestRankOfCom();
+    // void getFowardPlayerDist();
+    // void getBackwardPlayerDist();
+    // void getTopPlayerDist();
+    // void findRivalDistanceFrontAngle(float, float);
+    // void findRivalDistanceRearAngle(float, float);
+    
+
+    u8 _20[0xc8 - 0x20];
+}; // Size: 0xc8
+
+class CLPointControllerRivalKart
+{
+public:
+    CLPointControllerRivalKart(RivalBodyCtrl *);
+    virtual int findNextPointNo(CLPoint *);
+};
+
+class RivalAwardBodyCtrl : public RivalBodyCtrl
+{
+public:
+    RivalAwardBodyCtrl(RivalKart *);
+    virtual void doNextPoint(bool);
+    virtual void doRotPosSterr(const JGeometry::TVec3f &);
+    virtual ~RivalAwardBodyCtrl() {} // 0x8028416c
+    virtual void doDriftCtrl();       // 0x80284438
+    virtual void doChangeDriverCtrl(); // 0x8028443c
+};
+
+class RivalAward2ndBodyCtrl : public RivalBodyCtrl
+{
+public:
+    RivalAward2ndBodyCtrl(RivalKart *);
+    virtual void doSterrCtrl();
+    void calcVtTargetPos();
+    void doNextPoint(bool);
+    virtual ~RivalAward2ndBodyCtrl() {} // 0x80284440
+};
+
+#endif // RIVALBODYCTRL_H

include/Sato/RivalCtrlBase.h

@@ -0,0 +1,36 @@
+#ifndef RIVALCTRLBASE_H
+#define RIVALCTRLBASE_H
+
+#include "types.h"
+
+class RivalKart;
+
+class RivalCtrlBase
+{
+public:
+    class RankParam
+    {
+    public:
+        RankParam(int);
+        void reset();
+    };
+
+    RivalCtrlBase(RivalKart *);
+    void getMyID();
+    void getBodyCtrl();
+    void getBody();
+    void getRandom();
+    void getRankParamID();
+    void tstEndRace();
+    void isRival() const;
+    void getMyRank();
+    // Inline/Unused
+    // void getSpeedCtrl();
+    // void getItemCtrl();
+
+    virtual ~RivalCtrlBase() {} // 0x8027ea9c
+
+    RivalKart *mRival;
+};
+
+#endif

include/Sato/RivalItemCtrl.h

@@ -0,0 +1,71 @@
+#ifndef RIVALITEMCTRL_H
+#define RIVALITEMCTRL_H
+
+#include <JSystem/JKernel/JKRDisposer.h>
+
+#include "Sato/RivalCtrlBase.h"
+#include "Sato/ItemObj.h"
+#include "types.h"
+
+class RivalKart;
+
+class RivalItemCtrl : RivalCtrlBase, JKRDisposer
+{ 
+public:
+    RivalItemCtrl(RivalKart *);          // 0x8027ea50
+    void init();                         // 0x8027eb5c
+    void reset();                        // 0x8027eb7c
+    void doItemCtrl();                   // 0x8027ebb8
+    void startItem(ItemObj *);           // 0x8027ed9c
+    void execute_endItemParam();         // 0x8027ee0c
+    void set_endItemParam();             // 0x8027ee44
+    void setThrowFlg(bool);              // 0x8027ee74
+    void initItem_GTurtle();             // 0x8027efb0
+    void useItem_GTurtle_Normal();       // 0x8027f00c
+    void initItem_GTurtleSuc();          // 0x8027f0a0
+    void useItem_GTurtleSuc_Normal();    // 0x8027f150
+    void initItem_RTurtle();             // 0x8027f3a8
+    void useItem_RTurtle_Normal();       // 0x8027f404
+    void initItem_Bomb();                // 0x8027f498
+    void initItem_YoshiEgg();            // 0x8027f4f4
+    void useItem_YoshiEgg_Normal();      // 0x8027f550
+    void useItem_Bomb_Normal();          // 0x8027f630
+    void initItem_Banana();              // 0x8027f710
+    void useItem_Banana_Normal();        // 0x8027f764
+    void initItem_Kinoko();              // 0x8027f840
+    void useItem_Kinoko_Normal();        // 0x8027f89c
+    void initItem_KinokoSuc();           // 0x8027f9bc
+    void useItem_KinokoSuc_Normal();     // 0x8027fa6c
+    void initItem_GoldenKinoko();        // 0x8027fb24
+    void useItem_GoldenKinoko();         // 0x8027fb80
+    void initItem_Star();                // 0x8027fcd4
+    void useItem_Star_Normal();          // 0x8027fd30
+    void initItem_Thunder();             // 0x8027fde8
+    void useItem_Thunder_Normal();       // 0x8027fe44
+    void initItem_WanWan();              // 0x8027fe74
+    void useItem_WanWan_Normal();        // 0x8027fed0
+    void triggerButton();                // 0x8027ff00
+    void triggerButtonStickFront(float); // 0x8027fff4
+    void triggerButtonStickBack(float);  // 0x802800f8
+    // Inline/Unused
+    // void resetSucItem(ItemObj *);
+    // void endItem();
+    // void setRndCount(unsigned long, unsigned long);
+    // void setRndFlgItemFront(float);
+    // void chkEnableThrowBack();
+    // void initItem_RTurtleSuc();
+    // void useItem_RTurtleSuc_Normal();
+    // void doSpReleaseGTurtle();
+    // void releaseBombFront(const float &, const float &);
+    // void doUseKinoko();
+    // void pressButton();
+    // void releaseButton();
+    // void releaseButtonStickFront(float);
+    // void releaseButtonStickBack(float);
+    // Inline
+    virtual ~RivalItemCtrl(); // 0x8027eae4
+
+    u8 _20[0x44 - 0x20];
+}; // Size: 0x44
+
+#endif // RIVALITEMCTRL_H

include/Sato/RivalKart.h

@@ -4,29 +4,51 @@
 #include <JSystem/JKernel/JKRDisposer.h>
 
 class KartBody;
+class KartSus;
+class RivalBodyCtrl;
+class RivalItemCtrl;
+class RivalSpeedCtrl;
 
-class RivalKart
+class RivalKartBase
+{ // fabricated
+    u32 _0;
+};
+
+class RivalKart : RivalKartBase, JKRDisposer
 { // Autogenerated
 public:
     // Global
-    RivalKart(KartBody *);           // 0x80270f9c
+    RivalKart(KartBody *body); // 0x80270f9c
-    virtual ~RivalKart();            // 0x8027117c(inline)
+    virtual ~RivalKart();      // 1c
-    void Init();                     // 0x802711e0
+
-    void StartInit();                // 0x80271228
+    void Init();                   // 0x802711e0
-    static void Reset();             // 0x80271250
+    static void StartInit();       // 0x80271228
-    void ResetInit();                // 0x80271274
+    static void Reset();           // 0x80271250
-    void setRankAry();               // 0x802712bc
+    void ResetInit();              // 0x80271274
-    void getMaxSpeed() const;        // 0x802712e0
+    static void setRankAry();      // 0x802712bc
-    void getOffsetMaxSpeed() const;  // 0x802712ec
+    f32 getMaxSpeed() const;       // 0x802712e0
-    void setMaxSpeed(const float &); // 0x802712f8
+    f32 getOffsetMaxSpeed() const; // 0x802712ec
-    void ContempLate();              // 0x80271308
+    void setMaxSpeed(const f32 &); // 0x802712f8
-    void ActiveCtrl();               // 0x80271398
+    void ContempLate();            // 0x80271308
+    void ActiveCtrl();             // 0x80271398
     // Inline/Unused
     // void InitParam();
-    // void getTargetPos(JGeometry::TVec3<float> *);
+    // void getTargetPos(JGeometry::TVec3f *);
-    // void getVtTargetPos(JGeometry::TVec3<float> *);
+    // void getVtTargetPos(JGeometry::TVec3f *);
     // void getRoadWidth();
     // void DoSearchTarget();
 
-}; // class RivalKart
+    RivalBodyCtrl *getBodyCtrl() { return mBodyCtrl; }
-#endif  // RIVALKART_H
+
+
+    KartBody *mBody;            // 20
+    KartSus *mSus[4];           // 24
+    int _34;                    // 34
+    int mNo;                    // 38
+    RivalBodyCtrl *mBodyCtrl;   // 3c
+    RivalItemCtrl *mItemCtrl;   // 40
+    RivalSpeedCtrl *mSpeedCtrl; // 44
+
+}; // 0x48
+
+#endif // RIVALKART_H

include/Sato/RivalSpeedCtrl.h

@@ -0,0 +1,109 @@
+#ifndef RIVALSPEEDCTRL_H
+#define RIVALSPEEDCTRL_H
+
+#include <JSystem/JKernel/JKRDisposer.h>
+
+#include "Sato/RivalCtrlBase.h"
+#include "Sato/RivalKart.h"
+
+class RivalSpeedCtrl : RivalCtrlBase, JKRDisposer
+{ // Autogenerated
+public:
+    RivalSpeedCtrl(RivalKart *);     // 0x8028460c
+    static void StartInit();         // 0x80284b84
+    static void ResetInit();         // 0x80284d24
+    static void LoadCrsLevelParam(); // 0x80284de0
+    void InitRndStartRank();         // 0x80284ed8
+    void getNowCrsIndex();           // 0x802850d0    
+    void init();                     // 0x80285210
+    void doPlayerDistSpeedCtrl();    // 0x802857a8
+    void doCurveDegSpdCtrl();        // 0x80285944
+    void doRankSpdCtrl();            // 0x80285abc
+    void resetRaceStrengthening();   // 0x80285fc4
+    void clampMaxSpeed();            // 0x8028603c
+    static f32 sCrsLevelParam;       // 0x803a2794
+    static f32 sStartRankList;       // 0x804139f4
+    static f32 *sEngineParamPtr;     // 0x80415090
+    static int sComStrengthState;    // 0x80415094
+    static int sRivalGPPoint;        // 0x80415098
+    static void *sStartRankPtr;      // 0x80416d30, some JSUList, too lazy to implement properly now
+    static u8 sConfusedFightModeFlg; // 0x80416d34
+    static u8 sComWeakPointSwapFlg;  // 0x80416d35
+
+    // Inline/Unused
+    // void JSULink<RivalStartRankParam>::~JSULink();
+    // void initCalc();
+    // void calcOffsetMaxSpd();
+    // void doAccident();
+    // void doUsually();
+    // void calcDriftSpdRatio();
+
+    // Vtable
+    virtual ~RivalSpeedCtrl() {}       // 0x80284b04, 14
+    virtual void reset();              // 0x802851a4, 18
+    virtual void doSpeedCtrl();        // 0x80285494, 1c
+    virtual void stop();               // 0x802868b4, 20
+    virtual void stop_immediately() {} // 0x801cf6b8, 24
+    virtual void set_speeddown() {}    // 0x801cf228, 28
+    virtual void doAccelCtrl();        // 0x80285884, 2c
+    virtual void initStartDash();      // 0x802852e4, 30
+
+    f32 getMaxSpeed() const { return mMaxSpeed; }
+    f32 getOffsetMaxSpeed() const { return mOffsetMaxSpeed; }
+    void setMaxSpeed(const float &max) { mMaxSpeed = max; }
+
+    u8 _20[0x34 - 0x20];
+    f32 mMaxSpeed; // 34
+    u8 _38[0x3c - 0x38];
+    f32 mOffsetMaxSpeed;
+    u8 _40[0x4c - 0x40];
+}; // Size: 0x4c
+
+class RivalAwardDemoSpeedCtrl : public RivalSpeedCtrl
+{
+public:
+    RivalAwardDemoSpeedCtrl(RivalKart *);
+    void reset();
+    virtual void initStartDash();
+    virtual void doAccelCtrl();
+    void doAccelMaxSpdCtrl();
+    void doSpeedCtrl();
+
+    void stop(); // 0x80286730
+
+    void stop_immediately(); // 0x802867f8
+
+    u8 _4c[0x4];
+};
+
+class RivalAwardDemo2ndSpeedCtrl : public RivalAwardDemoSpeedCtrl
+{
+public:
+    RivalAwardDemo2ndSpeedCtrl(RivalKart *);
+    void reset();
+    void doAccelMaxSpdCtrl();
+    void doAccelCtrl();
+
+    virtual void set_speeddown();                  // 0x802867ec
+    virtual ~RivalAwardDemo2ndSpeedCtrl(); // 0x80286804
+
+    u8 _50[0x8];
+};
+
+class RivalStaffRollDemoSpeedCtrl : public RivalAwardDemoSpeedCtrl
+{
+public:
+    RivalStaffRollDemoSpeedCtrl(RivalKart *);
+    void reset();
+    void doSpeedCtrl();
+    void stop_immediately();                // 0x80286724
+    virtual ~RivalStaffRollDemoSpeedCtrl(); // 0x8028673c
+    u8 _50[0x4];
+};
+
+// Inline function in TU
+
+// void RivalBodyCtrl::getKartTotalDist(int); // 0x80285fb0
+// virtual JSUList<RivalStartRankParam>::~JSUList()  // 0x802869e8
+
+#endif // RIVALSPEEDCTRL_H

include/Sato/StateObserver.h

@@ -9,14 +9,16 @@ public:
 
     void setState(u16);
 
+    u16 getState() const { return mState; }
+
     // Vtable
-    /*virtual ~StateObserver();
+    virtual ~StateObserver();
     virtual void MoveExec() = 0;
-    virtual void InitExec() = 0;*/
+    virtual void InitExec() = 0;
 
 private:
     u16 _4;
-    u16 _6;
+    u16 mState;
     u32 _8;
 };
 

include/Shiraiwa/JugemMain.h

@@ -1,28 +1,36 @@
 #ifndef JUGEMMAIN_H
 #define JUGEMMAIN_H
 
+#include "Sato/GeographyObj.h"
 #include "Sato/StateObserver.h"
 #include "Shiraiwa/JugemRodSignal.h"
 // perhaps this could go in it's own file
 // Inherited from GeographyObj, StateObserver and TAnmPlayer?
-struct TJugem {
+// Todo: GeographyObj -> TMapObjHioNode
-    void signalGo() {
+class TJugem : GeographyObj, StateObserver
+{
+public:
+    TJugem();
+
+    void signalGo()
+    {
         _0x250 = true;
-        mObserver.setState(0);
+        setState(0);
-        
     };
-    bool isAbleStart();/* {
+    bool isAbleStart(); /* {
-        return true;
+         return true;
-    }*/
+     }*/
-    bool isCallThree() {
+    bool isCallThree()
+    {
         return !mJugemRod ? false : mJugemRod->isCallThree();
     }
-    u8 _0[0x14c];
+
-    StateObserver mObserver; // Temporary
+    int getSignalState();
-    u8 _0x154[0x250 - 0x154];
+
+    u8 _0x158[0x250 - 0x158];
     bool _0x250;
     u8 _0x251[0x26c - 0x251];
-    TJugemRodSignal * mJugemRod;
+    TJugemRodSignal *mJugemRod;
 };
 
 #endif

include/Shiraiwa/MapObjAntLion.h

@@ -0,0 +1,56 @@
+#ifndef MAPOBJANTLION_H
+#define MAPOBJANTLION_H
+
+#include <JSystem/J3D.h>
+#include <JSystem/JKernel/JKRHeap.h>
+
+#include "Kaneshige/Course/CrsData.h"
+#include "Sato/GeographyObj.h"
+#include "Sato/StateObserver.h"
+
+#include "types.h"
+
+class TMapObjHioNode : public GeographyObj
+{
+public:
+    virtual ~TMapObjHioNode();
+};
+
+class TMapObjAntLion : public TMapObjHioNode, StateObserver
+{
+public:
+    // Global
+    TMapObjAntLion(const CrsData::SObject &);        // 0x802cdf80
+    virtual const char *getBmdFileName();            // 0x802ce0d8
+    void createColModel(J3DModelData *);             // 0x802ce100
+    void loadAnimation();                            // 0x802ce184
+    void createModel(JKRSolidHeap *, unsigned long); // 0x802ce1d0
+    void reset();                                    // 0x802ce3dc
+    void calc();                                     // 0x802ce440
+    void initFunc_Start();                           // 0x802ce494
+    void doFunc_Start();                             // 0x802ce4d4
+    void initFunc_Wait();                            // 0x802ce4fc
+    void doFunc_Wait();                              // 0x802ce5a4
+    void initFunc_Eat();                             // 0x802ce5a8
+    void doFunc_Eat();                               // 0x802ce748
+    void getZDir(JGeometry::TVec3f *);               // 0x802ce7e4
+    void doKartColCallBack(int);                     // 0x802ce884
+
+    void eat() {
+        if(getState() != 2) {
+            setState(2);
+        }
+    }
+
+    // void sTable;                                     // 0x803aa258
+    // void scJointName;                                // 0x804154b8
+    // void sAntLionBckAnmTrans;                        // 0x80417118
+    // void sAntLionBckMtxCalc;                         // 0x8041711c
+    // void sJointNo;                                   // 0x80417120
+    //  Inline
+    virtual ~TMapObjAntLion(); // 0x802ce010
+    void InitExec();           // 0x802ce304
+    void MoveExec();           // 0x802ce370
+};
+
+#endif // MAPOBJANTLION_H

include/Shiraiwa/SiUtil.h

@@ -0,0 +1,35 @@
+#ifndef SIUTIL_H
+#define SIUTIL_H
+
+#include <JSystem/JGeometry.h>
+
+#include "Sato/GeographyObj.h"
+
+#include "types.h"
+
+namespace SiUtil
+{ // Autogenerated
+    // Global
+    void checkPassFrame(f32, f32, f32);                                                                                  // 0x802a7038
+    void getViewport(JGeometry::TBox2f *, u8, u8);                                                                       // 0x802a709c
+    void getViewport(JGeometry::TBox2f *, u8);                                                                           // 0x802a71ec
+    void getScreenPosCheckMirror(int, const JGeometry::TVec3f &, JGeometry::TVec2f *);                                   // 0x802a7290
+    void getScreenPos(int, const JGeometry::TVec3f &, JGeometry::TVec2f *, bool);                                        // 0x802a72cc
+    void setItemReaction(const void *, GeographyObj *);                                                                  // 0x802a7474
+    void clampVec(const JGeometry::TVec3f &, JGeometry::TVec3f &, const JGeometry::TVec3f &, const JGeometry::TVec3f &); // 0x802a7644
+    f32 getNormalRange(f32, f32, f32);                                                                                  // 0x802a76cc
+    int getConsoleNum();                                                                                                // 0x802a76f8
+    int getDrawConsoleNum();                                                                                            // 0x802a7790
+    void getCourseHeight(JGeometry::TVec3f &);                                                                           // 0x802a7828
+    void searchNearKartBall(const JGeometry::TVec3f &, f32);                                                             // 0x802a7874
+    void searchNearKartCircle(const JGeometry::TVec3f &, f32);                                                           // 0x802a7950
+    void setRandomStartFrame(J3DFrameCtrl *, stRandom *rand);                                                            // 0x802a7a30
+    // Inline/Unused
+    // void getMultiple(u16, u16, bool);
+    // void getBufferImage(u8 *, u16, u16, u16, u16, bool);
+    // void drawBufferImage(_GXTexObj *, short, short, u16, u16);
+    // void initGX(JUtility::TColor);
+    // void getWaterHeight(JGeometry::TVec3f &);
+    // void searchNearKartCylinder(const JGeometry::TVec3f &, f32, f32);
+};     // namespace SiUtil
+#endif // SIUTIL_H

include/Shiraiwa/Wipe.h

@@ -0,0 +1,237 @@
+#ifndef WIPE_H
+#define WIPE_H
+
+#include <JSystem/J2D/J2DGrafContext.h>
+#include <JSystem/JKernel/JKRHeap.h>
+#include <JSystem/JUtility/JUTTexture.h>
+#include "types.h"
+
+// TODO: static member variables, possible errors
+
+class TWipeBase
+{
+public:
+    TWipeBase(JKRHeap *heap);
+
+    JUTTexture *getTexture(u32 id);
+
+    static void createBuffer(int, JKRHeap *heap);
+
+    virtual ~TWipeBase();                          // 08
+    virtual void init();                           // 0C
+    virtual void draw(int, f32, JUTColor);         // 10
+    virtual void calc(int, f32, JUTColor);         // 14
+    virtual void reset();                          // 18
+    virtual void calcMain(int, f32, JUTColor) = 0; // 1C
+    virtual void changeState(int, int);            // 20
+    virtual void drawPreIn(int, JUTColor);         // 24
+    virtual void drawPreOut(int, JUTColor) {}      // 28
+    virtual void drawMain(int, f32, JUTColor) = 0; // 2C
+
+    // Unused
+    static void loadTexture(JKRHeap *heap);
+    void deleteBuffer();
+
+private:
+    static const char *scTextureName[3];
+    static JUTTexture *sTexture[3];
+
+    // Unused/Deadstripped
+    static u8 sBuffer[0x10];
+    static const u8 scBufSize;
+    static const int scPortMax;
+
+protected:
+    J2DOrthoGraph **mGraph;
+    u8 mConsoleNum;
+    int mWipeState[4];
+};
+
+class TWipeCheck : public TWipeBase
+{
+public:
+    TWipeCheck(JKRHeap *heap);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+
+    virtual ~TWipeCheck();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawPreIn(int, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+
+private:
+    static s16 sWipeHeightOrg;
+    static s16 sWipeWidthOrg;
+    static f32 sAlphaDiffRate;
+
+    u8 mAlpha[4];
+    u8 mAlphaDiff[4];
+    JGeometry::TBox2f mVp;
+};
+
+class TWipeCircle : public TWipeBase
+{
+public:
+    TWipeCircle(JKRHeap *heap);
+
+    void initGX();
+    void drawBufferImage(JUTTexture *, JGeometry::TBox2f &, JGeometry::TBox2f &);
+
+    virtual ~TWipeCircle();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+
+private:
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    u32 _1c;
+    u32 _20[4];
+    JGeometry::TVec2f mPos[4];
+    u8 _50[0x64 - 0x50];
+    f32 _64[4];
+};
+
+class TWipeCurtain : public TWipeBase
+{
+public:
+    TWipeCurtain(JKRHeap *heap);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+    void drawImage(JUTTexture *, f32, f32, f32, f32);
+    void initGXForTex(JUTColor);
+
+    virtual ~TWipeCurtain();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+    virtual void drawPreIn(int, JUTColor);
+
+private:
+    static f32 sLineWidth;
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    f32 mHeight[4];
+};
+
+class TWipeLineA : public TWipeBase
+{
+public:
+    TWipeLineA(JKRHeap *);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+
+    virtual ~TWipeLineA();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+private:
+    static s16 sWipeLineWidth;
+    static s16 sWipeProgressLines;
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    f32 mOffset[4];
+};
+
+class TWipeLineB : public TWipeBase
+{
+public:
+    TWipeLineB(JKRHeap *heap);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+
+    virtual ~TWipeLineB();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+
+private:
+    static s16 sWipeLineHeight;
+    static s16 sWipeProgressLines;
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    f32 mOffset[4];
+};
+
+class TWipeShut : public TWipeBase
+{
+public:
+    TWipeShut(JKRHeap *heap);
+
+    void initGX();
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+    void drawTriangle(JGeometry::TVec2f *, const JUTColor &);
+
+    virtual ~TWipeShut();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+
+private:
+    static s16 scWipeHeadHeight;
+    static s16 scWipeHeadWidth;
+    static f32 sChangeRate;
+    static f32 sSecondWidthOrg;
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    f32 mWidth[4];
+};
+
+class TWipeSlide : public TWipeBase
+{
+public:
+    TWipeSlide(JKRHeap *heap);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+    void drawImage(JUTTexture *, bool, f32, f32, f32, f32);
+    void initGXForTex(JUTColor);
+
+    virtual ~TWipeSlide();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+
+private:
+    static u8 sWipePatternMask;
+
+    s16 _1c[4];
+    f32 _24[4];
+    u8 _34[4];
+    u8 mPattern;
+    // u8 _0x2c[0x10];
+};
+
+class TWipeWaveA : public TWipeBase
+{
+public:
+    TWipeWaveA(JKRHeap *heap);
+
+    void drawQuad(f32, f32, f32, f32, const JUTColor &);
+    void initGX(const JUTColor &);
+    
+
+    virtual ~TWipeWaveA();
+    virtual void init();
+    virtual void calcMain(int, f32, JUTColor);
+    virtual void drawMain(int, f32, JUTColor);
+    virtual void drawTex(f32, f32, f32, f32, f32, f32);
+
+private:
+    static f32 sWipeMoveRateMax;
+    static f32 sWipeStartPos;
+    static f32 sWipeHeadWidth;
+    static f32 sWipeHeadHeight;
+    static f32 sAlphaMinRate;
+    static f32 sAlphaMaxRate;
+
+    f32 mOffsetY[4];
+    u32 _2c; // unused?
+};
+
+#endif

include/Yamamoto/KartAnime.h

@@ -1,41 +1,44 @@
 #ifndef KARTANIME_H
 #define KARTANIME_H
 
+#include "types.h"
+
 class KartAnime
 { // Autogenerated
+public:
     KartAnime() {}
 
 public:
-    void IsAppeal(int);                 // 0x802f9a5c
+    bool IsAppeal(int);                 // 0x802f9a5c
-    void IsThrow(int);                  // 0x802f9aa4
+    bool IsThrow(int);                  // 0x802f9aa4
-    void IsMove(int);                   // 0x802f9aec
+    bool IsMove(int);                   // 0x802f9aec
-    void IsSuspend(int);                // 0x802f9b34
+    bool IsSuspend(int);                // 0x802f9b34
-    void IsDamage(int);                 // 0x802f9bf8
+    bool IsDamage(int);                 // 0x802f9bf8
-    void IsDamageL(int);                // 0x802f9c40
+    bool IsDamageL(int);                // 0x802f9c40
-    void IsDamageS(int);                // 0x802f9c88
+    bool IsDamageS(int);                // 0x802f9c88
-    void IsRide(int);                   // 0x802f9cd0
+    bool IsRide(int);                   // 0x802f9cd0
-    void IsNormalStart(int);            // 0x802f9d18
+    bool IsNormalStart(int);            // 0x802f9d18
-    void IsBackStart(int);              // 0x802f9d60
+    bool IsBackStart(int);              // 0x802f9d60
-    void IsRun(int);                    // 0x802f9da8
+    bool IsRun(int);                    // 0x802f9da8
-    void IsDrift(int);                  // 0x802f9df0
+    bool IsDrift(int);                  // 0x802f9df0
-    void IsDriftStart(int);             // 0x802f9e38
+    bool IsDriftStart(int);             // 0x802f9e38
-    void IsDriftLeft(int);              // 0x802f9e80
+    bool IsDriftLeft(int);              // 0x802f9e80
-    void IsDriftRight(int);             // 0x802f9ec8
+    bool IsDriftRight(int);             // 0x802f9ec8
-    void IsChange(int);                 // 0x802f9f10
+    bool IsChange(int);                 // 0x802f9f10
-    void IsRocket(int);                 // 0x802f9f58
+    bool IsRocket(int);                 // 0x802f9f58
-    void IsJump(int);                   // 0x802f9fa0
+    bool IsJump(int);                   // 0x802f9fa0
-    void IsSit(int);                    // 0x802f9fe8
+    bool IsSit(int);                    // 0x802f9fe8
-    void IsBackAnime(int);              // 0x802fa030
+    bool IsBackAnime(int);              // 0x802fa030
-    void IsFloatAnime(int);             // 0x802fa078
+    bool IsFloatAnime(int);             // 0x802fa078
-    void IsDangerAnime(int);            // 0x802fa0c0
+    bool IsDangerAnime(int);            // 0x802fa0c0
-    void IsDangerLoopAnime(int);        // 0x802fa108
+    bool IsDangerLoopAnime(int);        // 0x802fa108
-    void IsDangerPlusAnime(int);        // 0x802fa17c
+    bool IsDangerPlusAnime(int);        // 0x802fa17c
-    void IsGetItemAnime(int);           // 0x802fa1c4
+    bool IsGetItemAnime(int);           // 0x802fa1c4
-    void IsBurnAnime(int);              // 0x802fa208
+    bool IsBurnAnime(int);              // 0x802fa208
-    void IsDrive(int);                  // 0x802fa250
+    bool IsDrive(int);                  // 0x802fa250
-    void IsBack(int);                   // 0x802fa298
+    bool IsBack(int);                   // 0x802fa298
-    void IsGaol(int);                   // 0x802fa2fc
+    bool IsGaol(int);                   // 0x802fa2fc
-    void IsAttack(int);                 // 0x802fa344
+    bool IsAttack(int);                 // 0x802fa344
     void IsProhibition(int);            // 0x802fa38c
     void MakeThrowAnime(int, int, int); // 0x802fa408
     void MakeBackAnime(int);            // 0x802fa424
@@ -97,9 +100,14 @@ public:
     // void MakeGetAnime(ItemObj *, int);
     // Inline
     void IsChangeStart(); // 0x802f9bc4
-private:
+
-    // TODO
+    u8 _0[0x10];         //
-};
+    u64 mFlags;          // 0x10, 0x14
+    u8 mType;            // 0x17
+    u8 _19[0x48 - 0x19]; //
+
+}; // Size: 0x48
+
 // Outside class Inlines
 // void DriverModel::TurnBack();
 // void ItemObj::clrTransferPartner() // ItemObj.h; // 0x802fa7a8
@@ -110,4 +118,5 @@ private:
 // void DriverModel::StartRocketStartFailure() // DriverModel.h; // 0x802fb304
 // void DriverModel::SetFreeze() // DriverModel.h; // 0x802fbe58
 // void DriverModel::ResetFreeze() // DriverModel.h; // 0x802fbeac
-#endif // KARTANIME_H
+
+#endif // KARTANIME_H

include/Yamamoto/KartAnt.h

@@ -1,6 +1,14 @@
 #ifndef KARTANT_H
 #define KARTANT_H
 
+#include <JSystem/JGeometry/Vec.h>
+
+#include "Shiraiwa/MapObjAntLion.h"
+
+#include "types.h"
+
+class KartBody;
+
 class KartAnt
 { // Autogenerated
 public:
@@ -17,6 +25,15 @@ public:
     // Inline/Unused
     // void MakeAnt(GeographyObj *);
 private:
-    // TODO
+    u8 _0;
+    KartBody *mBody;
+    TMapObjAntLion *mAntLion;
+    u8 mFlags;
+    u8 mState;
+    u8 mTimer;
+    u8 _f[0x20 - 0xf];
+    JGeometry::TVec3f _20;
+    JGeometry::TVec3f _2c;
+    JGeometry::TVec3f _38;
 };
 #endif // KARTANT_H

include/Yamamoto/KartCannon.h

@@ -1,6 +1,10 @@
 #ifndef KARTCANNON_H
 #define KARTCANNON_H
 
+#include <JSystem/JGeometry/Vec.h>
+
+#include "types.h"
+
 class KartCannon
 {
 public:
@@ -25,6 +29,9 @@ public:
     void DoRainbowCannonCrl(); // 0x80303b80
     void DoAfterCannonCrl();   // 0x80303dd4
 private:
-    // TODO
+    u8 _0[0x1c];           //
+    JGeometry::TVec3f _1c; //
+    JGeometry::TVec3f _28; //
+    JGeometry::TVec3f _34; //
 };
 #endif // KARTCANNON_H

include/Yamamoto/KartCheck.h

@@ -17,13 +17,14 @@ public:
     void CheckAllClearKey();
     void CheckAllClearKeyT();
     void CheckPartsClearKey(int);
-    void CheckOnlyTandemPartsClearKey(int);
+    bool CheckOnlyTandemPartsClearKey(int);
-    void CheckPlayer();
+    bool CheckPlayer();
-    void CheckDraw(u32, int);
+    bool CheckDraw(u32, int);
-    void CheckIndication();
+    bool CheckIndication();
 
 private:
-    // TODO
+    u8 _0[0x8];
-};
+
+}; // 0x8
 
 #endif

include/Yamamoto/KartCrash.h

@@ -38,6 +38,8 @@ public:
     // Inline/Unused
     // void MakeRollCrash();
 private:
-    // TODO
+    u8 _0[0x14];
-};
+
+}; // 0x14
+
 #endif // KARTCRASH_H

include/Yamamoto/KartDamage.h

@@ -27,6 +27,7 @@ public:
     // void SetThunderDamageAnime();
     // void DoAfterDamageCrl();
 private:
-    // TODO
+    u8 _0[0xc];
-};
+}; // 0xc
+
 #endif // KARTDAMAGE_H

include/Yamamoto/KartDemoCam.h

@@ -0,0 +1,102 @@
+#ifndef KARTDEMOCAM_H
+#define KARTDEMOCAM_H
+
+#include "Kaneshige/Course/CrsData.h"
+
+#include "Yamamoto/kartCtrl.h"
+
+class KartCam;
+
+class KartDemoCam
+{ // Autogenerated
+public:
+    KartDemoCam() {}
+
+    void Init(KartCam *);                       // 0x8030a1e8
+    void ChaseFovy(const CrsData::Camera *);    // 0x8030a24c
+    void DoInitCol();                           // 0x8030a338
+    void DoCol();                               // 0x8030a380
+    void InitFixCam();                          // 0x8030a4bc
+    void DoFixCam();                            // 0x8030a61c
+    void InitFixSearchCam();                    // 0x8030a6b8
+    void DoFixSearchCam();                      // 0x8030a794
+    void InitFixChaseCam();                     // 0x8030a8b0
+    void DoFixChaseCam();                       // 0x8030aa60
+    void InitChaseCam();                        // 0x8030abd8
+    void DoChaseCam();                          // 0x8030ad20
+    void InitFixPathCam();                      // 0x8030ae98
+    void DoFixPathCam();                        // 0x8030affc
+    void InitChasePathCam();                    // 0x8030b1d8
+    void DoChasePathCam();                      // 0x8030b2fc
+    void InitFixSplCam();                       // 0x8030b508
+    void DoFixSplCam();                         // 0x8030b6c4
+    void InitChaseSplCam();                     // 0x8030b894
+    void DoChaseSplCam();                       // 0x8030ba24
+    void InitFixPalaCam();                      // 0x8030bc28
+    void DoFixPalaCam();                        // 0x8030bff4
+    void InitDemoPathCam();                     // 0x8030c31c
+    void DoDemoPathCam();                       // 0x8030c414
+    void InitDemoParallelView();                // 0x8030c5b8
+    void DemoParallelView();                    // 0x8030c6a8
+    void InitDemoGoalView();                    // 0x8030c798
+    void DemoGoalView();                        // 0x8030cb4c
+    void MapView();                             // 0x8030cec4
+    void ObjectView();                          // 0x8030d36c
+    void DemoInitID();                          // 0x8030d650
+    void InitID();                              // 0x8030d7b8
+    void DoDemoView();                          // 0x8030d93c
+    void LiveViewChange();                      // 0x8030da9c
+    void DemoView();                            // 0x8030db6c
+    void DoPathEnd(JGeometry::TVec3f *, f32 *); // 0x8030dd34
+    void InitStartFixPathCam();                 // 0x8030de9c
+    void DoStartFixPathCam();                   // 0x8030df74
+    void InitStartPathCam();                    // 0x8030e07c
+    void DoStartPathCam();                      // 0x8030e15c
+    void InitStartLookPathCam();                // 0x8030e2bc
+    void DoStartLookPathCam();                  // 0x8030e364
+    void InitStartOnlyPathCam();                // 0x8030e450
+    void DoStartOnlyPathCam();                  // 0x8030e574
+    void InitStartFixCam();                     // 0x8030e6d0
+    void DoStartFixCam();                       // 0x8030e7f8
+    void InitStartChasePathCam();               // 0x8030e8c0
+    void DoStartChasePathCam();                 // 0x8030e9c4
+    void InitVsLastCam();                       // 0x8030ebc0
+    void VsLastCam();                           // 0x8030ecb0
+    void InitLastCam();                         // 0x8030eeb4
+    void LastCam();                             // 0x8030f160
+    void InitStartDemoCam();                    // 0x8030f5c4
+    void StartDemoCam();                        // 0x8030f6ac
+    void SetLastDemo();                         // 0x8030f7a0
+    void SetRaceCam();                          // 0x8030f7fc
+    void SetNextID();                           // 0x8030f85c
+    void DoExecution();                         // 0x8030f8ec
+    u8 GetStartID();                          // 0x8030f94c
+    void InitStartID(bool);                     // 0x8030f9b0
+    void StartDemoView();                       // 0x8030f9e8
+    void InitStartMapCam();                     // 0x8030fa08
+    void StartMapCam();                         // 0x8030faf0
+    void SetMapNextID();                        // 0x8030fbcc
+    void SetUpMapID();                          // 0x8030fc40
+    void InitStaffView();                        // 0x8030fc9c
+    void StaffView();                           // 0x8030fdbc
+    void SetStaffNextID();                      // 0x8030ff40
+    void SetUpStaffID();                        // 0x8030ffb8
+    // Inline/Unused
+    // void GetPerView();
+    // void KartBody::getPerCam();
+
+    KartCam *mCam;
+    KartBody *mBody;
+    Mtx mPosMtx;
+    u16 _38;
+    u8 _3a[0x70 - 0x3a];
+    f32 mCamKartDiffLength;
+    JGeometry::TVec3f _74;
+    JGeometry::TVec3f _80;
+    JGeometry::TVec3f _8c;
+    JGeometry::TVec3f mCamKartDiff;
+    JGeometry::TVec3f _a4;
+    u8 _b0[0x110 - 0xb0];
+}; // 110
+
+#endif // KARTDEMOCAM_H

include/Yamamoto/KartDisp.h

@@ -4,25 +4,27 @@
 #include <JSystem/JGeometry.h>
 #include "types.h"
 
+class KartBody;
+
 class KartDisp
 {
 public:
     KartDisp() {}
 
-    void Init(int);               // 0x803101d8
+    void Init(int i);             // 0x803101d8
     void DoShake();               // 0x80310214
     void MakeDispBodyPose();      // 0x803104d4
     void MakeDispBodyPos();       // 0x8031069c
-    void MakeSusMatrix(int);      // 0x803109d4
+    void MakeSusMatrix(int i);    // 0x803109d4
-    void MatrixScale(Mtx44, f32); // 0x80311138
+    void MatrixScale(Mtx, f32); // 0x80311138
     void MakeTireDispMatrix();    // 0x803111a8
     void MakeBodyDispMatrix();    // 0x803116d0
     void MakeScaleMatrix();       // 0x80311820
     void MakeKartDisp();          // 0x80311980
     // Inline/Unused
-    // void DomFalgDisp();
+    void DomFalgDisp();
-    // void DoDispDebug();
+    void DoDispDebug();
 private:
-    // TODO
+    KartBody *mBody;
 };
 #endif // KARTDISP_H

include/Yamamoto/KartDossin.h

@@ -4,6 +4,8 @@
 #include "Sato/GeographyObj.h"
 #include "types.h"
 
+class KartBody;
+
 class KartDossin
 { // Autogenerated
 public:
@@ -21,7 +23,18 @@ public:
     void DoCheckEnd();               // 0x80304694
     void DoDossinCrl();              // 0x803046f8
     void DoAfterDossinCrl();         // 0x803048b8
-private:
+
-    // TODO
+    KartBody *mBody;
-};
+    u8 _4[0x4];
-#endif // KARTDOSSIN_H
+    JGeometry::TVec3f _8;
+    u8 _14;
+    u8 _15;
+    u16 _16;
+    u16 _18;
+    f32 _1c;
+    f32 _20;
+    u8 _24[0x2c - 0x24];
+
+}; // 2c
+
+#endif // KARTDOSSIN_H

include/Yamamoto/KartGame.h

@@ -5,6 +5,8 @@
 #include "Yamamoto/kartSus.h"
 #include "types.h"
 
+class KartBody;
+
 class KartGame
 {
 public:
@@ -69,8 +71,13 @@ public:
     // void FrameWorkL(f32, f32, KartSus *);
     // void DoTurboPower();
     // void CheckBalloonPlayer();
-private:
+    KartBody *mBody;
-    // TODO
+    u8 _4[0x12 - 004];
+    u16 mCountDownDuration;
+    u8 _14[0x20 - 0x14];
+    JGeometry::TVec3f _20;
+    JGeometry::TVec3f _2C;
+    JGeometry::TVec3f _34;
 };
 
 #endif KARTGAME_H

include/Yamamoto/KartHandle.h

@@ -12,15 +12,15 @@ class KartHandle
 public:
     KartHandle() {}
 
-    void Init(int);                                         // 0x80311ae8
+    void Init(int);                        // 0x80311ae8
-    void DoMotor(MotorManager::MotorType);                  // 0x80311b34
+    bool DoMotor(MotorManager::MotorType); // 0x80311b34
-    void DoPowerMotor(float, unsigned char, unsigned char); // 0x80311cac
+    bool DoPowerMotor(f32, u8, u8);        // 0x80311cac
-    void StopMotor();                                       // 0x80311df8
+    void StopMotor();                      // 0x80311df8
-    void WatchFrontalCollisionForce();                      // 0x80311e64
+    void WatchFrontalCollisionForce();     // 0x80311e64
 private:
     KartBody *mBody;
-    u32 _04;
+    u32 mRumbleTimer;
-    u8 _08;
+    u8 mRumbleStrength;
-    u8 _09;
+    u8 _9;
 };
 #endif // KARTHANDLE_H

include/Yamamoto/KartItem.h

@@ -4,7 +4,8 @@
 #include "types.h"
 
 class KartItem
-{ // Autogenerated
+{
+public:
     KartItem() {}
     void Init(int);
     void DoRabbit();
@@ -42,7 +43,8 @@ class KartItem
     // void DoDriverItemAnime();
     // void DoDriverItemRelease();
 private:
-    // TODO
+    u8 _0[0xc]; //
-};
+
+}; // 0xc
 
 #endif // KARTITEMSTRAT_H

include/Yamamoto/KartPerCam.h

@@ -1,8 +1,15 @@
 #ifndef KARTPERCAM_H
 #define KARTPERCAM_H
 
+#include <JSystem/JGeometry/Vec.h>
+#include "Kaneshige/Course/CrsArea.h"
+#include "Yamamoto/kartLine.h"
+#include "types.h"
+
+class KartBody;
+
 class KartPerCam
-{ // Autogenerated
+{
 public:
     KartPerCam() {}
 
@@ -20,22 +27,46 @@ public:
     void InitDemoParallelView(); // 0x80315dbc
     void InitID();               // 0x80315e3c
     // Inline/Unused
-    // void ChaseFovy();
+    void ChaseFovy();
-    // void DoFixCam();
+    void DoFixCam();
-    // void DoFixSearchCam();
+    void DoFixSearchCam();
-    // void DoFixChaseCam();
+    void DoFixChaseCam();
-    // void DoChaseCam();
+    void DoChaseCam();
-    // void DoFixPathCam();
+    void DoFixPathCam();
-    // void DoChasePathCam();
+    void DoChasePathCam();
-    // void DoFixSplCam();
+    void DoFixSplCam();
-    // void DoChaseSplCam();
+    void DoChaseSplCam();
-    // void DoFixPalaCam();
+    void DoFixPalaCam();
-    // void DoDemoPathCam();
+    void DoDemoPathCam();
-    // void DemoParallelView();
+    void DemoParallelView();
-    // void InitDemoGoalView();
+    void InitDemoGoalView();
-    // void DemoGoalView();
+    void DemoGoalView();
-    // void DemoView();
+    void DemoView();
 private:
-    // TODO
+    KartBody *mBody;          //
+    Mtx mPalaCamMtx;          //
+    Spline *_34;              //
+    CrsArea mArea;            // 14
+    u16 _4c;                  //
+    u8 _4e;                   //
+    u8 _4f;                   //
+    u8 _50;                   //
+    u8 _51[0x52 - 0x51];      //
+    u16 _52;                  //
+    u16 _54;                  //
+    u8 _56[0x58 - 0x56];      //
+    int mCamId;               // 58
+    f32 mFovY;                // 5c
+    u8 _60[0x88 - 0x60];      //
+    f32 _88;                  // length of vector b8
+    f32 _8c;                  //
+    u8 _90[0x94 - 0x90];      //
+    JGeometry::TVec3f _94;    //
+    JGeometry::TVec3f _a0;    //
+    JGeometry::TVec3f mPos;   // ac
+    JGeometry::TVec3f _b8;    //
+    JGeometry::TVec3f _c4;    //
+    JGeometry::TVec3f _d0[4]; //
+    u8 _100[0x160 - 0x100];   //
 };
 #endif // KARTPERCAM_H

include/Yamamoto/KartPipe.h

@@ -1,6 +1,12 @@
 #ifndef KARTPIPE_H
 #define KARTPIPE_H
 
+#include "Kaneshige/JugemPoint.h"
+
+#include "types.h"
+
+class KartBody;
+
 class KartPipe
 { // Autogenerated
 public:
@@ -17,6 +23,19 @@ public:
     void DoPipeCrl();      // 0x803129a4
     void DoAfterPipeCrl(); // 0x80312b8c
 private:
-    // TODO
+    JugemPoint *mPoint; // 00
-};
+    KartBody *mBody;    // 04
+    u8 mFlags;          // 08
+    u8 mState;          // 09
+    u8 mTimer;          // 0a
+    u16 _c;             //
+    int mCameraID;      // 10
+    u8 _14[4];          //
+    f32 mSpeed;         // 18
+    u8 _1c[4];          //
+    JGeometry::TVec3f _20; //
+    JGeometry::TVec3f _2c; //
+    JGeometry::TVec3f _38; //
+}; // 44
+
 #endif // KARTPIPE_H

include/Yamamoto/KartRescue.h

@@ -1,8 +1,12 @@
 #ifndef KARTRESCUE_H
 #define KARTRESCUE_H
 
+#include <JSystem/JGeometry/Vec.h>
+
 #include "Sato/GeographyObj.h"
 
+#include "types.h"
+
 class KartBody;
 
 class KartRescue
@@ -28,6 +32,17 @@ public:
     // Inline/Unused
     // void DoHang();
 private:
-    // TODO
+    u8 _0[0xc];            //
-};
+    CrsGround mGround;     // c
+    u8 _6c[0x8c - 0x6c];   //
+    JGeometry::TVec3f _8c; //
+    JGeometry::TVec3f _98; //
+    JGeometry::TVec3f _a4; //
+    JGeometry::TVec3f _b0; //
+    JGeometry::TVec3f _bc; //
+    JGeometry::TVec3f _c8; //
+    u8 _d4[0x104 - 0xd4];  //
+
+}; // 0x104
+
 #endif // KARTRESCUE_H