d_lyt_mini_game WIP

11 files changed, 2242 insertions, 143 deletions

diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt
index 714ddd7b..3cf914ad 100644
--- a/config/SOUE01/splits.txt
+++ b/config/SOUE01/splits.txt
@@ -1618,9 +1618,10 @@ d/lyt/d_lyt_enemy_icon.cpp:
 
 d/lyt/d_lyt_mini_game.cpp:
 	.text       start:0x8028BCE0 end:0x802969E0 align:16
-	.rodata     start:0x804EE790 end:0x804EEB68
+	.rodata     start:0x804EE7D8 end:0x804EEB68
 	.data       start:0x80538E58 end:0x80539B68
 	.sbss       start:0x80575970 end:0x80575990
+	.sdata2     start:0x8057C700 end:0x8057C760
 
 d/lyt/d_lyt_meter_suiryu_score.cpp:
 	.text       start:0x802969E0 end:0x8029C2C8 align:16
diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt
index c0285720..9bc6b458 100644
--- a/config/SOUE01/symbols.txt
+++ b/config/SOUE01/symbols.txt
@@ -555,9 +555,9 @@ create__3d3dFPQ23EGG4Heap = .text:0x80016700; // type:function size:0x160
 fn_80016860 = .text:0x80016860; // type:function size:0x28
 createLightTextures__3d3dFv = .text:0x80016890; // type:function size:0x98
 fn_80016930 = .text:0x80016930; // type:function size:0x2C
-fn_80016960__3d3dFR7mVec3_cRC7mVec3_c = .text:0x80016960; // type:function size:0x130
-fn_80016A90__3d3dFRC7mVec3_c = .text:0x80016A90; // type:function size:0xCC
-fn_80016B60 = .text:0x80016B60; // type:function size:0xAC
+worldToScreen__3d3dFR7mVec3_cRC7mVec3_c = .text:0x80016960; // type:function size:0x130
+isOnScreen__3d3dFRC7mVec3_c = .text:0x80016A90; // type:function size:0xCC
+screenToWorld = .text:0x80016B60; // type:function size:0xAC
 __ct__Q23d3d13AnmMdlWrapperFv = .text:0x80016C10; // type:function size:0x88
 __dt__Q23d3d13AnmMdlWrapperFv = .text:0x80016CA0; // type:function size:0xB0
 create__Q23d3d13AnmMdlWrapperFR9dAcBase_cPvPvPCcPCcUl = .text:0x80016D50; // type:function size:0x78
@@ -13682,7 +13682,7 @@ AcItem__checkFlagForItem2 = .text:0x80252D90; // type:function size:0x34
 AcItem__setItemFlagBasedOnId = .text:0x80252DD0; // type:function size:0x34
 AcItem__getTreasureShift = .text:0x80252E10; // type:function size:0x48
 AcItem__setTreasureTempCollect = .text:0x80252E60; // type:function size:0x40
-AcItem__checkTreasureTempCollect = .text:0x80252EA0; // type:function size:0x50
+checkTreasureTempCollect__9dAcItem_cFUs = .text:0x80252EA0; // type:function size:0x50
 AcItem__setBoundingBox = .text:0x80252EF0; // type:function size:0x88
 fn_80252F80 = .text:0x80252F80; // type:function size:0x88
 fn_80253010 = .text:0x80253010; // type:function size:0x88
@@ -15224,112 +15224,112 @@ fn_8028BA90 = .text:0x8028BA90; // type:function size:0x30
 LytEnemyIcon__initStates = .text:0x8028BAC0; // type:function size:0x128
 LytEnemyIcon__dtor = .text:0x8028BBF0; // type:function size:0x58
 fn_8028BC50 = .text:0x8028BC50; // type:function size:0x88
-fn_8028BCE0 = .text:0x8028BCE0; // type:function size:0xDC
-fn_8028BDC0 = .text:0x8028BDC0; // type:function size:0x58
-fn_8028BE20 = .text:0x8028BE20; // type:function size:0x180
-fn_8028BFA0 = .text:0x8028BFA0; // type:function size:0x28
-fn_8028BFD0 = .text:0x8028BFD0; // type:function size:0x88
-fn_8028C060 = .text:0x8028C060; // type:function size:0x90
-fn_8028C0F0 = .text:0x8028C0F0; // type:function size:0x74
-fn_8028C170 = .text:0x8028C170; // type:function size:0x28
-fn_8028C1A0 = .text:0x8028C1A0; // type:function size:0x54
-fn_8028C200 = .text:0x8028C200; // type:function size:0x54
-fn_8028C260 = .text:0x8028C260; // type:function size:0xC
-fn_8028C270 = .text:0x8028C270; // type:function size:0x60
-fn_8028C2D0 = .text:0x8028C2D0; // type:function size:0x60
-fn_8028C330 = .text:0x8028C330; // type:function size:0x60
-fn_8028C390 = .text:0x8028C390; // type:function size:0x114
-fn_8028C4B0 = .text:0x8028C4B0; // type:function size:0x70
-fn_8028C520 = .text:0x8028C520; // type:function size:0x6C
-fn_8028C590 = .text:0x8028C590; // type:function size:0x64
-fn_8028C600 = .text:0x8028C600; // type:function size:0x64
-fn_8028C670 = .text:0x8028C670; // type:function size:0x58
-fn_8028C6D0 = .text:0x8028C6D0; // type:function size:0xA4
-fn_8028C780 = .text:0x8028C780; // type:function size:0x48
-fn_8028C7D0 = .text:0x8028C7D0; // type:function size:0x114
-fn_8028C8F0 = .text:0x8028C8F0; // type:function size:0x8C
-fn_8028C980 = .text:0x8028C980; // type:function size:0x168
-fn_8028CAF0 = .text:0x8028CAF0; // type:function size:0x3C
-fn_8028CB30 = .text:0x8028CB30; // type:function size:0x90
-fn_8028CBC0 = .text:0x8028CBC0; // type:function size:0xB8
-fn_8028CC80 = .text:0x8028CC80; // type:function size:0x90
-fn_8028CD10 = .text:0x8028CD10; // type:function size:0x8C
-fn_8028CDA0 = .text:0x8028CDA0; // type:function size:0x80
-fn_8028CE20 = .text:0x8028CE20; // type:function size:0x150
-fn_8028CF70 = .text:0x8028CF70; // type:function size:0xC0
-fn_8028D030 = .text:0x8028D030; // type:function size:0xE0
-fn_8028D110 = .text:0x8028D110; // type:function size:0x48
-fn_8028D160 = .text:0x8028D160; // type:function size:0x38
-fn_8028D1A0 = .text:0x8028D1A0; // type:function size:0x2C
-fn_8028D1D0 = .text:0x8028D1D0; // type:function size:0xC0
-fn_8028D290 = .text:0x8028D290; // type:function size:0x80
-fn_8028D310 = .text:0x8028D310; // type:function size:0x80
-fn_8028D390 = .text:0x8028D390; // type:function size:0xC0
-fn_8028D450 = .text:0x8028D450; // type:function size:0xC0
-fn_8028D510 = .text:0x8028D510; // type:function size:0xC0
-fn_8028D5D0 = .text:0x8028D5D0; // type:function size:0x58
-fn_8028D630 = .text:0x8028D630; // type:function size:0xC
-fn_8028D640 = .text:0x8028D640; // type:function size:0xC
-fn_8028D650 = .text:0x8028D650; // type:function size:0x18
-fn_8028D670 = .text:0x8028D670; // type:function size:0x58
-fn_8028D6D0 = .text:0x8028D6D0; // type:function size:0x44
-fn_8028D720 = .text:0x8028D720; // type:function size:0x44
-fn_8028D770 = .text:0x8028D770; // type:function size:0x44
-fn_8028D7C0 = .text:0x8028D7C0; // type:function size:0x50
-fn_8028D810 = .text:0x8028D810; // type:function size:0x18
-fn_8028D830 = .text:0x8028D830; // type:function size:0x74
-fn_8028D8B0 = .text:0x8028D8B0; // type:function size:0xC8
-fn_8028D980 = .text:0x8028D980; // type:function size:0x74
-fn_8028DA00 = .text:0x8028DA00; // type:function size:0x224
-fn_8028DC30 = .text:0x8028DC30; // type:function size:0x48
-fn_8028DC80 = .text:0x8028DC80; // type:function size:0x100
-fn_8028DD80 = .text:0x8028DD80; // type:function size:0xC0
-fn_8028DE40 = .text:0x8028DE40; // type:function size:0x84
-fn_8028DED0 = .text:0x8028DED0; // type:function size:0x100
-fn_8028DFD0 = .text:0x8028DFD0; // type:function size:0xEC
-fn_8028E0C0 = .text:0x8028E0C0; // type:function size:0xAC
-fn_8028E170 = .text:0x8028E170; // type:function size:0x60
-fn_8028E1D0 = .text:0x8028E1D0; // type:function size:0xC4
-fn_8028E2A0 = .text:0x8028E2A0; // type:function size:0x54
-fn_8028E300 = .text:0x8028E300; // type:function size:0x14
-fn_8028E320 = .text:0x8028E320; // type:function size:0x198
-fn_8028E4C0 = .text:0x8028E4C0; // type:function size:0x2C
-fn_8028E4F0 = .text:0x8028E4F0; // type:function size:0x124
-fn_8028E620 = .text:0x8028E620; // type:function size:0xC
-fn_8028E630 = .text:0x8028E630; // type:function size:0x194
-fn_8028E7D0 = .text:0x8028E7D0; // type:function size:0x98
-fn_8028E870 = .text:0x8028E870; // type:function size:0x80
-fn_8028E8F0 = .text:0x8028E8F0; // type:function size:0x80
-fn_8028E970 = .text:0x8028E970; // type:function size:0x80
-fn_8028E9F0 = .text:0x8028E9F0; // type:function size:0x80
-fn_8028EA70 = .text:0x8028EA70; // type:function size:0x13C
-fn_8028EBB0 = .text:0x8028EBB0; // type:function size:0x60
-fn_8028EC10 = .text:0x8028EC10; // type:function size:0x8
-fn_8028EC20 = .text:0x8028EC20; // type:function size:0x114
-fn_8028ED40 = .text:0x8028ED40; // type:function size:0x74
-fn_8028EDC0 = .text:0x8028EDC0; // type:function size:0x64
-fn_8028EE30 = .text:0x8028EE30; // type:function size:0xC
-fn_8028EE40 = .text:0x8028EE40; // type:function size:0xC
-fn_8028EE50 = .text:0x8028EE50; // type:function size:0xC
-fn_8028EE60 = .text:0x8028EE60; // type:function size:0xC
-fn_8028EE70 = .text:0x8028EE70; // type:function size:0x64
-fn_8028EEE0 = .text:0x8028EEE0; // type:function size:0xC
-fn_8028EEF0 = .text:0x8028EEF0; // type:function size:0x44
-fn_8028EF40 = .text:0x8028EF40; // type:function size:0x44
-fn_8028EF90 = .text:0x8028EF90; // type:function size:0x44
-fn_8028EFE0 = .text:0x8028EFE0; // type:function size:0x44
-fn_8028F030 = .text:0x8028F030; // type:function size:0x44
-fn_8028F080 = .text:0x8028F080; // type:function size:0x11C
-fn_8028F1A0 = .text:0x8028F1A0; // type:function size:0x94
-fn_8028F240 = .text:0x8028F240; // type:function size:0x80
-fn_8028F2C0 = .text:0x8028F2C0; // type:function size:0xE8
-fn_8028F3B0 = .text:0x8028F3B0; // type:function size:0xB4
-fn_8028F470 = .text:0x8028F470; // type:function size:0xB4
-fn_8028F530 = .text:0x8028F530; // type:function size:0xBC
-fn_8028F5F0 = .text:0x8028F5F0; // type:function size:0x74
-fn_8028F670 = .text:0x8028F670; // type:function size:0x1BC
-fn_8028F830 = .text:0x8028F830; // type:function size:0x48
-fn_8028F880 = .text:0x8028F880; // type:function size:0x10C
+build__26dLytMiniGamePumpkinParts_cFPQ23d2d10ResAccIf_c = .text:0x8028BCE0; // type:function size:0xDC
+remove__26dLytMiniGamePumpkinParts_cFv = .text:0x8028BDC0; // type:function size:0x58
+execute__26dLytMiniGamePumpkinParts_cFv = .text:0x8028BE20; // type:function size:0x180
+draw__26dLytMiniGamePumpkinParts_cFv = .text:0x8028BFA0; // type:function size:0x28
+init__26dLytMiniGamePumpkinParts_cFv = .text:0x8028BFD0; // type:function size:0x88
+setPumpkinPos__26dLytMiniGamePumpkinParts_cFRC7mVec3_c = .text:0x8028C060; // type:function size:0x90
+getPoint__26dLytMiniGamePumpkinParts_cFUcb = .text:0x8028C0F0; // type:function size:0x74
+isActive__26dLytMiniGamePumpkinParts_cCFv = .text:0x8028C170; // type:function size:0x28
+startGetPoint__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C1A0; // type:function size:0x54
+startDoubleScore__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C200; // type:function size:0x54
+stopDoubleScore__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C260; // type:function size:0xC
+resetGetPoint__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C270; // type:function size:0x60
+resetDoubleScore__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C2D0; // type:function size:0x60
+resetPattern__26dLytMiniGamePumpkinParts_cFv = .text:0x8028C330; // type:function size:0x60
+setPattern__26dLytMiniGamePumpkinParts_cFl = .text:0x8028C390; // type:function size:0x114
+build__21dLytMiniGamePumpkin_cFPQ23d2d10ResAccIf_c = .text:0x8028C4B0; // type:function size:0x70
+remove__21dLytMiniGamePumpkin_cFv = .text:0x8028C520; // type:function size:0x6C
+execute__21dLytMiniGamePumpkin_cFv = .text:0x8028C590; // type:function size:0x64
+draw__21dLytMiniGamePumpkin_cFv = .text:0x8028C600; // type:function size:0x64
+init__21dLytMiniGamePumpkin_cFv = .text:0x8028C670; // type:function size:0x58
+getPoint__21dLytMiniGamePumpkin_cFRC7mVec3_clb = .text:0x8028C6D0; // type:function size:0xA4
+calcCombo__21dLytMiniGamePumpkin_cFl = .text:0x8028C780; // type:function size:0x48
+build__18dLytMiniGameBugs_cFPQ23d2d10ResAccIf_c = .text:0x8028C7D0; // type:function size:0x114
+remove__18dLytMiniGameBugs_cFv = .text:0x8028C8F0; // type:function size:0x8C
+execute__18dLytMiniGameBugs_cFv = .text:0x8028C980; // type:function size:0x168
+draw__18dLytMiniGameBugs_cFv = .text:0x8028CAF0; // type:function size:0x3C
+init__18dLytMiniGameBugs_cFv = .text:0x8028CB30; // type:function size:0x90
+startAllIconsIn__18dLytMiniGameBugs_cFv = .text:0x8028CBC0; // type:function size:0xB8
+startOut__18dLytMiniGameBugs_cFv = .text:0x8028CC80; // type:function size:0x90
+startIn__18dLytMiniGameBugs_cFv = .text:0x8028CD10; // type:function size:0x8C
+startOutForced__18dLytMiniGameBugs_cFv = .text:0x8028CDA0; // type:function size:0x80
+collectBug__18dLytMiniGameBugs_cFl = .text:0x8028CE20; // type:function size:0x150
+startBugsFlash__18dLytMiniGameBugs_cFv = .text:0x8028CF70; // type:function size:0xC0
+setBug__18dLytMiniGameBugs_cFll = .text:0x8028D030; // type:function size:0xE0
+isSlotIconOnEndReached__18dLytMiniGameBugs_cCFl = .text:0x8028D110; // type:function size:0x48
+isSlotIconOnEnabled__18dLytMiniGameBugs_cCFl = .text:0x8028D160; // type:function size:0x38
+isSlotBugCollected__18dLytMiniGameBugs_cFl = .text:0x8028D1A0; // type:function size:0x2C
+resetBugIconsIn__18dLytMiniGameBugs_cFv = .text:0x8028D1D0; // type:function size:0xC0
+resetIn__18dLytMiniGameBugs_cFv = .text:0x8028D290; // type:function size:0x80
+resetOut__18dLytMiniGameBugs_cFv = .text:0x8028D310; // type:function size:0x80
+resetBugIconsOn__18dLytMiniGameBugs_cFv = .text:0x8028D390; // type:function size:0xC0
+resetBugIconsTex__18dLytMiniGameBugs_cFv = .text:0x8028D450; // type:function size:0xC0
+resetBugIconsFlash__18dLytMiniGameBugs_cFv = .text:0x8028D510; // type:function size:0xC0
+stopBugIconsIn__18dLytMiniGameBugs_cFv = .text:0x8028D5D0; // type:function size:0x58
+stopIn__18dLytMiniGameBugs_cFv = .text:0x8028D630; // type:function size:0xC
+stopOut__18dLytMiniGameBugs_cFv = .text:0x8028D640; // type:function size:0xC
+stopBugIconOn__18dLytMiniGameBugs_cFl = .text:0x8028D650; // type:function size:0x18
+stopBugIconsFlash__18dLytMiniGameBugs_cFv = .text:0x8028D670; // type:function size:0x58
+isIconInEndReached__18dLytMiniGameBugs_cCFv = .text:0x8028D6D0; // type:function size:0x44
+isInEndReached__18dLytMiniGameBugs_cCFv = .text:0x8028D720; // type:function size:0x44
+isOutEndReached__18dLytMiniGameBugs_cCFv = .text:0x8028D770; // type:function size:0x44
+isSlotOnEndReached__18dLytMiniGameBugs_cCFl = .text:0x8028D7C0; // type:function size:0x50
+isBug0Flashing__18dLytMiniGameBugs_cCFv = .text:0x8028D810; // type:function size:0x18
+areAllBugIconsOn__18dLytMiniGameBugs_cCFv = .text:0x8028D830; // type:function size:0x74
+build__18dLytMiniGameTime_cFPQ23d2d10ResAccIf_c = .text:0x8028D8B0; // type:function size:0xC8
+remove__18dLytMiniGameTime_cFv = .text:0x8028D980; // type:function size:0x74
+execute__18dLytMiniGameTime_cFv = .text:0x8028DA00; // type:function size:0x224
+draw__18dLytMiniGameTime_cFv = .text:0x8028DC30; // type:function size:0x48
+init__18dLytMiniGameTime_cFv = .text:0x8028DC80; // type:function size:0x100
+fn_8028DD80__18dLytMiniGameTime_cFv = .text:0x8028DD80; // type:function size:0xC0
+fn_8028DE40__18dLytMiniGameTime_cFv = .text:0x8028DE40; // type:function size:0x84
+fn_8028DED0__18dLytMiniGameTime_cFv = .text:0x8028DED0; // type:function size:0x100
+fn_8028DFD0__18dLytMiniGameTime_cFv = .text:0x8028DFD0; // type:function size:0xEC
+fn_8028E0C0__18dLytMiniGameTime_cFv = .text:0x8028E0C0; // type:function size:0xAC
+fn_8028E170__18dLytMiniGameTime_cFv = .text:0x8028E170; // type:function size:0x60
+fn_8028E1D0__18dLytMiniGameTime_cFv = .text:0x8028E1D0; // type:function size:0xC4
+startLoop__18dLytMiniGameTime_cFv = .text:0x8028E2A0; // type:function size:0x54
+setTimerValueInMilliSeconds__18dLytMiniGameTime_cFl = .text:0x8028E300; // type:function size:0x14
+updateLongTimer__18dLytMiniGameTime_cFv = .text:0x8028E320; // type:function size:0x198
+setTimerSecondsValueInMilliSeconds__18dLytMiniGameTime_cFl = .text:0x8028E4C0; // type:function size:0x2C
+updateSecondsTimer__18dLytMiniGameTime_cFv = .text:0x8028E4F0; // type:function size:0x124
+saveSecondsTimer__18dLytMiniGameTime_cFv = .text:0x8028E620; // type:function size:0xC
+setBestTime__18dLytMiniGameTime_cFl = .text:0x8028E630; // type:function size:0x194
+setShowBestTime__18dLytMiniGameTime_cFb = .text:0x8028E7D0; // type:function size:0x98
+resetIn__18dLytMiniGameTime_cFv = .text:0x8028E870; // type:function size:0x80
+resetOut__18dLytMiniGameTime_cFv = .text:0x8028E8F0; // type:function size:0x80
+resetAlphaIn__18dLytMiniGameTime_cFv = .text:0x8028E970; // type:function size:0x80
+resetAlphaOut__18dLytMiniGameTime_cFv = .text:0x8028E9F0; // type:function size:0x80
+resetDigits__18dLytMiniGameTime_cFv = .text:0x8028EA70; // type:function size:0x13C
+fn_8028EBB0__18dLytMiniGameTime_cFv = .text:0x8028EBB0; // type:function size:0x60
+resetShowBestTime__18dLytMiniGameTime_cFv = .text:0x8028EC10; // type:function size:0x8
+resetFinish__18dLytMiniGameTime_cFv = .text:0x8028EC20; // type:function size:0x114
+resetLoop__18dLytMiniGameTime_cFv = .text:0x8028ED40; // type:function size:0x74
+initSignChange__18dLytMiniGameTime_cFv = .text:0x8028EDC0; // type:function size:0x64
+stopIn__18dLytMiniGameTime_cFv = .text:0x8028EE30; // type:function size:0xC
+stopOut__18dLytMiniGameTime_cFv = .text:0x8028EE40; // type:function size:0xC
+stopAlphaIn__18dLytMiniGameTime_cFv = .text:0x8028EE50; // type:function size:0xC
+stopAlphaOut__18dLytMiniGameTime_cFv = .text:0x8028EE60; // type:function size:0xC
+stopFinish__18dLytMiniGameTime_cFv = .text:0x8028EE70; // type:function size:0x64
+stopLoop__18dLytMiniGameTime_cFv = .text:0x8028EEE0; // type:function size:0xC
+isInEndReached__18dLytMiniGameTime_cCFv = .text:0x8028EEF0; // type:function size:0x44
+isOutEndReached__18dLytMiniGameTime_cCFv = .text:0x8028EF40; // type:function size:0x44
+isAlphaInEndReached__18dLytMiniGameTime_cCFv = .text:0x8028EF90; // type:function size:0x44
+isAlphaOutEndReached__18dLytMiniGameTime_cCFv = .text:0x8028EFE0; // type:function size:0x44
+isFinishEndReached__18dLytMiniGameTime_cCFv = .text:0x8028F030; // type:function size:0x44
+setHighestDigitIndex__18dLytMiniGameTime_cFUc = .text:0x8028F080; // type:function size:0x11C
+setSignChange__18dLytMiniGameTime_cFUl = .text:0x8028F1A0; // type:function size:0x94
+fn_8028F240__18dLytMiniGameTime_cFb = .text:0x8028F240; // type:function size:0x80
+setBestHasSixDigits__18dLytMiniGameTime_cFb = .text:0x8028F2C0; // type:function size:0xE8
+setDigit__18dLytMiniGameTime_cFll = .text:0x8028F3B0; // type:function size:0xB4
+setDigitBest__18dLytMiniGameTime_cFll = .text:0x8028F470; // type:function size:0xB4
+build__19dLytMiniGameStart_cFPQ23d2d10ResAccIf_c = .text:0x8028F530; // type:function size:0xBC
+remove__19dLytMiniGameStart_cFv = .text:0x8028F5F0; // type:function size:0x74
+execute__19dLytMiniGameStart_cFv = .text:0x8028F670; // type:function size:0x1BC
+draw__19dLytMiniGameStart_cFv = .text:0x8028F830; // type:function size:0x48
+init__19dLytMiniGameStart_cFv = .text:0x8028F880; // type:function size:0x10C
 fn_8028F990 = .text:0x8028F990; // type:function size:0x4C
 fn_8028F9E0 = .text:0x8028F9E0; // type:function size:0x60
 fn_8028FA40 = .text:0x8028FA40; // type:function size:0x4C
@@ -15350,11 +15350,11 @@ fn_8028FE10 = .text:0x8028FE10; // type:function size:0x48
 fn_8028FE60 = .text:0x8028FE60; // type:function size:0x48
 fn_8028FEB0 = .text:0x8028FEB0; // type:function size:0x48
 fn_8028FF00 = .text:0x8028FF00; // type:function size:0x48
-fn_8028FF50 = .text:0x8028FF50; // type:function size:0x168
-fn_802900C0 = .text:0x802900C0; // type:function size:0x74
-fn_80290140 = .text:0x80290140; // type:function size:0x2EC
-fn_80290430 = .text:0x80290430; // type:function size:0x48
-fn_80290480 = .text:0x80290480; // type:function size:0xF84
+build__19dLytMiniGameScore_cFPQ23d2d10ResAccIf_c = .text:0x8028FF50; // type:function size:0x168
+remove__19dLytMiniGameScore_cFv = .text:0x802900C0; // type:function size:0x74
+execute__19dLytMiniGameScore_cFv = .text:0x80290140; // type:function size:0x2EC
+draw__19dLytMiniGameScore_cFv = .text:0x80290430; // type:function size:0x48
+init__19dLytMiniGameScore_cFv = .text:0x80290480; // type:function size:0xF84
 fn_80291410 = .text:0x80291410; // type:function size:0x1A0
 fn_802915B0 = .text:0x802915B0; // type:function size:0x84
 fn_80291640 = .text:0x80291640; // type:function size:0x100
@@ -15404,11 +15404,11 @@ fn_80292C30 = .text:0x80292C30; // type:function size:0x764
 fn_802933A0 = .text:0x802933A0; // type:function size:0x6C
 fn_80293410 = .text:0x80293410; // type:function size:0x34
 fn_80293450 = .text:0x80293450; // type:function size:0x2A0
-fn_802936F0 = .text:0x802936F0; // type:function size:0xC8
-fn_802937C0 = .text:0x802937C0; // type:function size:0x74
-fn_80293840 = .text:0x80293840; // type:function size:0xF0
-fn_80293930 = .text:0x80293930; // type:function size:0x48
-fn_80293980 = .text:0x80293980; // type:function size:0xA8
+build__21dLytMiniGameScoreSd_cFPQ23d2d10ResAccIf_c = .text:0x802936F0; // type:function size:0xC8
+remove__21dLytMiniGameScoreSd_cFv = .text:0x802937C0; // type:function size:0x74
+execute__21dLytMiniGameScoreSd_cFv = .text:0x80293840; // type:function size:0xF0
+draw__21dLytMiniGameScoreSd_cFv = .text:0x80293930; // type:function size:0x48
+init__21dLytMiniGameScoreSd_cFv = .text:0x80293980; // type:function size:0xA8
 fn_80293A30 = .text:0x80293A30; // type:function size:0x60
 fn_80293A90 = .text:0x80293A90; // type:function size:0x60
 fn_80293AF0 = .text:0x80293AF0; // type:function size:0xC0
@@ -15424,7 +15424,7 @@ fn_80294010 = .text:0x80294010; // type:function size:0xC
 fn_80294020 = .text:0x80294020; // type:function size:0xC
 fn_80294030 = .text:0x80294030; // type:function size:0x44
 fn_80294080 = .text:0x80294080; // type:function size:0x44
-LytMiniGame__ctor = .text:0x802940D0; // type:function size:0x380
+dLytMiniGame_c_classInit__Fv = .text:0x802940D0; // type:function size:0x380
 fn_80294450 = .text:0x80294450; // type:function size:0x74
 fn_802944D0 = .text:0x802944D0; // type:function size:0x74
 fn_80294550 = .text:0x80294550; // type:function size:0x74
@@ -15485,7 +15485,7 @@ fn_80296580 = .text:0x80296580; // type:function size:0x130
 fn_802966B0 = .text:0x802966B0; // type:function size:0x30
 fn_802966E0 = .text:0x802966E0; // type:function size:0x40
 decrementLayoutArcRefCount = .text:0x80296720; // type:function size:0x4C
-fn_80296770 = .text:0x80296770; // type:function size:0x270
+__dt__14dLytMiniGame_cFv = .text:0x80296770; // type:function size:0x270
 LytMeterSuiryuScoreBase__stateNoneEnter = .text:0x802969E0; // type:function size:0x4
 LytMeterSuiryuScoreBase__stateNoneUpdate = .text:0x802969F0; // type:function size:0x4
 LytMeterSuiryuScoreBase__stateNoneLeave = .text:0x80296A00; // type:function size:0x4
@@ -42447,12 +42447,12 @@ lbl_80575959 = .sbss:0x80575959; // type:object size:0x1 data:byte
 lbl_8057595C = .sbss:0x8057595C; // type:object size:0x4 data:4byte
 lbl_80575960 = .sbss:0x80575960; // type:object size:0x8 data:4byte
 lbl_80575968 = .sbss:0x80575968; // type:object size:0x8 data:4byte
-lbl_80575970 = .sbss:0x80575970; // type:object size:0x4 data:4byte
-lbl_80575974 = .sbss:0x80575974; // type:object size:0x4 data:4byte
-lbl_80575978 = .sbss:0x80575978; // type:object size:0x4 data:4byte
-lbl_8057597C = .sbss:0x8057597C; // type:object size:0x4 data:4byte
-lbl_80575980 = .sbss:0x80575980; // type:object size:0x4 data:4byte
-lbl_80575984 = .sbss:0x80575984; // type:object size:0x4 data:4byte
+sInstance__21dLytMiniGamePumpkin_c = .sbss:0x80575970; // type:object size:0x4 data:4byte
+sInstance__18dLytMiniGameBugs_c = .sbss:0x80575974; // type:object size:0x4 data:4byte
+sInstance__18dLytMiniGameTime_c = .sbss:0x80575978; // type:object size:0x4 data:4byte
+sInstance__19dLytMiniGameStart_c = .sbss:0x8057597C; // type:object size:0x4 data:4byte
+sInstance__19dLytMiniGameScore_c = .sbss:0x80575980; // type:object size:0x4 data:4byte
+sInstance__21dLytMiniGameScoreSd_c = .sbss:0x80575984; // type:object size:0x4 data:4byte
 sInstance__14dLytMiniGame_c = .sbss:0x80575988; // type:object size:0x8 data:4byte
 lbl_80575990 = .sbss:0x80575990; // type:object size:0x8 data:4byte
 lbl_80575998 = .sbss:0x80575998; // type:object size:0x8 data:4byte
diff --git a/include/d/a/d_a_item.h b/include/d/a/d_a_item.h
index ed78c6c4..b08a0fa7 100644
--- a/include/d/a/d_a_item.h
+++ b/include/d/a/d_a_item.h
@@ -53,6 +53,7 @@ public:
         return checkFlag(flag);
     }
     static void setFlag(s32 id);
+    static bool checkTreasureTempCollect(u16 itemId);
 
     void setItemPosition(const mVec3_c &);
     void getItemFromBWheelItem();
diff --git a/include/d/lyt/d2d.h b/include/d/lyt/d2d.h
index 7030b9b4..d650ee9e 100644
--- a/include/d/lyt/d2d.h
+++ b/include/d/lyt/d2d.h
@@ -5,6 +5,7 @@
 #include "m/m2d.h"
 #include "nw4r/lyt/lyt_pane.h"
 #include "nw4r/lyt/lyt_picture.h"
+#include "nw4r/lyt/lyt_types.h"
 
 class dTextBox_c;
 class dWindow_c;
@@ -260,6 +261,11 @@ struct AnmGroupBase_c {
         return (mFlags & ANMGROUP_FLAG_ENABLE) != 0;
     }
 
+    // Not sure
+    inline u8 isEnabled_() const {
+        return (mFlags & ANMGROUP_FLAG_ENABLE);
+    }
+
     inline bool isStop() const {
         return mpFrameCtrl->isStop();
     }
diff --git a/include/d/lyt/d_lyt_mini_game.h b/include/d/lyt/d_lyt_mini_game.h
index bfb19692..8d3f1f9c 100644
--- a/include/d/lyt/d_lyt_mini_game.h
+++ b/include/d/lyt/d_lyt_mini_game.h
@@ -2,9 +2,381 @@
 #define D_LYT_MINI_GAME_H
 
 #include "common.h"
+#include "d/d_base.h"
+#include "d/lyt/d2d.h"
+#include "m/m_vec.h"
 
-class dLytMiniGame_c {
+/** 2D UI - Mini Game - Pumpkin score popup */
+class dLytMiniGamePumpkinParts_c {
 public:
+    dLytMiniGamePumpkinParts_c() {}
+    virtual ~dLytMiniGamePumpkinParts_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+    void setPumpkinPos(const mVec3_c &pos);
+    void getPoint(u8 combo, bool doubleScore);
+    bool isActive() const;
+
+private:
+    void resetPattern();
+    void setPattern(s32 pat);
+    void startGetPoint();
+    void startDoubleScore();
+    void stopDoubleScore();
+    void resetGetPoint();
+    void resetDoubleScore();
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[3];
+    /* 0x154 */ bool field_0x154;
+    /* 0x158 */ mVec3_c mPumpkinWorldPos;
+    /* 0x164 */ mVec3_c mPumpkinScreenPos;
+    /* 0x170 */ mVec2_c field_0x170;
+    /* 0x178 */ bool mHasPlayedDoubleScoreSound;
+};
+
+/** 2D UI - Mini Game - Pumpkin score popups */
+class dLytMiniGamePumpkin_c {
+public:
+    dLytMiniGamePumpkin_c() {}
+    virtual ~dLytMiniGamePumpkin_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+    void getPoint(const mVec3_c &pumpkinPos, s32 unk, bool doubleScore);
+    void calcCombo(s32 unk);
+
+private:
+    static dLytMiniGamePumpkin_c *sInstance;
+
+    /* 0x004 */ dLytMiniGamePumpkinParts_c mParts[3];
+    /* 0x478 */ s32 field_0x478;
+    /* 0x47C */ s32 mCombo;
+};
+
+/** 2D UI - Mini Game - Bug Heaven */
+class dLytMiniGameBugs_c {
+public:
+    dLytMiniGameBugs_c() {}
+    virtual ~dLytMiniGameBugs_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+    enum BugIndex_e {
+        DEKU_HORNET,
+        BLESSED_BUTTERFLY,
+        GERUDO_DRAGONFLY,
+        STARRY_FIREFLY,
+        WOODLAND_RHINO_BEETLE,
+        VOLCANIC_LADYBUG,
+        SAND_CICADA,
+        SKY_STAG_BEETLE,
+        FARON_GRASSHOPPER,
+        SKYLOFT_MANTIS,
+        LANAYRU_ANT,
+        ELDIN_ROLLER,
+    };
+
+private:
+    void startAllIconsIn();
+    void startOut();
+    void startIn();
+    void startOutForced();
+    void collectBug(s32 slot);
+    void startBugsFlash();
+    void setBug(s32 slot, s32 bugIndex);
+    bool isSlotIconOnEndReached(s32 slot) const;
+    bool isSlotIconOnEnabled(s32 slot) const;
+    bool isSlotBugCollected(s32 slot);
+    void resetBugIconsIn();
+    void resetIn();
+    void resetOut();
+    void resetBugIconsOn();
+    void resetBugIconsTex();
+    void resetBugIconsFlash();
+    void stopBugIconsIn();
+    void stopIn();
+    void stopOut();
+    void stopBugIconOn(s32);
+    void stopBugIconsFlash();
+    bool isIconInEndReached() const;
+    bool isInEndReached() const;
+    bool isOutEndReached() const;
+    bool isSlotOnEndReached(s32 slot) const;
+    bool isBug0Flashing() const;
+    bool areAllBugIconsOn() const;
+
+    const d2d::AnmGroup_c &getAnm(s32 idx) const {
+        return mAnm[idx];
+    }
+
+    d2d::AnmGroup_c &getAnm(s32 idx) {
+        return mAnm[idx];
+    }
+
+    static dLytMiniGameBugs_c *sInstance;
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[42];
+    /* 0xB14 */ s32 mBugItemIds[10];
+    /* 0xB3C */ bool mBugIconsInEnded;
+    /* 0xB3D */ bool mInTriggered;
+    /* 0xB3E */ bool mBugCollected[10];
+    /* 0xB48 */ bool mBugIconsFlashStarted;
+    /* 0xB49 */ u8 mBugsNumLevel; ///< 0 = 5 bugs, 1 = 10 bugs
+    /* 0xB4A */ u8 mBugsNum;
+    /* 0xB4B */ bool field_0xB4B;
+    /* 0xB4C */ bool field_0xB4C;
+};
+
+/** 2D UI - Mini Game - Time */
+class dLytMiniGameTime_c {
+public:
+    dLytMiniGameTime_c() {}
+    virtual ~dLytMiniGameTime_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+private:
+    enum TimerVariant_e {
+        TIMER_LONG,
+        TIMER_SECONDS,
+    };
+
+    void fn_8028DD80();
+    void fn_8028DE40();
+    void fn_8028DED0();
+    void fn_8028DFD0();
+    void fn_8028E0C0();
+    void fn_8028E170();
+    void fn_8028E1D0();
+    void startLoop();
+    void setTimerValueInMilliSeconds(s32 time);
+    void updateLongTimer();
+    void setTimerSecondsValueInMilliSeconds(s32 time);
+    void updateSecondsTimer();
+    void saveSecondsTimer();
+    void setBestTime(s32 time);
+    void setShowBestTime(bool show);
+    void resetIn();
+    void resetOut();
+    void resetAlphaIn();
+    void resetAlphaOut();
+    void resetDigits();
+    void fn_8028EBB0();
+    void resetShowBestTime();
+    void resetFinish();
+    void resetLoop();
+    void initSignChange();
+    void stopIn();
+    void stopOut();
+    void stopAlphaIn();
+    void stopAlphaOut();
+    void stopFinish();
+    void stopLoop();
+    bool isInEndReached() const;
+    bool isOutEndReached() const;
+    bool isAlphaInEndReached() const;
+    bool isAlphaOutEndReached() const;
+    bool isFinishEndReached() const;
+    void setHighestDigitIndex(u8);
+    void setSignChange(u32);
+    void fn_8028F240(bool);
+    void setBestHasSixDigits(bool);
+    void setDigit(s32 digitIndex, s32 number);
+    void setDigitBest(s32 digitIndex, s32 number);
+
+    static dLytMiniGameTime_c *sInstance;
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[29];
+    /* 0x7D4 */ u8 field_0x7D4;
+    /* 0x7D8 */ s32 mCurrentTimerValueMilliSeconds;
+    /* 0x7DC */ s32 mCurrentTimerValueSeconds;
+    /* 0x7E0 */ s32 mLastTimerValueSeconds;
+    /* 0x7E4 */ u8 mTimerVariant;
+    /* 0x7E4 */ s32 mHighestDigitIndex;
+    /* 0x7EC */ bool field_0x7EC;
+    /* 0x7ED */ bool field_0x7ED;
+    /* 0x7EE */ bool field_0x7EE;
+    /* 0x7F0 */ UNKWORD field_0x7F0;
+    /* 0x7F4 */ u8 field_0x7F4;
+    /* 0x7F5 */ bool mIsVisible;
+};
+
+/** 2D UI - Mini Game - Start Popup */
+class dLytMiniGameStart_c {
+public:
+    dLytMiniGameStart_c() {}
+    virtual ~dLytMiniGameStart_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+private:
+    static dLytMiniGameStart_c *sInstance;
+
+    void fn_8028F990();
+    void fn_8028F9E0();
+    void fn_8028FA40();
+    void fn_8028FA90();
+    void fn_8028FAE0();
+    void fn_8028FB40();
+    void fn_8028FBA0();
+    void fn_8028FC00();
+    void fn_8028FC20();
+    void fn_8028FC80();
+    void fn_8028FCE0();
+    void fn_8028FD40();
+    void fn_8028FD50();
+    void fn_8028FD60();
+    void fn_8028FD70();
+    void fn_8028FDC0();
+    void fn_8028FE10();
+    void fn_8028FE60();
+    void fn_8028FEB0();
+    void fn_8028FF00();
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[3];
+};
+
+/** 2D UI - Mini Game - Score counter */
+class dLytMiniGameScore_c {
+public:
+    dLytMiniGameScore_c() {}
+    virtual ~dLytMiniGameScore_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+private:
+    static dLytMiniGameScore_c *sInstance;
+
+    void fn_80291410();
+    void fn_802915B0();
+    void fn_80291640();
+    void fn_80291740();
+    void fn_80291830();
+    void fn_80291900();
+    void fn_80291960();
+    void fn_80291A30();
+    void fn_80291B40();
+    void fn_80291BA0();
+    void fn_80291BC0();
+    void fn_80291D40();
+    void fn_80291E50();
+    void fn_80291E90();
+    void fn_80291ED0();
+    void fn_80291EF0();
+    void fn_80292030();
+    void fn_80292040();
+    void fn_802920B0();
+    void fn_80292110();
+    void fn_802921A0();
+    void fn_80292240();
+    void fn_80292250();
+    void fn_802922F0();
+    void fn_80292380();
+    void fn_80292400();
+    void fn_80292480();
+    void fn_80292500();
+    void fn_80292590();
+    void fn_80292610();
+    void fn_80292710();
+    void fn_80292880();
+    void fn_80292910();
+    void fn_80292920();
+    void fn_80292930();
+    void fn_80292940();
+    void fn_80292950();
+    void fn_802929C0();
+    void fn_80292A40();
+    void fn_80292A50();
+    void fn_80292AA0();
+    void fn_80292AF0();
+    void fn_80292B40();
+    void fn_80292B90();
+    void fn_80292BE0();
+    void fn_80292C30();
+    void fn_802933A0();
+    void fn_80293410();
+    void fn_80293450();
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[26];
+};
+
+/** 2D UI - Mini Game - Fun Fun Island score */
+class dLytMiniGameScoreSd_c {
+public:
+    dLytMiniGameScoreSd_c() {}
+    virtual ~dLytMiniGameScoreSd_c() {}
+
+    bool build(d2d::ResAccIf_c *resAcc);
+    bool remove();
+    bool execute();
+    bool draw();
+    void init();
+
+    void fn_80293A30();
+    void fn_80293A90();
+    void fn_80293AF0();
+    void fn_80293BB0();
+    void fn_80293C60();
+    void fn_80293D40();
+    void fn_80293DC0();
+    void fn_80293E40();
+    void fn_80293ED0();
+    void fn_80293F50();
+    void fn_80293FB0();
+    void fn_80294010();
+    void fn_80294020();
+    void fn_80294030();
+    void fn_80294080();
+
+private:
+    static dLytMiniGameScoreSd_c *sInstance;
+
+    /* 0x004 */ d2d::LytBase_c mLyt;
+    /* 0x094 */ d2d::AnmGroup_c mAnm[5];
+};
+
+class dLytMiniGame_c : public dBase_c {
+public:
+    dLytMiniGame_c()
+        : field_0x0068(0),
+          field_0x0069(0),
+          field_0x006A(0),
+          field_0x006B(0),
+          field_0x006C(0),
+          field_0x006D(0),
+          field_0x1510(1) {}
+    virtual ~dLytMiniGame_c() {}
+
     static dLytMiniGame_c *GetInstance() {
         return sInstance;
     }
@@ -38,10 +410,35 @@ public:
     }
 
 private:
-    u8 _0x0000[0x3866 - 0x0000];
-    bool field_0x3866;
-
     static dLytMiniGame_c *sInstance;
+
+    /* 0x0068 */ u8 field_0x0068;
+    /* 0x0069 */ u8 field_0x0069;
+    /* 0x006A */ u8 field_0x006A;
+    /* 0x006B */ u8 field_0x006B;
+    /* 0x006C */ u8 field_0x006C;
+    /* 0x006D */ u8 field_0x006D;
+
+    /* 0x0070 */ d2d::ResAccIf_c mResAcc1;
+    /* 0x03E0 */ d2d::ResAccIf_c mResAcc2;
+    /* 0x0750 */ d2d::ResAccIf_c mResAcc3;
+    /* 0x0AC0 */ d2d::ResAccIf_c mResAcc4;
+    /* 0x0E30 */ d2d::ResAccIf_c mResAcc5;
+    /* 0x11A0 */ d2d::ResAccIf_c mResAcc6;
+
+    /* 0x1510 */ UNKWORD field_0x1510;
+
+    /* 0x1514 */ dLytMiniGameScore_c mScore;
+    /* 0x1D64 */ dLytMiniGameScoreSd_c mScoreSd;
+    /* 0x1F40 */ dLytMiniGameStart_c mStart;
+    /* 0x209C */ dLytMiniGameTime_c mTime;
+    /* 0x2894 */ dLytMiniGameBugs_c mBugs;
+    /* 0x33E4 */ dLytMiniGamePumpkin_c mPumpkin;
+
+    // TODO
+    u8 _0x___[0x14E];
+
+    bool field_0x3866;
 };
 
 #endif
diff --git a/include/toBeSorted/d_d3d.h b/include/toBeSorted/d_d3d.h
index c609b45e..ebfeafd2 100644
--- a/include/toBeSorted/d_d3d.h
+++ b/include/toBeSorted/d_d3d.h
@@ -20,9 +20,9 @@ namespace d3d {
 
 bool create(EGG::Heap *);
 
-f32 fn_80016960(mVec3_c &, const mVec3_c &pos);
-bool fn_80016A90(const mVec3_c &pos);
-void fn_80016B60(mVec3_c &, const mVec3_c &pos);
+f32 worldToScreen(mVec3_c &result, const mVec3_c &worldPos);
+bool isOnScreen(const mVec3_c &worldPos);
+void screenToWorld(mVec3_c &result, const mVec3_c &screenPos);
 void createLightTextures();
 
 class AnmMdlWrapper : public m3d::mdlAnmChr {
diff --git a/src/d/d_cursor_hit_check.cpp b/src/d/d_cursor_hit_check.cpp
index 013d14cb..a5397396 100644
--- a/src/d/d_cursor_hit_check.cpp
+++ b/src/d/d_cursor_hit_check.cpp
@@ -124,7 +124,7 @@ bool dCursorHitCheckCC_c::checkHit(s32 x, s32 y) {
     );
 
     mVec3_c v;
-    d3d::fn_80016B60(v, pos);
+    d3d::screenToWorld(v, pos);
 
     nw4r::g3d::Camera cam = dStageMgr_c::GetInstance()->getCamera(0);
 
diff --git a/src/d/lyt/d_lyt_mini_game.cpp b/src/d/lyt/d_lyt_mini_game.cpp
new file mode 100644
index 00000000..9a6b73b7
--- /dev/null
+++ b/src/d/lyt/d_lyt_mini_game.cpp
@@ -0,0 +1,1694 @@
+#include "d/lyt/d_lyt_mini_game.h"
+
+#include "common.h"
+#include "d/a/d_a_item.h"
+#include "d/a/d_a_itembase.h"
+#include "d/d_lang.h"
+#include "d/lyt/d2d.h"
+#include "d/snd/d_snd_small_effect_mgr.h"
+#include "d/snd/d_snd_wzsound.h"
+#include "m/m_vec.h"
+#include "toBeSorted/d_d3d.h"
+
+static const d2d::LytBrlanMapping brlanMapPumpkin[] = {
+    {    "miniGamePumpkin_00_getPoint.brlan",    "G_scoreAll_00"},
+    { "miniGamePumpkin_00_doubleScore.brlan", "G_doubleScore_00"},
+    {"miniGamePumpkin_00_scorePattern.brlan",     "G_pattern_00"},
+};
+
+#define PUMPKIN_ANIM_GET_POINT 0
+#define PUMPKIN_ANIM_DOUBLE_SCORE 1
+#define PUMPKIN_ANIM_PATTERN 2
+
+#define PUMPKIN_NUM_ANIMS 3
+
+bool dLytMiniGamePumpkinParts_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("miniGamePumpkin_00.brlyt", nullptr);
+
+    for (int i = 0; i < PUMPKIN_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapPumpkin[i].mFile, resAcc, mLyt.getLayout(), brlanMapPumpkin[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+    }
+
+    mPumpkinWorldPos.set(0.0f, 0.0f, 0.0f);
+    mPumpkinScreenPos.set(0.0f, 0.0f, 0.0f);
+    field_0x170.set(0.0f, 0.0f);
+
+    return true;
+}
+
+bool dLytMiniGamePumpkinParts_c::remove() {
+    for (int i = 0; i < PUMPKIN_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    return true;
+}
+
+bool dLytMiniGamePumpkinParts_c::execute() {
+    if (mAnm[PUMPKIN_ANIM_GET_POINT].isEnabled() && mAnm[PUMPKIN_ANIM_GET_POINT].isStop2()) {
+        mAnm[PUMPKIN_ANIM_GET_POINT].setAnimEnable(false);
+        field_0x154 = false;
+    }
+
+    if (mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].isEnabled() && mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].isStop2()) {
+        mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setAnimEnable(false);
+        mHasPlayedDoubleScoreSound = false;
+    }
+
+    if (mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].isEnabled() && 20.0f <= mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].getFrame() &&
+        !mHasPlayedDoubleScoreSound) {
+        dSndSmallEffectMgr_c::GetInstance()->playSound(SE_S_MG_PUMP_SHOT_DOUBLE);
+        mHasPlayedDoubleScoreSound = true;
+    }
+
+    for (int i = 0; i < PUMPKIN_NUM_ANIMS; i++) {
+        if (mAnm[i].isEnabled()) {
+            mAnm[i].play();
+        }
+    }
+
+    if (field_0x154) {
+        d3d::worldToScreen(mPumpkinScreenPos, mPumpkinWorldPos);
+        mVec3_c tmp = mPumpkinScreenPos;
+        tmp.z = 0.0f;
+        field_0x170.set(tmp.x, tmp.y);
+        mLyt.getLayout()->GetRootPane()->SetTranslate(tmp);
+    }
+
+    mLyt.calc();
+
+    return true;
+}
+
+bool dLytMiniGamePumpkinParts_c::draw() {
+    mLyt.addToDrawList();
+    return true;
+}
+
+void dLytMiniGamePumpkinParts_c::init() {
+    resetPattern();
+    resetDoubleScore();
+    resetGetPoint();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setToStart();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setAnimEnable(true);
+    mLyt.calc();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setAnimEnable(false);
+}
+
+void dLytMiniGamePumpkinParts_c::setPumpkinPos(const mVec3_c &pos) {
+    mPumpkinWorldPos = pos;
+    d3d::worldToScreen(mPumpkinScreenPos, mPumpkinWorldPos);
+    mVec3_c tmp = mPumpkinScreenPos;
+    tmp.z = 0.0f;
+    field_0x170.set(tmp.x, tmp.y);
+    mLyt.getLayout()->GetRootPane()->SetTranslate(tmp);
+    mLyt.calc();
+}
+
+void dLytMiniGamePumpkinParts_c::getPoint(u8 combo, bool doubleScore) {
+    startGetPoint();
+    setPattern(combo);
+    if (doubleScore) {
+        startDoubleScore();
+    } else {
+        stopDoubleScore();
+    }
+    field_0x154 = true;
+}
+
+bool dLytMiniGamePumpkinParts_c::isActive() const {
+    return mAnm[PUMPKIN_ANIM_GET_POINT].isEnabled() || mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].isEnabled();
+}
+
+void dLytMiniGamePumpkinParts_c::startGetPoint() {
+    mAnm[PUMPKIN_ANIM_GET_POINT].setToStart();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setAnimEnable(true);
+}
+
+void dLytMiniGamePumpkinParts_c::startDoubleScore() {
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setToStart();
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setAnimEnable(true);
+}
+
+void dLytMiniGamePumpkinParts_c::stopDoubleScore() {
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setAnimEnable(false);
+}
+
+void dLytMiniGamePumpkinParts_c::resetGetPoint() {
+    mAnm[PUMPKIN_ANIM_GET_POINT].setForwardOnce();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setToStart();
+    mAnm[PUMPKIN_ANIM_GET_POINT].setAnimEnable(false);
+}
+
+void dLytMiniGamePumpkinParts_c::resetDoubleScore() {
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setForwardOnce();
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setToStart();
+    mAnm[PUMPKIN_ANIM_DOUBLE_SCORE].setAnimEnable(false);
+}
+
+void dLytMiniGamePumpkinParts_c::resetPattern() {
+    mAnm[PUMPKIN_ANIM_PATTERN].setForwardOnce();
+    mAnm[PUMPKIN_ANIM_PATTERN].setFrame(0.0f);
+    mAnm[PUMPKIN_ANIM_PATTERN].setRate(0.0f);
+    mAnm[PUMPKIN_ANIM_PATTERN].setAnimEnable(false);
+}
+
+void dLytMiniGamePumpkinParts_c::setPattern(s32 pat) {
+    u32 frame = 0;
+    switch (pat) {
+        case 0:
+            frame = 0;
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameScoreUpSound(10);
+            break;
+        case 1:
+            frame = 1;
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameScoreUpSound(20);
+            break;
+        case 2:
+            frame = 2;
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameScoreUpSound(30);
+            break;
+        case 3:
+            frame = 3;
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameScoreUpSound(40);
+            break;
+        case 4:
+            frame = 4;
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameScoreUpSound(50);
+            break;
+    }
+    mAnm[PUMPKIN_ANIM_PATTERN].setFrame(frame);
+    mAnm[PUMPKIN_ANIM_PATTERN].setAnimEnable(true);
+    mLyt.calc();
+    mAnm[PUMPKIN_ANIM_PATTERN].setAnimEnable(false);
+}
+
+bool dLytMiniGamePumpkin_c::build(d2d::ResAccIf_c *resAcc) {
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        mParts[i].build(resAcc);
+    }
+    sInstance = this;
+    return true;
+}
+
+bool dLytMiniGamePumpkin_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        mParts[i].remove();
+    }
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGamePumpkin_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        mParts[i].execute();
+    }
+    return true;
+}
+
+bool dLytMiniGamePumpkin_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        mParts[i].draw();
+    }
+    return true;
+}
+
+void dLytMiniGamePumpkin_c::init() {
+    if (sInstance == nullptr) {
+        return;
+    }
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        mParts[i].init();
+    }
+    return;
+}
+
+void dLytMiniGamePumpkin_c::getPoint(const mVec3_c &pumpkinPos, s32 unk, bool doubleScore) {
+    if (sInstance == nullptr) {
+        return;
+    }
+    calcCombo(unk);
+    for (int i = 0; i < (int)ARRAY_LENGTH(mParts); i++) {
+        if (!mParts[i].isActive()) {
+            mParts[i].setPumpkinPos(pumpkinPos);
+            mParts[i].getPoint(mCombo, doubleScore);
+            return;
+        }
+    }
+}
+
+void dLytMiniGamePumpkin_c::calcCombo(s32 unk) {
+    if (unk < field_0x478) {
+        mCombo = 0;
+    } else if (field_0x478 < unk) {
+        mCombo++;
+    }
+    if (mCombo >= 5) {
+        mCombo = 4;
+    }
+    field_0x478 = unk;
+}
+
+static const d2d::LytBrlanMapping brlanMapBugs[] = {
+    {  "miniGameBugs_00_alphaIn.brlan",   "G_inOut_00"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_00"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_01"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_02"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_03"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_04"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_05"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_06"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_07"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_08"},
+    {       "miniGameBugs_00_in.brlan", "G_bugIcon_09"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_00"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_01"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_02"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_03"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_04"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_05"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_06"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_07"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_08"},
+    {   "miniGameBugs_00_iconOn.brlan", "G_bugIcon_09"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_00"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_01"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_02"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_03"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_04"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_05"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_06"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_07"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_08"},
+    {     "miniGameBugs_00_bugs.brlan", "G_texAnim_09"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_00"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_01"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_02"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_03"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_04"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_05"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_06"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_07"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_08"},
+    {"miniGameBugs_00_iconFlash.brlan", "G_bugIcon_09"},
+    { "miniGameBugs_00_alphaOut.brlan",   "G_inOut_00"},
+};
+
+#define BUGS_ANIM_IN 0
+#define BUGS_ANIM_ICON_IN_OFFSET 1
+#define BUGS_ANIM_ICON_ON_OFFSET 11
+#define BUGS_ANIM_ICON_TEX_ANIM_OFFSET 21
+#define BUGS_ANIM_ICON_FLASH_OFFSET 31
+#define BUGS_ANIM_OUT 41
+
+#define BUGS_NUM_ANIMS 42
+#define BUGS_NUM_BUGS 10
+
+bool dLytMiniGameBugs_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("miniGameBugs_00.brlyt", nullptr);
+
+    for (int i = 0; i < BUGS_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapBugs[i].mFile, resAcc, mLyt.getLayout(), brlanMapBugs[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+    }
+
+    sInstance = this;
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        mBugCollected[i] = 0;
+    }
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        mBugItemIds[i] = ITEM_DEKU_HORNET;
+    }
+
+    return true;
+}
+
+bool dLytMiniGameBugs_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    if (isBug0Flashing()) {
+        stopBugIconsFlash();
+    }
+    for (int i = 0; i < BUGS_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGameBugs_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+
+    if (areAllBugIconsOn()) {
+        startBugsFlash();
+    }
+
+    if (isIconInEndReached()) {
+        stopBugIconsIn();
+        mBugIconsInEnded = true;
+    }
+
+    if (isInEndReached()) {
+        stopIn();
+        for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+            if (mBugCollected[i] == true) {
+                collectBug(i);
+            }
+        }
+    }
+
+    if (isOutEndReached()) {
+        stopOut();
+    }
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        if (isSlotOnEndReached(i)) {
+            stopBugIconOn(i);
+        }
+    }
+
+    for (int i = 0; i < BUGS_NUM_ANIMS; i++) {
+        if (mAnm[i].isEnabled()) {
+            mAnm[i].play();
+        }
+    }
+
+    mLyt.calc();
+
+    return true;
+}
+
+bool dLytMiniGameBugs_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    mLyt.addToDrawList();
+    return true;
+}
+
+void dLytMiniGameBugs_c::init() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    switch (mBugsNumLevel) {
+        case 0: mBugsNum = 5; break;
+        case 1: mBugsNum = 10; break;
+    }
+
+    resetBugIconsTex();
+    resetBugIconsOn();
+    resetBugIconsFlash();
+    resetIn();
+    resetOut();
+    resetBugIconsIn();
+}
+
+void dLytMiniGameBugs_c::startAllIconsIn() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (mInTriggered != true) {
+        for (int i = 0; i < mBugsNum; i++) {
+            mAnm[i + BUGS_ANIM_ICON_IN_OFFSET].setToStart();
+            mAnm[i + BUGS_ANIM_ICON_IN_OFFSET].setAnimEnable(true);
+        }
+        mInTriggered = true;
+        field_0xB4B = true;
+    }
+}
+
+void dLytMiniGameBugs_c::startOut() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (mBugIconsInEnded && mInTriggered && field_0xB4B) {
+        mAnm[BUGS_ANIM_OUT].setToStart();
+        mAnm[BUGS_ANIM_OUT].setAnimEnable(true);
+        mInTriggered = false;
+        field_0xB4B = false;
+    }
+}
+
+void dLytMiniGameBugs_c::startIn() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (mBugIconsInEnded && mInTriggered != true && field_0xB4B) {
+        mAnm[BUGS_ANIM_IN].setToStart();
+        mAnm[BUGS_ANIM_IN].setAnimEnable(true);
+        mInTriggered = true;
+    }
+}
+
+void dLytMiniGameBugs_c::startOutForced() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (mBugIconsInEnded && mInTriggered) {
+        mAnm[BUGS_ANIM_OUT].setToStart();
+        mAnm[BUGS_ANIM_OUT].setAnimEnable(true);
+        mInTriggered = false;
+    }
+}
+
+void dLytMiniGameBugs_c::collectBug(s32 slot) {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (mBugCollected[slot] == false) {
+        mBugCollected[slot] = true;
+        if (dAcItem_c::checkTreasureTempCollect(mBugItemIds[slot])) {
+            field_0xB4C = false;
+        }
+        if (field_0xB4C) {
+            return;
+        }
+    }
+
+    if (isSlotIconOnEndReached(slot) || isSlotIconOnEnabled(slot)) {
+        return;
+    }
+
+    mAnm[slot + BUGS_ANIM_ICON_ON_OFFSET].setToStart();
+    mAnm[slot + BUGS_ANIM_ICON_ON_OFFSET].setAnimEnable(true);
+
+    u8 bugsCount = 0;
+    for (int i = 0; i < mBugsNum; i++) {
+        if (mBugCollected[i]) {
+            bugsCount++;
+        }
+    }
+
+    if (bugsCount != mBugsNum) {
+        dSndSmallEffectMgr_c::GetInstance()->playSound(SE_S_MG_MUSHITORI_GET);
+    }
+    field_0xB4C = true;
+}
+
+void dLytMiniGameBugs_c::startBugsFlash() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (!mBugIconsFlashStarted) {
+        mBugIconsFlashStarted = true;
+        return;
+    }
+
+    if (!isBug0Flashing()) {
+        for (int i = 0; i < mBugsNum; i++) {
+            s32 idx = i + BUGS_ANIM_ICON_FLASH_OFFSET;
+            mAnm[idx].setToStart();
+            mAnm[idx].setAnimEnable(true);
+        }
+    }
+}
+
+// corresponds to BugIndex_e
+static const s32 sBugItemIds[] = {
+    ITEM_DEKU_HORNET,           ITEM_BLESSED_BUTTERFLY, ITEM_GERUDO_DRAGONFLY, ITEM_STARRY_FIREFLY,
+    ITEM_WOODLAND_RHINO_BEETLE, ITEM_VOLCANIC_LADYBUG,  ITEM_SAND_CICADA,      ITEM_SKY_STAG_BEETLE,
+    ITEM_FARON_GRASSHOPPER,     ITEM_SKYLOFT_MANTIS,    ITEM_LANAYRU_ANT,      ITEM_ELDIN_ROLLER,
+};
+
+void dLytMiniGameBugs_c::setBug(s32 slot, s32 bugIndex) {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    f32 frame = static_cast<float>(bugIndex);
+    mAnm[slot + BUGS_ANIM_ICON_TEX_ANIM_OFFSET].setFrame(frame);
+    mAnm[slot + BUGS_ANIM_ICON_TEX_ANIM_OFFSET].setAnimEnable(true);
+    mLyt.calc();
+    mAnm[slot + BUGS_ANIM_ICON_TEX_ANIM_OFFSET].setAnimEnable(false);
+    mBugItemIds[slot] = sBugItemIds[bugIndex];
+}
+
+bool dLytMiniGameBugs_c::isSlotIconOnEndReached(s32 slot) const {
+    if (sInstance == nullptr) {
+        return false;
+    }
+    s32 idx = slot + BUGS_ANIM_ICON_ON_OFFSET;
+    return mAnm[idx].isEndReached();
+}
+
+bool dLytMiniGameBugs_c::isSlotIconOnEnabled(s32 slot) const {
+    if (sInstance == nullptr) {
+        return false;
+    }
+    s32 idx = slot + BUGS_ANIM_ICON_ON_OFFSET;
+    return mAnm[idx].isEnabled_();
+}
+
+bool dLytMiniGameBugs_c::isSlotBugCollected(s32 slot) {
+    if (sInstance == nullptr) {
+        return false;
+    }
+    return mBugCollected[slot] == true;
+}
+
+void dLytMiniGameBugs_c::resetBugIconsIn() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_IN_OFFSET;
+        mAnm[idx].setForwardOnce();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    mLyt.calc();
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_IN_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameBugs_c::resetIn() {
+    mAnm[BUGS_ANIM_IN].setForwardOnce();
+    mAnm[BUGS_ANIM_IN].setToStart();
+    mAnm[BUGS_ANIM_IN].setAnimEnable(true);
+    mLyt.calc();
+    mAnm[BUGS_ANIM_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameBugs_c::resetOut() {
+    mAnm[BUGS_ANIM_OUT].setForwardOnce();
+    mAnm[BUGS_ANIM_OUT].setToStart();
+    mAnm[BUGS_ANIM_OUT].setAnimEnable(true);
+    mLyt.calc();
+    mAnm[BUGS_ANIM_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameBugs_c::resetBugIconsOn() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_ON_OFFSET;
+        mAnm[idx].setForwardOnce();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    mLyt.calc();
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_ON_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameBugs_c::resetBugIconsTex() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_TEX_ANIM_OFFSET;
+        mAnm[idx].setForwardOnce();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    mLyt.calc();
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_TEX_ANIM_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameBugs_c::resetBugIconsFlash() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_FLASH_OFFSET;
+        mAnm[idx].setForwardLoop();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    mLyt.calc();
+
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_FLASH_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameBugs_c::stopBugIconsIn() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_IN_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameBugs_c::stopIn() {
+    mAnm[BUGS_ANIM_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameBugs_c::stopOut() {
+    mAnm[BUGS_ANIM_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameBugs_c::stopBugIconOn(s32 slot) {
+    mAnm[slot + BUGS_ANIM_ICON_ON_OFFSET].setAnimEnable(false);
+}
+
+void dLytMiniGameBugs_c::stopBugIconsFlash() {
+    for (int i = 0; i < BUGS_NUM_BUGS; i++) {
+        s32 idx = i + BUGS_ANIM_ICON_FLASH_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+bool dLytMiniGameBugs_c::isIconInEndReached() const {
+    s32 idx = 0 + BUGS_ANIM_ICON_IN_OFFSET;
+    if (mAnm[idx].isEnabled() && mAnm[idx].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameBugs_c::isInEndReached() const {
+    s32 idx = BUGS_ANIM_IN;
+    if (mAnm[idx].isEnabled() && mAnm[idx].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameBugs_c::isOutEndReached() const {
+    s32 idx = BUGS_ANIM_OUT;
+    if (mAnm[idx].isEnabled() && mAnm[idx].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameBugs_c::isSlotOnEndReached(s32 slot) const {
+    s32 idx = slot + BUGS_ANIM_ICON_ON_OFFSET;
+    if (mAnm[idx].isEnabled() && mAnm[idx].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameBugs_c::isBug0Flashing() const {
+    s32 idx = 0 + BUGS_ANIM_ICON_FLASH_OFFSET;
+    return mAnm[idx].isEnabled_();
+}
+
+bool dLytMiniGameBugs_c::areAllBugIconsOn() const {
+    bool ret = true;
+    for (int i = 0; i < mBugsNum; i++) {
+        if (!isSlotIconOnEndReached(i)) {
+            ret = false;
+            break;
+        }
+    }
+    return ret;
+}
+
+static const d2d::LytBrlanMapping brlanMapTime[] = {
+    {         "miniGameTime_00_in.brlan",      "G_inOut_00"},
+    {    "miniGameTime_00_alphaIn.brlan", "G_alphaInOut_00"},
+    {        "miniGameTime_00_out.brlan",      "G_inOut_00"},
+    { "miniGameTime_00_signChange.brlan", "G_signChange_00"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_00"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_01"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_02"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_03"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_04"},
+    {       "miniGameTime_00_0to9.brlan",       "G_0to9_05"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_00"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_01"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_02"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_03"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_04"},
+    {       "miniGameTime_00_0to9.brlan",      "G_0to9B_05"},
+    {"miniGameTime_00_setPosition.brlan",    "G_setPosi_00"},
+    {"miniGameTime_00_setPosition.brlan",   "G_setPosiB_00"},
+    {"miniGameTime_00_setPosition.brlan",      "G_0to9B_05"},
+    {"miniGameTime_00_bScoreOnOff.brlan",  "G_bestScore_00"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_00"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_01"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_02"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_03"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_04"},
+    { "miniGameTime_00_finishTime.brlan",     "G_finish_05"},
+    { "miniGameTime_00_finishTime.brlan",    "G_finishW_00"},
+    {   "miniGameTime_00_loopTime.brlan",   "G_loopTime_00"},
+    {   "miniGameTime_00_alphaOut.brlan", "G_alphaInOut_00"},
+};
+
+#define TIME_ANIM_IN 0
+#define TIME_ANIM_ALPHA_IN 1
+#define TIME_ANIM_OUT 2
+#define TIME_ANIM_SIGN_CHANGE 3
+#define TIME_ANIM_0_TO_9_OFFSET 4
+#define TIME_ANIM_0_TO_9_B_OFFSET 10
+#define TIME_ANIM_SET_POSITION 16
+#define TIME_ANIM_SET_POSITION_B 17
+#define TIME_ANIM_SET_POSITION_0_TO_9_B 18
+#define TIME_ANIM_BEST_SCORE_ON_OFF 19
+#define TIME_ANIM_FINISH_OFFSET 20
+#define TIME_ANIM_FINISH_W 26
+#define TIME_ANIM_LOOP_TIME 27
+#define TIME_ANIM_ALPHA_OUT 28
+
+#define TIME_NUM_ANIMS 29
+
+#define TIME_NUM_DIGITS 6
+
+bool dLytMiniGameTime_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("miniGameTime_00.brlyt", nullptr);
+
+    for (int i = 0; i < TIME_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapTime[i].mFile, resAcc, mLyt.getLayout(), brlanMapTime[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+        mAnm[i].setAnimEnable(false);
+    }
+
+    sInstance = this;
+    return true;
+}
+
+bool dLytMiniGameTime_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < TIME_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGameTime_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+
+    if (mIsVisible) {
+        switch (mTimerVariant) {
+            case TIMER_LONG:    updateLongTimer(); break;
+            case TIMER_SECONDS: updateSecondsTimer(); break;
+        }
+
+        if (isInEndReached()) {
+            stopIn();
+            field_0x7EC = true;
+        }
+
+        if (isOutEndReached()) {
+            stopOut();
+            stopLoop();
+            resetLoop();
+            mIsVisible = false;
+        }
+
+        if (isAlphaInEndReached()) {
+            stopAlphaIn();
+            if (field_0x7EE) {
+                startLoop();
+            }
+        }
+
+        if (isAlphaOutEndReached()) {
+            stopAlphaOut();
+            if (field_0x7EE) {
+                stopLoop();
+                resetLoop();
+            }
+            mIsVisible = false;
+        }
+
+        if (isFinishEndReached()) {
+            stopFinish();
+            startLoop();
+        }
+
+        for (int i = 0; i < TIME_NUM_ANIMS; i++) {
+            if (mAnm[i].isEnabled()) {
+                mAnm[i].play();
+            }
+        }
+        mLyt.calc();
+    }
+
+    if (mTimerVariant == TIMER_SECONDS) {
+        if (mCurrentTimerValueSeconds <= 10 && mLastTimerValueSeconds != mCurrentTimerValueSeconds) {
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameTimeUpSound(mCurrentTimerValueSeconds);
+        }
+        saveSecondsTimer();
+    }
+
+    if (field_0x7F0 == 0) {
+        if (mCurrentTimerValueSeconds >= 590 && mLastTimerValueSeconds != mCurrentTimerValueSeconds &&
+            mCurrentTimerValueSeconds != 600) {
+            dSndSmallEffectMgr_c::GetInstance()->playMinigameTimeUpSound(600 - mCurrentTimerValueSeconds);
+        }
+        saveSecondsTimer();
+    }
+
+    return true;
+}
+
+bool dLytMiniGameTime_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    if (mIsVisible) {
+        mLyt.addToDrawList();
+    }
+    return true;
+}
+
+void dLytMiniGameTime_c::init() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    switch (field_0x7F0) {
+        case 0: mTimerVariant = TIMER_LONG; break;
+        case 1: mTimerVariant = TIMER_SECONDS; break;
+        case 2: mTimerVariant = TIMER_SECONDS; break;
+        case 3: mTimerVariant = TIMER_LONG; break;
+        case 4: mTimerVariant = TIMER_LONG; break;
+        case 5: mTimerVariant = TIMER_LONG; break;
+    }
+
+    resetAlphaIn();
+    resetAlphaOut();
+    resetOut();
+    resetDigits();
+    fn_8028EBB0();
+    resetShowBestTime();
+    resetFinish();
+    resetLoop();
+    initSignChange();
+    resetIn();
+}
+
+void dLytMiniGameTime_c::fn_8028DD80() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (field_0x7ED == true) {
+        return;
+    }
+
+    mAnm[TIME_ANIM_ALPHA_IN].setToEnd2();
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(true);
+
+    mAnm[TIME_ANIM_IN].setToStart();
+    mAnm[TIME_ANIM_IN].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(false);
+
+    field_0x7ED = true;
+    field_0x7F4 = true;
+    mIsVisible = true;
+}
+
+void dLytMiniGameTime_c::fn_8028DE40() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (field_0x7EC && field_0x7ED) {
+        mAnm[TIME_ANIM_OUT].setToStart();
+        mAnm[TIME_ANIM_OUT].setAnimEnable(true);
+
+        field_0x7ED = false;
+        field_0x7F4 = false;
+    }
+}
+
+void dLytMiniGameTime_c::fn_8028DED0() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (field_0x7EC && field_0x7ED != true && field_0x7F4) {
+        if (!mAnm[TIME_ANIM_ALPHA_IN].isEnabled()) {
+            if (mAnm[TIME_ANIM_ALPHA_OUT].isEnabled()) {
+                mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(false);
+                // TODO maybe these inlines are wrong
+                f32 frame = mAnm[TIME_ANIM_ALPHA_OUT].getLastFrame();
+                f32 t = mAnm[TIME_ANIM_ALPHA_IN].getLastFrame();
+                frame -= mAnm[TIME_ANIM_ALPHA_OUT].getFrame();
+                if (t <= frame) {
+                    frame = t - 1.0f;
+                }
+                mAnm[TIME_ANIM_ALPHA_IN].setFrame(frame);
+            } else {
+                mAnm[TIME_ANIM_ALPHA_IN].setToStart();
+            }
+
+            mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(true);
+            field_0x7ED = true;
+        }
+
+        mIsVisible = true;
+    }
+}
+
+void dLytMiniGameTime_c::fn_8028DFD0() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    if (field_0x7EC && field_0x7ED) {
+        if (!mAnm[TIME_ANIM_ALPHA_OUT].isEnabled()) {
+            if (mAnm[TIME_ANIM_ALPHA_IN].isEnabled()) {
+                mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(false);
+                // TODO maybe these inlines are wrong
+                f32 frame = mAnm[TIME_ANIM_ALPHA_IN].getLastFrame();
+                f32 t = mAnm[TIME_ANIM_ALPHA_OUT].getLastFrame();
+                frame -= mAnm[TIME_ANIM_ALPHA_IN].getFrame();
+                if (t <= frame) {
+                    frame = t - 1.0f;
+                }
+                mAnm[TIME_ANIM_ALPHA_OUT].setFrame(frame);
+            } else {
+                mAnm[TIME_ANIM_ALPHA_OUT].setToStart();
+            }
+
+            mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(true);
+            field_0x7ED = false;
+        }
+    }
+}
+
+void dLytMiniGameTime_c::fn_8028E0C0() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    mAnm[TIME_ANIM_IN].setToEnd2();
+    mAnm[TIME_ANIM_IN].setAnimEnable(true);
+
+    mAnm[TIME_ANIM_ALPHA_IN].setToStart();
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_IN].setAnimEnable(false);
+    mIsVisible = true;
+}
+
+void dLytMiniGameTime_c::fn_8028E170() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    mAnm[TIME_ANIM_ALPHA_OUT].setToStart();
+    mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(true);
+}
+
+void dLytMiniGameTime_c::fn_8028E1D0() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    for (int i = 0; i <= mHighestDigitIndex; i++) {
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setToStart();
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setAnimEnable(true);
+    }
+
+    mAnm[TIME_ANIM_FINISH_W].setToStart();
+    mAnm[TIME_ANIM_FINISH_W].setAnimEnable(true);
+}
+
+void dLytMiniGameTime_c::startLoop() {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    mAnm[TIME_ANIM_LOOP_TIME].setFrame(0.0f);
+    mAnm[TIME_ANIM_LOOP_TIME].setAnimEnable(true);
+}
+
+void dLytMiniGameTime_c::setTimerValueInMilliSeconds(s32 a) {
+    if (sInstance == nullptr) {
+        return;
+    }
+    mCurrentTimerValueMilliSeconds = a;
+}
+
+void dLytMiniGameTime_c::updateLongTimer() {
+    s32 msec = mCurrentTimerValueMilliSeconds % 1000;
+    s32 sec = mCurrentTimerValueMilliSeconds / 1000;
+    s32 csec = msec / 10;
+    s32 min = sec / 60;
+    s32 sec1 = sec % 60;
+
+    mCurrentTimerValueSeconds = sec1 + min * 60;
+
+    s32 digits[6];
+    // ten-minutes
+    digits[5] = min / 10;
+    // minutes
+    digits[4] = min % 10;
+    // ten-seconds
+    digits[3] = sec1 / 10;
+    // seconds
+    digits[2] = sec1 % 10;
+    // tenths-of-a-second
+    digits[1] = csec / 10;
+    // hundredths-of-a-second
+    digits[0] = csec % 10;
+
+    if (digits[5] != 0) {
+        mHighestDigitIndex = 5;
+        fn_8028F240(true);
+    } else {
+        mHighestDigitIndex = 4;
+        fn_8028F240(false);
+    }
+
+    for (int i = 0; i <= mHighestDigitIndex; i++) {
+        setDigit(i, digits[i]);
+    }
+}
+
+void dLytMiniGameTime_c::setTimerSecondsValueInMilliSeconds(s32 time) {
+    if (sInstance == nullptr) {
+        return;
+    }
+    mCurrentTimerValueSeconds = time / 1000;
+}
+
+void dLytMiniGameTime_c::updateSecondsTimer() {
+    if (mCurrentTimerValueSeconds > 999) {
+        mCurrentTimerValueSeconds = 999;
+    }
+    s32 seconds = mCurrentTimerValueSeconds % 100;
+
+    s32 digits[3];
+    // 100-seconds
+    digits[2] = mCurrentTimerValueSeconds / 100;
+    // ten-seconds
+    digits[1] = seconds / 10;
+    // seconds
+    digits[0] = seconds % 10;
+
+    if (mCurrentTimerValueSeconds < 10) {
+        mHighestDigitIndex = 0;
+    } else if (mCurrentTimerValueSeconds < 100) {
+        mHighestDigitIndex = 1;
+    } else {
+        mHighestDigitIndex = 2;
+    }
+    setHighestDigitIndex(mHighestDigitIndex);
+    for (int i = 0; i <= mHighestDigitIndex; i++) {
+        setDigit(i + 2, digits[i]);
+    }
+}
+
+void dLytMiniGameTime_c::saveSecondsTimer() {
+    mLastTimerValueSeconds = mCurrentTimerValueSeconds;
+}
+
+void dLytMiniGameTime_c::setBestTime(s32 time) {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    s32 offset = 1;
+
+    s32 msec = time % 1000;
+    s32 sec = time / 1000;
+    s32 csec = msec / 10;
+    s32 min = sec / 60;
+    s32 sec1 = sec % 60;
+
+    s32 digits[6];
+    // ten-minutes
+    digits[5] = min / 10;
+    // minutes
+    digits[4] = min % 10;
+    // ten-seconds
+    digits[3] = sec1 / 10;
+    // seconds
+    digits[2] = sec1 % 10;
+    // tenths-of-a-second
+    digits[1] = csec / 10;
+    // hundredths-of-a-second
+    digits[0] = csec % 10;
+
+    if (digits[5] != 0) {
+        offset = 0;
+        setBestHasSixDigits(true);
+    } else {
+        setBestHasSixDigits(false);
+    }
+
+    for (int i = 0; i < 6 - offset; i++) {
+        setDigitBest(i, digits[i]);
+    }
+}
+
+void dLytMiniGameTime_c::setShowBestTime(bool show) {
+    if (sInstance == nullptr) {
+        return;
+    }
+
+    f32 frame = 1.0f;
+    if (show) {
+        frame = 0.0f;
+    }
+    mAnm[TIME_ANIM_BEST_SCORE_ON_OFF].setFrame(frame);
+    mAnm[TIME_ANIM_BEST_SCORE_ON_OFF].setAnimEnable(true);
+
+    mLyt.getLayout()->Animate(0);
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_BEST_SCORE_ON_OFF].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::resetIn() {
+    mAnm[TIME_ANIM_IN].setForwardOnce();
+    mAnm[TIME_ANIM_IN].setToStart();
+    mAnm[TIME_ANIM_IN].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::resetOut() {
+    mAnm[TIME_ANIM_OUT].setForwardOnce();
+    mAnm[TIME_ANIM_OUT].setToStart();
+    mAnm[TIME_ANIM_OUT].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::resetAlphaIn() {
+    mAnm[TIME_ANIM_ALPHA_IN].setForwardOnce();
+    mAnm[TIME_ANIM_ALPHA_IN].setToStart();
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::resetAlphaOut() {
+    mAnm[TIME_ANIM_ALPHA_OUT].setForwardOnce();
+    mAnm[TIME_ANIM_ALPHA_OUT].setToStart();
+    mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::resetDigits() {
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        s32 idx = i + TIME_ANIM_0_TO_9_OFFSET;
+        mAnm[idx].setForwardOnce();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        s32 idx = i + TIME_ANIM_0_TO_9_B_OFFSET;
+        mAnm[idx].setForwardOnce();
+        mAnm[idx].setToStart();
+        mAnm[idx].setAnimEnable(true);
+    }
+
+    mLyt.calc();
+
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        s32 idx = i + TIME_ANIM_0_TO_9_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        s32 idx = i + TIME_ANIM_0_TO_9_B_OFFSET;
+        mAnm[idx].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameTime_c::fn_8028EBB0() {
+    switch (mTimerVariant) {
+        case TIMER_LONG:
+            fn_8028F240(false);
+            setBestHasSixDigits(false);
+            break;
+        case TIMER_SECONDS: setHighestDigitIndex(0); break;
+    }
+}
+
+void dLytMiniGameTime_c::resetShowBestTime() {
+    setShowBestTime(false);
+}
+
+void dLytMiniGameTime_c::resetFinish() {
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setForwardOnce();
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setToStart();
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setAnimEnable(true);
+        mLyt.calc();
+    }
+
+    mAnm[TIME_ANIM_FINISH_W].setForwardOnce();
+    mAnm[TIME_ANIM_FINISH_W].setToStart();
+    mAnm[TIME_ANIM_FINISH_W].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_FINISH_W].setAnimEnable(false);
+
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameTime_c::resetLoop() {
+    mAnm[TIME_ANIM_LOOP_TIME].setForwardLoop();
+    mAnm[TIME_ANIM_LOOP_TIME].setFrame(0.0f);
+    mAnm[TIME_ANIM_LOOP_TIME].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_LOOP_TIME].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::initSignChange() {
+    if (getCurrentLanguage1() == D_LANG_FR) {
+        setSignChange(2);
+        field_0x7D4 = 3;
+    } else {
+        setSignChange(1);
+        field_0x7D4 = 3;
+    }
+}
+
+void dLytMiniGameTime_c::stopIn() {
+    mAnm[TIME_ANIM_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::stopOut() {
+    mAnm[TIME_ANIM_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::stopAlphaIn() {
+    mAnm[TIME_ANIM_ALPHA_IN].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::stopAlphaOut() {
+    mAnm[TIME_ANIM_ALPHA_OUT].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::stopFinish() {
+    mAnm[TIME_ANIM_FINISH_W].setAnimEnable(false);
+
+    for (int i = 0; i < TIME_NUM_DIGITS; i++) {
+        mAnm[i + TIME_ANIM_FINISH_OFFSET].setAnimEnable(false);
+    }
+}
+
+void dLytMiniGameTime_c::stopLoop() {
+    mAnm[TIME_ANIM_LOOP_TIME].setAnimEnable(false);
+}
+
+bool dLytMiniGameTime_c::isInEndReached() const {
+    if (mAnm[TIME_ANIM_IN].isEnabled() && mAnm[TIME_ANIM_IN].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameTime_c::isOutEndReached() const {
+    if (mAnm[TIME_ANIM_OUT].isEnabled() && mAnm[TIME_ANIM_OUT].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameTime_c::isAlphaInEndReached() const {
+    if (mAnm[TIME_ANIM_ALPHA_IN].isEnabled() && mAnm[TIME_ANIM_ALPHA_IN].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameTime_c::isAlphaOutEndReached() const {
+    if (mAnm[TIME_ANIM_ALPHA_OUT].isEnabled() && mAnm[TIME_ANIM_ALPHA_OUT].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+bool dLytMiniGameTime_c::isFinishEndReached() const {
+    if (mAnm[TIME_ANIM_FINISH_OFFSET].isEnabled() && mAnm[TIME_ANIM_FINISH_OFFSET].isEndReached()) {
+        return true;
+    }
+    return false;
+}
+
+void dLytMiniGameTime_c::setHighestDigitIndex(u8 arg) {
+    f32 frame = arg + field_0x7D4 + 2;
+
+    mAnm[TIME_ANIM_SET_POSITION].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION].setAnimEnable(true);
+
+    mAnm[TIME_ANIM_SET_POSITION_B].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION_B].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION_B].setAnimEnable(true);
+
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_SET_POSITION].setAnimEnable(false);
+    mAnm[TIME_ANIM_SET_POSITION_B].setAnimEnable(false);
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::setSignChange(u32 arg) {
+    f32 frame = arg;
+
+    mAnm[TIME_ANIM_SIGN_CHANGE].setFrame(frame);
+    mAnm[TIME_ANIM_SIGN_CHANGE].setAnimEnable(true);
+
+    mLyt.getLayout()->Animate(0);
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_SIGN_CHANGE].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::fn_8028F240(bool b) {
+    f32 frame = 0.0f;
+    if (b) {
+        frame = 1.0f;
+    }
+
+    mAnm[TIME_ANIM_SET_POSITION].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION].setAnimEnable(true);
+
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_SET_POSITION].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::setBestHasSixDigits(bool b) {
+    f32 frame = 0.0f;
+    if (b) {
+        frame = 1.0f;
+    }
+
+    mAnm[TIME_ANIM_SET_POSITION_B].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION_B].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION_B].setAnimEnable(true);
+
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setForwardOnce();
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setFrame(frame);
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setAnimEnable(true);
+
+    mLyt.getLayout()->Animate(0);
+    mLyt.calc();
+
+    mAnm[TIME_ANIM_SET_POSITION_0_TO_9_B].setAnimEnable(false);
+    mAnm[TIME_ANIM_SET_POSITION_B].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::setDigit(s32 digitIndex, s32 number) {
+    s32 idx = digitIndex + TIME_ANIM_0_TO_9_OFFSET;
+    f32 frame = number;
+
+    mAnm[idx].setFrame(frame);
+    mAnm[idx].setAnimEnable(true);
+
+    mLyt.getLayout()->Animate(0);
+    mLyt.calc();
+
+    mAnm[idx].setAnimEnable(false);
+}
+
+void dLytMiniGameTime_c::setDigitBest(s32 digitIndex, s32 number) {
+    s32 idx = digitIndex + TIME_ANIM_0_TO_9_B_OFFSET;
+    f32 frame = number;
+
+    mAnm[idx].setFrame(frame);
+    mAnm[idx].setAnimEnable(true);
+
+    mLyt.getLayout()->Animate(0);
+    mLyt.calc();
+
+    mAnm[idx].setAnimEnable(false);
+}
+
+static const d2d::LytBrlanMapping brlanMapStart[] = {
+    {"start_00_321start.brlan", "G_321start_00"},
+    {  "start_00_finish.brlan",   "G_finish_00"},
+    {  "start_00_finish.brlan",   "G_timeUp_00"},
+};
+
+#define START_NUM_ANIMS 3
+
+bool dLytMiniGameStart_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("start_00.brlyt", nullptr);
+
+    for (int i = 0; i < START_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapStart[i].mFile, resAcc, mLyt.getLayout(), brlanMapStart[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+    }
+
+    sInstance = this;
+    return true;
+}
+
+bool dLytMiniGameStart_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < START_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGameStart_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+
+    for (int i = 0; i < START_NUM_ANIMS; i++) {
+        if (mAnm[i].isEnabled()) {
+            mAnm[i].play();
+        }
+    }
+
+    mLyt.calc();
+
+    return true;
+}
+
+bool dLytMiniGameStart_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    mLyt.addToDrawList();
+    return true;
+}
+
+void dLytMiniGameStart_c::init() {
+    // TODO - ...
+}
+
+static const d2d::LytBrlanMapping brlanMapScore[] = {
+    {           "miniGameScore_00_in.brlan",       "G_inOut_00"},
+    {      "miniGameScore_00_alphaIn.brlan",  "G_alphaInOut_00"},
+    {          "miniGameScore_00_out.brlan",       "G_inOut_00"},
+    {         "miniGameScore_00_0to9.brlan",        "G_0to9_00"},
+    {         "miniGameScore_00_0to9.brlan",        "G_0to9_01"},
+    {         "miniGameScore_00_0to9.brlan",        "G_0to9_02"},
+    {         "miniGameScore_00_0to9.brlan",        "G_0to9_03"},
+    {         "miniGameScore_00_0to9.brlan",        "G_0to9_04"},
+    {"miniGameScore_00_setPosition00.brlan", "G_setPosition_00"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getScore_00"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getScore_01"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getScore_02"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getScore_03"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getScore_04"},
+    {     "miniGameScore_00_getScore.brlan",    "G_getTextF_00"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getScore_00"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getScore_01"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getScore_02"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getScore_03"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getScore_04"},
+    {  "miniGameScore_00_finishScore.brlan",   "G_getScoreW_00"},
+    {  "miniGameScore_00_finishScore.brlan",   "G_getScoreX_00"},
+    {  "miniGameScore_00_finishScore.brlan",    "G_getTextF_00"},
+    {    "miniGameScore_00_loopScore.brlan",   "G_loopScore_00"},
+    {  "miniGameScore_00_rupeeChange.brlan",  "G_rupyChange_00"},
+    {     "miniGameScore_00_alphaOut.brlan",  "G_alphaInOut_00"},
+};
+
+#define SCORE_NUM_ANIMS 26
+
+bool dLytMiniGameScore_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("miniGameScore_00.brlyt", nullptr);
+
+    for (int i = 0; i < SCORE_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapScore[i].mFile, resAcc, mLyt.getLayout(), brlanMapScore[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+    }
+
+    sInstance = this;
+    return true;
+}
+
+bool dLytMiniGameScore_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < SCORE_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGameScore_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+
+    for (int i = 0; i < SCORE_NUM_ANIMS; i++) {
+        if (mAnm[i].isEnabled()) {
+            mAnm[i].play();
+        }
+    }
+
+    mLyt.calc();
+
+    return true;
+}
+
+bool dLytMiniGameScore_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    mLyt.addToDrawList();
+    return true;
+}
+
+void dLytMiniGameScore_c::init() {
+    // TODO - ...
+}
+
+static const d2d::LytBrlanMapping brlanMapScoreSd[] = {
+    {         "miniGameScoreSd_00_0to9.brlan",        "G_0to9_00"},
+    {         "miniGameScoreSd_00_0to9.brlan",        "G_0to9_01"},
+    {"miniGameScoreSd_00_setPosition00.brlan", "G_setPosition_00"},
+    {      "miniGameScoreSd_00_scoreUp.brlan",     "G_animAll_00"},
+    {    "miniGameScoreSd_00_scoreDown.brlan",     "G_animAll_00"},
+};
+
+#define SCORE_SD_NUM_ANIMS 5
+
+bool dLytMiniGameScoreSd_c::build(d2d::ResAccIf_c *resAcc) {
+    mLyt.setResAcc(resAcc);
+    mLyt.build("miniGameScoreSd_00.brlyt", nullptr);
+
+    for (int i = 0; i < SCORE_SD_NUM_ANIMS; i++) {
+        mAnm[i].init(brlanMapScoreSd[i].mFile, resAcc, mLyt.getLayout(), brlanMapScoreSd[i].mName);
+        mAnm[i].bind(false);
+        mAnm[i].setRate(1.0f);
+    }
+
+    sInstance = this;
+    return true;
+}
+
+bool dLytMiniGameScoreSd_c::remove() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    for (int i = 0; i < SCORE_SD_NUM_ANIMS; i++) {
+        mAnm[i].unbind();
+        mAnm[i].remove();
+    }
+
+    sInstance = nullptr;
+    return true;
+}
+
+bool dLytMiniGameScoreSd_c::execute() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+
+    for (int i = 0; i < SCORE_SD_NUM_ANIMS; i++) {
+        if (mAnm[i].isEnabled()) {
+            mAnm[i].play();
+        }
+    }
+
+    mLyt.calc();
+
+    return true;
+}
+
+bool dLytMiniGameScoreSd_c::draw() {
+    if (sInstance == nullptr) {
+        return true;
+    }
+    mLyt.addToDrawList();
+    return true;
+}
+
+void dLytMiniGameScoreSd_c::init() {
+    // TODO - ...
+}
+
+SPECIAL_BASE_PROFILE(LYT_MINI_GAME, dLytMiniGame_c, fProfile::LYT_MINI_GAME, 0x2B7, 1);
diff --git a/src/d/lyt/meter/d_lyt_meter_ganbari_gauge.cpp b/src/d/lyt/meter/d_lyt_meter_ganbari_gauge.cpp
index cf7423f0..448c8cbe 100644
--- a/src/d/lyt/meter/d_lyt_meter_ganbari_gauge.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_ganbari_gauge.cpp
@@ -439,7 +439,7 @@ bool dLytMeterGanbariGauge_c::execute() {
     mVec3_c diff = dAcPy_c::GetLink()->mPositionCopy3 - dScGame_c::getCamera(0)->getPositionMaybe();
     f32 len = diff.mag();
     mVec3_c v;
-    d3d::fn_80016960(v, dAcPy_c::GetLink()->mPositionCopy3);
+    d3d::worldToScreen(v, dAcPy_c::GetLink()->mPositionCopy3);
     if (!EventManager::isInEvent()) {
         field_0x524 = v;
     }
@@ -602,7 +602,7 @@ bool dLytMeterGanbariGauge_c::execute() {
 
     if (!EventManager::isInEvent() && !dAcPy_c::GetLink()->hasvt_0x1C0() &&
         !dAcPy_c::GetLink()->checkActionFlagsCont(0x10) &&
-        (d3d::fn_80016A90(dAcPy_c::GetLink()->mPositionCopy3) || fn_80104710(false) || isCrawling()) &&
+        (d3d::isOnScreen(dAcPy_c::GetLink()->mPositionCopy3) || fn_80104710(false) || isCrawling()) &&
         *mStateMgrWheel.getStateID() != StateID_Full && *mStateMgrMain.getStateID() == StateID_InvisibleWait &&
         !field_0x530) {
         mStateMgrMain.changeState(StateID_In);
@@ -611,7 +611,7 @@ bool dLytMeterGanbariGauge_c::execute() {
         mStateMgrMain.changeState(StateID_OutWait);
     } else if ((EventManager::isInEvent() || dAcPy_c::GetLink()->hasvt_0x1C0() ||
                 dAcPy_c::GetLink()->checkActionFlagsCont(0x10) ||
-                (!d3d::fn_80016A90(dAcPy_c::GetLink()->mPositionCopy3) && !fn_80104710(false) && !isCrawling())) &&
+                (!d3d::isOnScreen(dAcPy_c::GetLink()->mPositionCopy3) && !fn_80104710(false) && !isCrawling())) &&
                *mStateMgrMain.getStateID() == StateID_Wait) {
         mStateMgrMain.changeState(StateID_CameraOut);
     } else if (field_0x530 && *mStateMgrMain.getStateID() == StateID_Wait) {
diff --git a/src/d/lyt/meter/d_lyt_meter_rupy.cpp b/src/d/lyt/meter/d_lyt_meter_rupy.cpp
index c5987f56..940494e2 100644
--- a/src/d/lyt/meter/d_lyt_meter_rupy.cpp
+++ b/src/d/lyt/meter/d_lyt_meter_rupy.cpp
@@ -474,7 +474,7 @@ bool dLytMeterRupy_c::updateDisplayedAmount(bool suppressSound) {
             newNumDigits = 3;
             setDigit(0, newNumDisplayed / 100);
             s32 rem = (newNumDisplayed % 100);
-            setDigit(1, rem / 10); // x
+            setDigit(1, rem / 10);
             setDigit(2, rem % 10);
         } else if (newNumDisplayed >= 10) {
             newNumDigits = 2;
diff --git a/src/d/lyt/msg_window/d_lyt_msg_window.cpp b/src/d/lyt/msg_window/d_lyt_msg_window.cpp
index cd26b754..8e65ddcc 100644
--- a/src/d/lyt/msg_window/d_lyt_msg_window.cpp
+++ b/src/d/lyt/msg_window/d_lyt_msg_window.cpp
@@ -264,8 +264,8 @@ void dLytMsgWindow_c::initializeState_In() {
         param = 2;
     } else if (mpTagProcessor->getField_0x90D() == 3) {
         param = 1;
-    } else if (obj != nullptr && d3d::fn_80016A90(obj->mPositionCopy2)) {
-        d3d::fn_80016960(field_0x768, obj->mPositionCopy2);
+    } else if (obj != nullptr && d3d::isOnScreen(obj->mPositionCopy2)) {
+        d3d::worldToScreen(field_0x768, obj->mPositionCopy2);
         mVec3_c v = field_0x768;
         v.z = 0.f;
         field_0x768 = v;