Merge pull request #431 from PikalaxALT/sync_bery_crush

Sync berry crush from Emerald

46 files changed, 1816 insertions, 1479 deletions

diff --git a/data/scripts/cable_club.inc b/data/scripts/cable_club.inc
index 66cf634e9..e1902c6e4 100644
--- a/data/scripts/cable_club.inc
+++ b/data/scripts/cable_club.inc
@@ -977,7 +977,7 @@ CableClub_EventScript_WirelessBerryCrush:: @ 81BBD35
 	msgbox CableClub_Text_UseBerryCrush, MSGBOX_YESNO
 	compare VAR_RESULT, NO
 	goto_if_eq CableClub_EventScript_AbortLink
-	special CheckHasAtLeastOneBerry
+	special HasAtLeastOneBerry
 	compare VAR_RESULT, FALSE
 	goto_if_eq CableClub_EventScript_NeedBerryForBerryCrush
 	setvar VAR_0x8004, LINK_GROUP_BERRY_CRUSH
diff --git a/data/specials.inc b/data/specials.inc
index aa7eced1a..2bc4a2a43 100644
--- a/data/specials.inc
+++ b/data/specials.inc
@@ -419,7 +419,7 @@ gSpecials:: @ 815FD60
 	def_special HelpSystem_Disable
 	def_special HelpSystem_Enable
 	def_special SetPostgameFlags
-	def_special CheckHasAtLeastOneBerry
+	def_special HasAtLeastOneBerry
 	def_special DisplayBerryPowderVendorMenu
 	def_special RemoveBerryPowderVendorMenu
 	def_special Script_HasEnoughBerryPowder
diff --git a/graphics/link_games/unk_846F058.bin b/graphics/berry_crush/bg.bin
index 1967c9f45..1967c9f45 100644
--- a/graphics/link_games/unk_846F058.bin
+++ b/graphics/berry_crush/bg.bin
diff --git a/graphics/link_games/unk_846EEC0.bin b/graphics/berry_crush/container_cap.bin
index 934d95779..934d95779 100644
--- a/graphics/link_games/unk_846EEC0.bin
+++ b/graphics/berry_crush/container_cap.bin
diff --git a/graphics/link_games/unk_846E4D0.png b/graphics/berry_crush/crusher_base.png
index 88659471b..88659471b 100644
--- a/graphics/link_games/unk_846E4D0.png
+++ b/graphics/berry_crush/crusher_base.png
diff --git a/graphics/link_games/unk_846ED90.bin b/graphics/berry_crush/crusher_top.bin
index 79713a661..79713a661 100644
--- a/graphics/link_games/unk_846ED90.bin
+++ b/graphics/berry_crush/crusher_top.bin
diff --git a/graphics/link_games/unk_846E7FC.png b/graphics/berry_crush/impact.png
index 3eaf7db0d..3eaf7db0d 100644
--- a/graphics/link_games/unk_846E7FC.png
+++ b/graphics/berry_crush/impact.png
diff --git a/graphics/link_games/unk_846EB78.png b/graphics/berry_crush/sparkle.png
index 0248f9c93..0248f9c93 100644
--- a/graphics/link_games/unk_846EB78.png
+++ b/graphics/berry_crush/sparkle.png
diff --git a/graphics/link_games/unk_846ECC4.png b/graphics/berry_crush/timer_digits.png
index cfb3e9508..cfb3e9508 100644
--- a/graphics/link_games/unk_846ECC4.png
+++ b/graphics/berry_crush/timer_digits.png
diff --git a/include/berry.h b/include/berry.h
index abbd20fc7..d1efa0abf 100644
--- a/include/berry.h
+++ b/include/berry.h
@@ -68,10 +68,10 @@ const struct Berry * GetBerryInfo(u8 berryIdx);
 extern const struct Berry gBerries[];
 
 struct BerryCrushStats {
-    u8 unk0;
+    u8 difficulty;
     u16 powder;
 };
 
-extern const struct BerryCrushStats gBerryCrushStats[];
+extern const struct BerryCrushStats gBerryCrush_BerryData[];
 
 #endif // GUARD_BERRY_H
diff --git a/include/berry_crush.h b/include/berry_crush.h
index a08f1f699..c87029003 100644
--- a/include/berry_crush.h
+++ b/include/berry_crush.h
@@ -4,5 +4,6 @@
 #include "main.h"
 
 void StartBerryCrush(MainCallback callback);
+void ShowBerryCrushRankings(void);
 
 #endif // GUARD_BERRY_CRUSH_H
diff --git a/include/digit_obj_util.h b/include/digit_obj_util.h
index 1db775d26..5674f201f 100644
--- a/include/digit_obj_util.h
+++ b/include/digit_obj_util.h
@@ -24,7 +24,7 @@ extern const u32 gUnknown_8479688[];
 extern const u32 gUnknown_8479748[];
 
 bool32 DigitObjUtil_Init(u32 count);
-void DigitObjUtil_Teardown(void);
+void DigitObjUtil_Free(void);
 bool32 DigitObjUtil_CreatePrinter(u32 id, s32 num, const struct DigitObjUtilTemplate *template);
 void DigitObjUtil_PrintNumOn(u32 id, s32 num);
 void DigitObjUtil_DeletePrinter(u32 id);
diff --git a/include/global.h b/include/global.h
index 04adc82cb..1d12fdae9 100644
--- a/include/global.h
+++ b/include/global.h
@@ -45,9 +45,27 @@
 // Converts a number to Q8.8 fixed-point format
 #define Q_8_8(n) ((s16)((n) * 256))
 
+// Converts a number from Q8.8 fixed-point format
+#define Q_8_8_TO_INT(n) ((s16)((n) >> 8))
+
 // Converts a number to Q4.12 fixed-point format
 #define Q_4_12(n)  ((s16)((n) * 4096))
 
+// Converts a number from Q4.12 fixed-point format
+#define Q_4_12_TO_INT(n) ((s16)((n) >> 12))
+
+// Converts a number to QN.S fixed-point format (16-bits)
+#define Q_N_S(s, n) ((s16)((n) * (1 << (s))))
+
+// converts a number from QN.S fixed-point format (16-bits)
+#define Q_N_S_TO_INT(s, n) ((s16)((n) >> (s)))
+
+// Converts a number to Q24.8 fixed-point format
+#define Q_24_8(n) ((s32)((n) << 8))
+
+// Converts a number from Q24.8 fixed-point format
+#define Q_24_8_TO_INT(n) ((s32)((n) >> 8))
+
 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define max(a, b) ((a) >= (b) ? (a) : (b))
 
diff --git a/include/graphics.h b/include/graphics.h
index 6b2c87bad..a92b798ae 100644
--- a/include/graphics.h
+++ b/include/graphics.h
@@ -4888,9 +4888,9 @@ extern const u32 gFile_graphics_battle_transitions_vs_frame_palette[];
 extern const u32 gFile_graphics_battle_transitions_vs_frame_tilemap[];
 
 // berry_crush
-extern const u16 gUnknown_8EAFEA0[];
-extern const u32 gUnknown_8EAFFC0[];
-extern const u32 gUnknown_8EB0ADC[];
+extern const u16 gBerryCrush_Crusher_Pal[];
+extern const u32 gBerryCrush_Crusher_Gfx[];
+extern const u32 gBerryCrush_Crusher_Tilemap[];
 
 // easy_chat_3
 extern const u32 gEasyChatWindow_Gfx[];
diff --git a/include/item.h b/include/item.h
index 2c5852617..92a057f7e 100644
--- a/include/item.h
+++ b/include/item.h
@@ -79,6 +79,6 @@ void RemovePCItem(u16 itemId, u16 quantity);
 void SortAndCompactBagPocket(struct BagPocket * pocket);
 u8 CountItemsInPC(void);
 void ApplyNewEncryptionKeyToBagItems_(u32 newKey);
-bool8 CheckHasAtLeastOneBerry(void);
+bool8 HasAtLeastOneBerry(void);
 
 #endif // GUARD_ITEM_H
diff --git a/include/link.h b/include/link.h
index 5ca2297cd..766bba919 100644
--- a/include/link.h
+++ b/include/link.h
@@ -274,7 +274,7 @@ void LoadWirelessStatusIndicatorSpriteGfx(void);
 void CreateWirelessStatusIndicatorSprite(u8, u8);
 void sub_8009FE8(void);
 void ClearLinkCallback_2(void);
-void LinkRfu_SetRfuFuncToSend6600(void);
+void Rfu_SetLinkStandbyCallback(void);
 void IntlConvertLinkPlayerName(struct LinkPlayer * linkPlayer);
 bool8 IsWirelessAdapterConnected(void);
 bool8 Link_PrepareCmd0xCCCC_Rfu0xA100(u8 blockRequestType);
diff --git a/include/link_rfu.h b/include/link_rfu.h
index 550b8225c..7d40776f3 100644
--- a/include/link_rfu.h
+++ b/include/link_rfu.h
@@ -5,17 +5,17 @@
 #include "librfu.h"
 #include "AgbRfu_LinkManager.h"
 
-#define RFU_COMMAND_0x8800 0x8800
-#define RFU_COMMAND_0x8900 0x8900
-#define RFU_COMMAND_0xa100 0xa100
-#define RFU_COMMAND_0x7700 0x7700
-#define RFU_COMMAND_0x7800 0x7800
-#define RFU_COMMAND_0x6600 0x6600
-#define RFU_COMMAND_0x5f00 0x5f00
-#define RFU_COMMAND_0x2f00 0x2f00
-#define RFU_COMMAND_0xbe00 0xbe00
-#define RFU_COMMAND_0xee00 0xee00
-#define RFU_COMMAND_0xed00 0xed00
+#define RFUCMD_SEND_PACKET        0x2F00
+#define RFUCMD_READY_CLOSE_LINK   0x5f00
+#define RFUCMD_READY_EXIT_STANDBY 0x6600
+#define RFUCMD_0x7700             0x7700
+#define RFUCMD_0x7800             0x7800
+#define RFUCMD_0x8800             0x8800
+#define RFUCMD_0x8900             0x8900
+#define RFUCMD_SEND_BLOCK_REQ     0xa100
+#define RFUCMD_SEND_HELD_KEYS     0xbe00
+#define RFUCMD_0xED00             0xed00
+#define RFUCMD_0xEE00             0xee00
 
 // RfuTgtData.gname is read as these structs.
 struct GFtgtGnameSub
@@ -196,7 +196,7 @@ void DestroyWirelessStatusIndicatorSprite(void);
 void MEvent_CreateTask_CardOrNewsWithFriend(u32 arg0);
 void MEvent_CreateTask_CardOrNewsOverWireless(u32 arg0);
 void MEvent_CreateTask_Leader(u32 arg0);
-void RfuPrepareSend0x2f00(void * data);
+void Rfu_SendPacket(void * data);
 u8 CreateTask_ListenToWireless(void);
 void LinkRfu_DestroyIdleTask(void);
 void sub_80F86F4(void);
@@ -275,7 +275,7 @@ bool32 GetRfuUnkCE8(void);
 void sub_80FA4A8(void);
 void sub_80FB9D0(void);
 void sub_80FB030(u32 a0);
-void sub_80FBA44(void);
+void ClearRecvCommands(void);
 
 #include "mevent_server.h"
 extern const struct mevent_server_cmd gMEventSrvScript_OtherTrainerCanceled[];
diff --git a/include/math_util.h b/include/math_util.h
index 9f9677463..1f8edc5d9 100644
--- a/include/math_util.h
+++ b/include/math_util.h
@@ -1,11 +1,21 @@
 #ifndef GUARD_MATH_UTIL_H
 #define GUARD_MATH_UTIL_H
 
-s16 MathUtil_Inv16(s16 y);
-s16 MathUtil_Mul16(s16 x, s16 y);
-s32 MathUtil_Div32(s32 x, s32 y);
-s32 MathUtil_Mul32(s32 x, s32 y);
-s16 MathUtil_Div16Shift(u8 s, s16 x, s16 y);
-s16 MathUtil_Mul16Shift(u8 s, s16 x, s16 y);
+// Fixed-point arithmetic library.
+
+// x * y
+s16 Q_8_8_mul(s16 x, s16 y);
+s16 Q_N_S_mul(u8 s, s16 x, s16 y);
+s32 Q_24_8_mul(s32 x, s32 y);
+
+// x / y
+s16 Q_8_8_div(s16 x, s16 y);
+s16 Q_N_S_div(u8 s, s16 x, s16 y);
+s32 Q_24_8_div(s32 x, s32 y);
+
+// 1.0 / y
+s16 Q_8_8_inv(s16 y);
+s16 Q_N_S_inv(u8 s, s16 y);
+s32 Q_24_8_inv(s32 y);
 
 #endif //GUARD_MATH_UTIL_H
diff --git a/include/new_menu_helpers.h b/include/new_menu_helpers.h
index eab3c0830..79bff207a 100644
--- a/include/new_menu_helpers.h
+++ b/include/new_menu_helpers.h
@@ -20,7 +20,7 @@ void CopyToBufferFromBgTilemap(u8 bgId, u16 *dest, u8 left, u8 top, u8 width, u8
 void ResetBgPositions(void);
 void InitStandardTextBoxWindows(void);
 void FreeAllOverworldWindowBuffers(void);
-void ResetBg0(void);
+void InitTextBoxGfxAndPrinters(void);
 u16 RunTextPrinters_CheckPrinter0Active(void);
 u16 AddTextPrinterParameterized2(u8 windowId, u8 fontId, const u8 *str, u8 speed, void (*callback)(struct TextPrinterTemplate *, u16), u8 fgColor, u8 bgColor, u8 shadowColor);
 void AddTextPrinterDiffStyle(bool8 allowSkippingDelayWithButtonPress);
diff --git a/include/palette.h b/include/palette.h
index 145d6e6b6..55054b63d 100644
--- a/include/palette.h
+++ b/include/palette.h
@@ -16,6 +16,10 @@
 #define PALETTE_FADE_STATUS_DONE 0
 #define PALETTE_FADE_STATUS_LOADING 0xFF
 
+#define PALETTES_BG      0x0000FFFF
+#define PALETTES_OBJECTS 0xFFFF0000
+#define PALETTES_ALL     (PALETTES_BG | PALETTES_OBJECTS)
+
 enum
 {
     FAST_FADE_IN_FROM_WHITE,
diff --git a/include/save.h b/include/save.h
index 3c1962f28..b49442193 100644
--- a/include/save.h
+++ b/include/save.h
@@ -114,6 +114,6 @@ bool8 sub_80DA4A0(void);
 u8 Save_LoadGameData(u8 saveType);
 u32 TryCopySpecialSaveSection(u8 sector, u8* dst);
 u32 TryWriteSpecialSaveSection(u8 sector, u8* src);
-void Task_SaveGame_UpdatedLinkRecords(u8 taskId);
+void Task_LinkSave(u8 taskId);
 
 #endif // GUARD_SAVE_H
diff --git a/src/battle_anim_effects_2.c b/src/battle_anim_effects_2.c
index ff9e64cb9..e24434a0e 100644
--- a/src/battle_anim_effects_2.c
+++ b/src/battle_anim_effects_2.c
@@ -1532,7 +1532,7 @@ void AnimAirWaveProjectile(struct Sprite *sprite)
     {
         sprite->data[0] = 8;
         task->data[5] = 4;
-        a = MathUtil_Inv16(0x1000);
+        a = Q_8_8_inv(0x1000);
         sprite->pos1.x += sprite->pos2.x;
         sprite->pos1.y += sprite->pos2.y;
         sprite->pos2.y = 0;
@@ -1551,8 +1551,8 @@ void AnimAirWaveProjectile(struct Sprite *sprite)
         sprite->data[1] = 0;
         sprite->data[6] = 0;
         sprite->data[5] = 0;
-        sprite->data[3] = MathUtil_Mul16(MathUtil_Mul16(b, a), MathUtil_Inv16(0x1C0));
-        sprite->data[4] = MathUtil_Mul16(MathUtil_Mul16(c, a), MathUtil_Inv16(0x1C0));
+        sprite->data[3] = Q_8_8_mul(Q_8_8_mul(b, a), Q_8_8_inv(0x1C0));
+        sprite->data[4] = Q_8_8_mul(Q_8_8_mul(c, a), Q_8_8_inv(0x1C0));
         sprite->callback = AnimAirWaveProjectile_Step1;
     }
 }
@@ -1643,18 +1643,18 @@ void AnimTask_AirCutterProjectile(u8 taskId)
     else
         xDiff = attackerX - targetX;
 
-    gTasks[taskId].data[5] = MathUtil_Mul16(xDiff, MathUtil_Inv16(gBattleAnimArgs[2] & ~1));
-    gTasks[taskId].data[6] = MathUtil_Mul16(gTasks[taskId].data[5], 0x80);
+    gTasks[taskId].data[5] = Q_8_8_mul(xDiff, Q_8_8_inv(gBattleAnimArgs[2] & ~1));
+    gTasks[taskId].data[6] = Q_8_8_mul(gTasks[taskId].data[5], 0x80);
     gTasks[taskId].data[7] = gBattleAnimArgs[2];
     if (targetY >= attackerY)
     {
         yDiff = targetY - attackerY;
-        gTasks[taskId].data[8] = MathUtil_Mul16(yDiff, MathUtil_Inv16(gTasks[taskId].data[5])) & ~1;
+        gTasks[taskId].data[8] = Q_8_8_mul(yDiff, Q_8_8_inv(gTasks[taskId].data[5])) & ~1;
     }
     else
     {
         yDiff = attackerY - targetY;
-        gTasks[taskId].data[8] = MathUtil_Mul16(yDiff, MathUtil_Inv16(gTasks[taskId].data[5])) | 1;
+        gTasks[taskId].data[8] = Q_8_8_mul(yDiff, Q_8_8_inv(gTasks[taskId].data[5])) | 1;
     }
 
     gTasks[taskId].data[3] = gBattleAnimArgs[3];
diff --git a/src/battle_interface.c b/src/battle_interface.c
index 1df525967..cd4445fad 100644
--- a/src/battle_interface.c
+++ b/src/battle_interface.c
@@ -19,9 +19,6 @@
 #undef abs
 #define abs(a) ((a) < 0 ? -(a) : (a))
 
-#define Q_24_8(n)  ((s32)((n) * 256))
-#define Q_24_8_TO_INT(n) ((int)((n) >> 8))
-
 struct TestingBar
 {
     s32 maxValue;
diff --git a/src/berry.c b/src/berry.c
index c5b8af7f8..680f21e3d 100644
--- a/src/berry.c
+++ b/src/berry.c
@@ -867,50 +867,50 @@ const struct Berry gBerries[] = {
 
 };
 
-const struct BerryCrushStats gBerryCrushStats[] = {
-    { 50,  20},
-    { 50,  20},
-    { 50,  20},
-    { 50,  20},
-    { 50,  20},
-    { 50,  30},
-    { 50,  30},
-    { 50,  30},
-    { 50,  30},
-    { 50,  30},
-    { 60,  50},
-    { 60,  50},
-    { 60,  50},
-    { 60,  50},
-    { 60,  50},
-    { 80,  70},
-    { 80,  70},
-    { 80,  70},
-    { 80,  70},
-    { 80,  70},
-    {100, 100},
-    {100, 100},
-    {100, 100},
-    {100, 100},
-    {100, 100},
-    {130, 150},
-    {130, 150},
-    {130, 150},
-    {130, 150},
-    {130, 150},
-    {160, 250},
-    {160, 250},
-    {160, 250},
-    {160, 250},
-    {160, 250},
-    {180, 500},
-    {180, 500},
-    {180, 500},
-    {180, 500},
-    {180, 500},
-    {200, 750},
-    {200, 750},
-    {150, 200}
+const struct BerryCrushStats gBerryCrush_BerryData[] = {
+    [ITEM_CHERI_BERRY  - FIRST_BERRY_INDEX] = { 50,  20},
+    [ITEM_CHESTO_BERRY - FIRST_BERRY_INDEX] = { 50,  20},
+    [ITEM_PECHA_BERRY  - FIRST_BERRY_INDEX] = { 50,  20},
+    [ITEM_RAWST_BERRY  - FIRST_BERRY_INDEX] = { 50,  20},
+    [ITEM_ASPEAR_BERRY - FIRST_BERRY_INDEX] = { 50,  20},
+    [ITEM_LEPPA_BERRY  - FIRST_BERRY_INDEX] = { 50,  30},
+    [ITEM_ORAN_BERRY   - FIRST_BERRY_INDEX] = { 50,  30},
+    [ITEM_PERSIM_BERRY - FIRST_BERRY_INDEX] = { 50,  30},
+    [ITEM_LUM_BERRY    - FIRST_BERRY_INDEX] = { 50,  30},
+    [ITEM_SITRUS_BERRY - FIRST_BERRY_INDEX] = { 50,  30},
+    [ITEM_FIGY_BERRY   - FIRST_BERRY_INDEX] = { 60,  50},
+    [ITEM_WIKI_BERRY   - FIRST_BERRY_INDEX] = { 60,  50},
+    [ITEM_MAGO_BERRY   - FIRST_BERRY_INDEX] = { 60,  50},
+    [ITEM_AGUAV_BERRY  - FIRST_BERRY_INDEX] = { 60,  50},
+    [ITEM_IAPAPA_BERRY - FIRST_BERRY_INDEX] = { 60,  50},
+    [ITEM_RAZZ_BERRY   - FIRST_BERRY_INDEX] = { 80,  70},
+    [ITEM_BLUK_BERRY   - FIRST_BERRY_INDEX] = { 80,  70},
+    [ITEM_NANAB_BERRY  - FIRST_BERRY_INDEX] = { 80,  70},
+    [ITEM_WEPEAR_BERRY - FIRST_BERRY_INDEX] = { 80,  70},
+    [ITEM_PINAP_BERRY  - FIRST_BERRY_INDEX] = { 80,  70},
+    [ITEM_POMEG_BERRY  - FIRST_BERRY_INDEX] = {100, 100},
+    [ITEM_KELPSY_BERRY - FIRST_BERRY_INDEX] = {100, 100},
+    [ITEM_QUALOT_BERRY - FIRST_BERRY_INDEX] = {100, 100},
+    [ITEM_HONDEW_BERRY - FIRST_BERRY_INDEX] = {100, 100},
+    [ITEM_GREPA_BERRY  - FIRST_BERRY_INDEX] = {100, 100},
+    [ITEM_TAMATO_BERRY - FIRST_BERRY_INDEX] = {130, 150},
+    [ITEM_CORNN_BERRY  - FIRST_BERRY_INDEX] = {130, 150},
+    [ITEM_MAGOST_BERRY - FIRST_BERRY_INDEX] = {130, 150},
+    [ITEM_RABUTA_BERRY - FIRST_BERRY_INDEX] = {130, 150},
+    [ITEM_NOMEL_BERRY  - FIRST_BERRY_INDEX] = {130, 150},
+    [ITEM_SPELON_BERRY - FIRST_BERRY_INDEX] = {160, 250},
+    [ITEM_PAMTRE_BERRY - FIRST_BERRY_INDEX] = {160, 250},
+    [ITEM_WATMEL_BERRY - FIRST_BERRY_INDEX] = {160, 250},
+    [ITEM_DURIN_BERRY  - FIRST_BERRY_INDEX] = {160, 250},
+    [ITEM_BELUE_BERRY  - FIRST_BERRY_INDEX] = {160, 250},
+    [ITEM_LIECHI_BERRY - FIRST_BERRY_INDEX] = {180, 500},
+    [ITEM_GANLON_BERRY - FIRST_BERRY_INDEX] = {180, 500},
+    [ITEM_SALAC_BERRY  - FIRST_BERRY_INDEX] = {180, 500},
+    [ITEM_PETAYA_BERRY - FIRST_BERRY_INDEX] = {180, 500},
+    [ITEM_APICOT_BERRY - FIRST_BERRY_INDEX] = {180, 500},
+    [ITEM_LANSAT_BERRY - FIRST_BERRY_INDEX] = {200, 750},
+    [ITEM_STARF_BERRY  - FIRST_BERRY_INDEX] = {200, 750},
+    [ITEM_ENIGMA_BERRY - FIRST_BERRY_INDEX] = {150, 200}
 };
 
 // Leftover from R/S
diff --git a/src/berry_crush.c b/src/berry_crush.c
index 05be05802..f2c54297b 100644
--- a/src/berry_crush.c
+++ b/src/berry_crush.c
@@ -14,6 +14,7 @@
 #include "item_menu_icons.h"
 #include "link.h"
 #include "link_rfu.h"
+#include "list_menu.h"
 #include "math_util.h"
 #include "menu.h"
 #include "minigame_countdown.h"
@@ -30,336 +31,471 @@
 #include "constants/songs.h"
 #include "constants/items.h"
 
+#define MAX_TIME (10 * 60 * 60) // Timer can go up to 9:59:59
+
+#define TAG_CRUSHER_BASE  1
+#define PALTAG_EFFECT     2 // The next two gfx tags share this pal tag
+#define GFXTAG_IMPACT     2
+#define GFXTAG_SPARKLE    3
+#define TAG_TIMER_DIGITS  4
+#define TAG_PLAYER1_BERRY 5
+#define TAG_PLAYER2_BERRY 6
+#define TAG_PLAYER3_BERRY 7
+#define TAG_PLAYER4_BERRY 8
+#define TAG_PLAYER5_BERRY 9
+
 #define TAG_COUNTDOWN 0x1000
 
+#define CRUSHER_START_Y (-104)
+
 enum {
-    BCTEXT_AREYOUREADY,
-    BCTEXT_WAITFOROTHERS,
-    BCTEXT_GAINEDPOWDER,
-    BCTEXT_RECORDINGRESULTS,
-    BCTEXT_ASKPLAYAGAIN,
-    BCTEXT_CANCEL_NOBERRIES,
-    BCTEXT_CANCEL_DROPPEDOUT,
-    BCTEXT_TIMEUP,
-    BCTEXT_COMMSTANDBY,
+    RUN_CMD,
+    SCHEDULE_CMD,
 };
 
 enum {
-    BCCMD_BeginNormalPaletteFade = 1,
-    BCCMD_WaitPaletteFade,
-    BCCMD_PrintMessage,
-    BCCMD_InitGfx,
-    BCCMD_TeardownGfx,
-    BCCMD_SignalReadyToBegin,
-    BCCMD_AskPickBerry,
-    BCCMD_GoToBerryPouch,
-    BCCMD_WaitForOthersToPickBerries,
-    BCCMD_DropBerriesIntoCrusher,
-    BCCMD_DropLid,
-    BCCMD_Countdown,
-    BCCMD_PlayGame_Master,
-    BCCMD_PlayGame_Slave,
-    BCCMD_FinishGame,
-    BCCMD_HandleTimeUp,
-    BCCMD_TabulateResults,
-    BCCMD_ShowResults,
-    BCCMD_SaveTheGame,
-    BCCMD_AskPlayAgain,
-    BCCMD_CommunicatePlayAgainResponses,
-    BCCMD_FadeOutToPlayAgain,
-    BCCMD_PlayAgainFailureMessage,
-    BCCMD_GracefulExit,
-    BCCMD_Quit,
+    MSG_PICK_BERRY,
+    MSG_WAIT_PICK,
+    MSG_POWDER,
+    MSG_SAVING,
+    MSG_PLAY_AGAIN,
+    MSG_NO_BERRIES,
+    MSG_DROPPED,
+    MSG_TIMES_UP,
+    MSG_COMM_STANDBY,
 };
 
+enum {
+    CMD_NONE = 0,
+    CMD_FADE,
+    CMD_WAIT_FADE,
+    CMD_PRINT_MSG,
+    CMD_SHOW_GAME,
+    CMD_HIDE_GAME,
+    CMD_READY_BEGIN,
+    CMD_ASK_PICK_BERRY,
+    CMD_PICK_BERRY,
+    CMD_WAIT_BERRIES,
+    CMD_DROP_BERRIES,
+    CMD_DROP_LID,
+    CMD_COUNTDOWN,
+    CMD_PLAY_GAME_LEADER,
+    CMD_PLAY_GAME_MEMBER,
+    CMD_FINISH_GAME,
+    CMD_TIMES_UP,
+    CMD_CALC_RESULTS,
+    CMD_SHOW_RESULTS,
+    CMD_SAVE,
+    CMD_ASK_PLAY_AGAIN,
+    CMD_COMM_PLAY_AGAIN,
+    CMD_PLAY_AGAIN_YES,
+    CMD_PLAY_AGAIN_NO,
+    CMD_CLOSE_LINK,
+    CMD_QUIT,
+};
+
+// Args for Cmd_BeginNormalPaletteFade
+#define bSelectedPals(i)  args[0 + i]
+#define bDelay            args[4]
+#define bStartY           args[5]
+#define bTargetY          args[6]
+#define bPalette(i)       args[7 + i]
+#define bCommunicateAfter args[9]
+
+// Args for Cmd_WaitPaletteFade
+#define bWaitFadeCommAfter args[0]
+
+// Args for Cmd_PrintMessage
+#define bMsgId        args[0]
+#define bFlags        args[1]
+#define bKeys(i)      args[2 + i]
+#define bNextCmdState args[4]
+
+#define F_MSG_CLEAR  (1 << 0)
+#define F_MSG_EXPAND (1 << 1)
+
+// Main states for the game. Many are assigned but never checked
+enum {
+    STATE_INIT = 1,
+    STATE_RESET,
+    STATE_PICK_BERRY,
+    STATE_DROP_BERRIES,
+    STATE_DROP_LID,
+    STATE_COUNTDOWN,
+    STATE_PLAYING,
+    STATE_FINISHED,
+    STATE_TIMES_UP,
+    STATE_10, // Unused
+    STATE_RESULTS_PRESSES,
+    STATE_RESULTS_RANDOM,
+    STATE_RESULTS_CRUSHING,
+    STATE_14, // Unused
+    STATE_PLAY_AGAIN,
+};
+
+#define RESULTS_STATE_START STATE_RESULTS_PRESSES
+#define RESULTS_STATE_END   STATE_RESULTS_CRUSHING
+
+// IDs for each results page that shows in succession at the game's end.
+// Only 3 pages are shown for a given game. Presses and Crushing are always shown 1st and 3rd.
+// The 2nd page is random, and can be rankings for either Neatness, Cooperative, or Power.
+enum {
+    RESULTS_PAGE_PRESSES,
+    RESULTS_PAGE_RANDOM,
+    RESULTS_PAGE_CRUSHING,
+    NUM_RESULTS_PAGES,
+};
+// Random pages, see above
+// "Neatness" is how many of the player's inputs were at a regular interval
+// "Cooperative" is how often the player pressed A at the same time as others
+// "Power" is how much of the time the player spent pressing A
+enum {
+    RESULTS_PAGE_NEATNESS,
+    RESULTS_PAGE_COOPERATIVE,
+    RESULTS_PAGE_POWER,
+    NUM_RANDOM_RESULTS_PAGES
+};
+
+#define PLAY_AGAIN_YES        0
+#define PLAY_AGAIN_NO         1
+#define PLAY_AGAIN_NO_BERRIES 3
+
+enum {
+    COLORID_GRAY,
+    COLORID_BLACK,
+    COLORID_LIGHT_GRAY,
+    COLORID_BLUE,
+    COLORID_GREEN,
+    COLORID_RED,
+};
+
+// Flags for the inputFlags field
+// Field is 16 bits; 3 bits for each player, last bit is unused
+// The first two bits are interchangeable
+// Needlessly complicated system, the inputState field is sufficient by itself
+#define F_INPUT_HIT_A (1 << 0)
+#define F_INPUT_HIT_B (1 << 1)
+#define F_INPUT_HIT_SYNC (1 << 2) // Input at same time as another player
+#define INPUT_FLAGS_PER_PLAYER 3
+#define INPUT_FLAG_MASK ((1 << INPUT_FLAGS_PER_PLAYER) - 1)
+
+// Values for the inputState field
+enum {
+    INPUT_STATE_NONE,
+    INPUT_STATE_HIT,      // Hit the crusher
+    INPUT_STATE_HIT_SYNC, // Hit the crusher at same time as another player
+};
+
+// No reason for this to be 2
+// Simply a flag for whether a given player has sent their data this round
+// Data is only sent if the player is the leader or if they pressed A
+#define SEND_GAME_STATE 2
+
 struct BerryCrushGame_Player
 {
-    u8 unk0[PLAYER_NAME_LENGTH + 1 + 4];
-    u16 unkC;
-    u16 unkE;
-    u16 unk10;
-    u16 unk12;
-    u16 unk14;
-    u16 unk16;
-    u16 unk18;
-    u16 unk1A;
-    u8 unk1B;
-    u8 unk1C;
+    u8 name[PLAYER_NAME_LENGTH + 1 + 4];
+    u16 berryId;
+    u16 inputTime;
+    u16 neatInputStreak;
+    u16 timeSincePrevInput;
+    u16 maxNeatInputStreak;
+    u16 numAPresses;
+    u16 numSyncedAPresses;
+    u16 timePressingA;
+    u8 inputFlags;
+    u8 inputState;
 };
 
-struct BerryCrushGame_4E
-{
-    u16 unk0;
-    u16 unk2;
-    u8 unk4_0:1;
-    u8 unk4_1:1;
-    u8 unk4_2:1;
-    u8 unk4_3:5;
-    s8 unk5;
-    u16 unk6;
-    u16 unk8;
-    u16 unkA;
-    u16 unkC;
+struct BerryCrushGame_LocalState
+{
+    u16 sendFlag;
+    bool8 endGame:1;
+    bool8 bigSparkle:1;
+    bool8 pushedAButton:1;
+    u8 playerPressedAFlags:5;
+    s8 vibration;
+    u16 depth;
+    u16 timer;
+    u16 inputFlags;
+    u16 sparkleAmount;
 };
 
-struct BerryCrushGame_40
+struct BerryCrushGame_LinkState
 {
-    s16 unk0;
-    s16 unk2;
-    s16 unk4;
-    s16 unk6;
-    s16 unk8;
-    s16 unkA;
-    s16 unkC;
-    s16 unkE;
+    u16 rfuCmd;
+    u16 sendFlag;
+    bool8 endGame:1;
+    bool8 bigSparkle:1;
+    bool8 pushedAButton:1;
+    u8 playerPressedAFlags:5;
+    s8 vibration;
+    u16 depth;
+    u16 timer;
+    u16 inputFlags;
+    u16 sparkleAmount;
 };
 
-struct BerryCrushGame_5C
-{
-    u16 unk00;
-    u8 unk02_0:1;
-    u8 unk02_1:1;
-    u8 pushedAButton:1;
-    u8 unk02_3:5;
-    s8 unk03;
-    u16 unk04;
-    u16 unk06;
-    u16 unk08;
-    u16 unk0A;
+// Flags for the inputFlags field
+// Field is 16 bits; 3 bits for each player, last bit is unused
+// The first two bits are interchangeable
+// Needlessly complicated system, the inputState field is sufficient by itself
+#define F_INPUT_HIT_A (1 << 0)
+#define F_INPUT_HIT_B (1 << 1)
+#define F_INPUT_HIT_SYNC (1 << 2) // Input at same time as another player
+#define INPUT_FLAGS_PER_PLAYER 3
+#define INPUT_FLAG_MASK ((1 << INPUT_FLAGS_PER_PLAYER) - 1)
+
+struct BerryCrushGame_Results
+{
+    u32 powder;
+    u16 time;
+    u16 targetPressesPerSec; // Never read
+    u16 silkiness;
+    u16 totalAPresses;
+    u16 stats[2][MAX_RFU_PLAYERS];
+    u8 playerIdsRanked[2][MAX_RFU_PLAYERS + 3];
 };
 
-struct BerryCrushGame_68
-{
-    u32 unk00;
-    u16 unk04;
-    u16 unk06;
-    u16 unk08;
-    u16 unk0A;
-    // 0: Number of A presses
-    // 1: Neatness
-    u16 stats[2][5];
-    u8 unk20[2][8];
-};
+// playerIdsRanked above has 3 additional elements after the players.
+// Only 1 of these 2*3 is ever used, and it stores the id for which
+// random results page to show. Its define below is for readability.
+#define randomPageId playerIdsRanked[0][7]
 
-struct BerryCrushPlayerSeatCoords
+struct BerryCrushPlayerCoords
 {
-    u8 unk0;
-    u8 unk1;
-    u8 unk2;
-    s16 unk4;
-    s16 unk6;
-    s16 unk8;
-    s16 unkA;
+    u8 playerId;
+    u8 windowGfxX;
+    u8 windowGfxY;
+    s16 impactXOffset;
+    s16 impactYOffset;
+    s16 berryXOffset;
+    s16 berryXDest;
 };
 
-struct BerryCrushGame_138
+struct BerryCrushGame_Gfx
 {
-    u8 animBerryIdx;
-    u8 unk1;
-    u8 unk2;
-    u8 unk3;
+    u8 counter;
+    u8 vibrationIdx;
+    u8 numVibrations;
+    bool8 vibrating;
     s16 minutes;
     s16 secondsInt;
     s16 secondsFrac;
-    const struct BerryCrushPlayerSeatCoords *seatCoords[5];
+    const struct BerryCrushPlayerCoords *playerCoords[MAX_RFU_PLAYERS];
     struct Sprite *coreSprite;
-    struct Sprite *impactSprites[5];
-    struct Sprite *berrySprites[5];
+    struct Sprite *impactSprites[MAX_RFU_PLAYERS];
+    struct Sprite *berrySprites[MAX_RFU_PLAYERS];
     struct Sprite *sparkleSprites[11];
     struct Sprite *timerSprites[2];
-    u8 unk80;
-    u8 filler81;
-    u8 unk82;
-    u8 unk83[5];
-    u16 bgBuffers[4][0x800];
+    u8 resultsState;
+    u8 unused;
+    u8 resultsWindowId;
+    u8 nameWindowIds[MAX_RFU_PLAYERS];
+    u16 bgBuffers[4][BG_SCREEN_SIZE];
 };
 
+struct BerryCrushGame;
+
+typedef u32 (*CmdFunc)(struct BerryCrushGame * game, u8 * args);
+
 struct BerryCrushGame
 {
     MainCallback savedCallback;
-    u32 (*cmdCallback)(struct BerryCrushGame *, u8 *);
+    CmdFunc cmdCallback;
     u8 localId;
     u8 playerCount;
     u8 mainTask;
     u8 textSpeed;
     u8 cmdState;
-    u8 unkD;
+    u8 unused; // Never read
     u8 nextCmd;
     u8 afterPalFadeCmd;
-    u16 unk10;
+    u16 cmdTimer;
     u16 gameState;
-    u16 unk14;
+    u16 playAgainState;
     u16 pressingSpeed;
-    s16 unk18;
-    s16 unk1A;
+    s16 targetAPresses;
+    s16 totalAPresses;
     s32 powder;
-    s32 unk20;
-    u8 unk24;
-    u8 unk25_0:1;
-    u8 unk25_1:1;
-    u8 unk25_2:1;
-    u8 unk25_3:1;
-    u8 unk25_4:1;
-    u8 unk25_5:3;
-    u16 unk26;
+    s32 targetDepth;
+    u8 newDepth;
+    bool8 noRoomForPowder:1; // Never read
+    bool8 newRecord:1;
+    bool8 playedSound:1;
+    bool8 endGame:1;
+    bool8 bigSparkle:1;
+    u8 sparkleAmount:3;
+    u16 leaderTimer;
     u16 timer;
     s16 depth;
     s16 vibration;
-    s16 unk2E;
-    s16 unk30;
-    s16 unk32;
-    s16 unk34;
-    u8 commandParams[0xC];
+    s16 bigSparkleCounter;
+    s16 numBigSparkles;
+    s16 numBigSparkleChecks;
+    s16 sparkleCounter;
+    u8 commandParams[12];
     u16 sendCmd[6];
     u16 recvCmd[7];
-    struct BerryCrushGame_5C localState;
-    struct BerryCrushGame_68 unk68;
-    struct BerryCrushGame_Player unk98[5];
-    struct BerryCrushGame_138 spritesManager;
+    struct BerryCrushGame_LocalState localState;
+    struct BerryCrushGame_Results results;
+    struct BerryCrushGame_Player players[5];
+    struct BerryCrushGame_Gfx gfx;
 };
 
-static EWRAM_DATA struct BerryCrushGame *sBerryCrushGamePtr = NULL;
-
-static void BerryCrush_InitPlayerNamesAndTextSpeed(struct BerryCrushGame *game);
-static void CB2_ReturnToBerryCrushGameFromBerryPouch(void);
-static void VBlankCB_BerryCrush(void);
-static void CB2_BerryCrush(void);
-static void Task_RunBerryCrushGame(u8 taskId);
-static u32 BerryCrushCommand_BeginNormalPaletteFade(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_WaitPaletteFade(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_PrintMessage(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_InitGfx(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_TeardownGfx(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_SignalReadyToBegin(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_AskPickBerry(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_GoToBerryPouch(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_WaitForOthersToPickBerries(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_DropBerriesIntoCrusher(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_DropLid(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_Countdown(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_PlayGame_Master(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_PlayGame_Slave(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_FinishGame(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_HandleTimeUp(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_TabulateResults(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_ShowResults(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_SaveTheGame(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_AskPlayAgain(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_CommunicatePlayAgainResponses(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_FadeOutToPlayAgain(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_PlayAgainFailureMessage(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_GracefulExit(struct BerryCrushGame * game, u8 *params);
-static u32 BerryCrushCommand_Quit(struct BerryCrushGame * game, u8 *params);
-static void sub_814D4D8(struct BerryCrushGame * game);
-static void BerryCrush_SetShowMessageParams(u8 *params, u8 stringId, u8 flags, u16 waitKeys, u8 followupCmd);
-static void FramesToMinSec(struct BerryCrushGame_138 * arg0, u16 arg1);
+static EWRAM_DATA struct BerryCrushGame *sGame = NULL;
+
+static void SetNamesAndTextSpeed(struct BerryCrushGame *game);
+static void GetBerryFromBag(void);
+static void VBlankCB(void);
+static void MainCB(void);
+static void MainTask(u8 taskId);
+static u32 Cmd_BeginNormalPaletteFade(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_WaitPaletteFade(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_PrintMessage(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_ShowGameDisplay(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_HideGameDisplay(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_SignalReadyToBegin(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_AskPickBerry(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_GoToBerryPouch(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_WaitForOthersToPickBerries(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_DropBerriesIntoCrusher(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_DropLid(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_Countdown(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_PlayGame_Leader(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_PlayGame_Member(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_FinishGame(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_HandleTimeUp(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_TabulateResults(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_ShowResults(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_SaveGame(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_AskPlayAgain(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_CommunicatePlayAgainResponses(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_PlayAgain(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_StopGame(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_CloseLink(struct BerryCrushGame * game, u8 *args);
+static u32 Cmd_Quit(struct BerryCrushGame * game, u8 *args);
+static void ResetGame(struct BerryCrushGame * game);
+static void SetPrintMessageArgs(u8 *args, u8 stringId, u8 flags, u16 waitKeys, u8 followupCmd);
+static void FramesToMinSec(struct BerryCrushGame_Gfx * gfx, u16 frames);
 static void PrintTextCentered(u8 windowId, u8 left, u8 colorId, const u8 *string);
-static void PrintBerryCrushResultWindow(struct BerryCrushGame * sp0C, u8 sp10, u8 sp14, u8 r3);
-static void sub_814E32C(struct BerryCrushGame * r8);
+static void PrintResultsText(struct BerryCrushGame * game, u8 command, u8 x, u8 y);
+static void printCrushingResults(struct BerryCrushGame * game);
 static void Task_ShowBerryCrushRankings(u8 r4);
-static void BerryCrush_PrintTimeOnSprites(struct BerryCrushGame_138 * r4, u16 r1);
-static void sub_814EB38(struct BerryCrushGame * r5);
-static void sub_814EBB0(struct BerryCrushGame * r6);
-static void sub_814EC80(struct BerryCrushGame * r6);
-static void sub_814ECE0(struct BerryCrushGame * r6);
-static void sub_814EF10(struct BerryCrushGame * r5);
-static void SpriteCB_BerryCrushImpact(struct Sprite * sprite);
-static void sub_814EFFC(struct Sprite * sprite);
-static void sub_814F044(struct Sprite * sprite);
-static void sub_814F0D8(struct Sprite * sprite);
-struct BerryCrushGame *GetBerryCrushGame(void);
-void StartBerryCrush(MainCallback callback);
-u32 ExitBerryCrushWithCallback(MainCallback callback);
-void CB2_BerryCrush_GoToBerryPouch(void);
-void BerryCrush_SetVBlankCallback(void);
-void BerryCrush_UnsetVBlankCallback(void);
-void BerryCrush_UpdateSav2Records(void);
-void BerryCrush_RunOrScheduleCommand(u16 command, u8 runMode, u8 *params);
-void BerryCrush_SetPaletteFadeParams(u8 *params, bool8 communicateAfter, u32 selectedPals, s8 delay, u8 startY, u8 targetY, u16 palette);
-int sub_814D9CC(struct BerryCrushGame *arg0);
-int BerryCrush_InitBgs(void);
-int BerryCrush_TeardownBgs(void);
-void BerryCrush_CreateBerrySprites(struct BerryCrushGame *arg0, struct BerryCrushGame_138 *arg1);
-void BerryCrushFreeBerrySpriteGfx(struct BerryCrushGame *arg0, struct BerryCrushGame_138 *arg1);
-void sub_814DC5C(struct BerryCrushGame *arg0, struct BerryCrushGame_138 *arg1);
-bool32 sub_814DE50(struct BerryCrushGame *arg0, struct BerryCrushGame_138 *arg1);
-bool32 sub_814E644(struct BerryCrushGame *arg0, struct BerryCrushGame_138 *arg1);
-void sub_814E80C(struct BerryCrushGame *arg0);
-void sub_814DA04(struct BerryCrushGame *arg0);
-void BerryCrush_HideTimerSprites(struct BerryCrushGame_138 *arg0);
-void SpriteCB_DropBerryIntoCrusher(struct Sprite * sprite);
-void ShowBerryCrushRankings(void);
-
-static const u8 gUnknown_846E2E0[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
-static const u8 gUnknown_846E2E8[] = {0x00, 0x01, 0x02, 0x03, 0x05, 0x00, 0x00, 0x00};
-
-static const s8 gUnknown_846E2F0[][7] = {
-    {0x04, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00},
-    {0x04, 0x02, 0x00, 0xff, 0x00, 0x00, 0x00},
-    {0x04, 0x02, 0x00, 0xfe, 0x00, 0x00, 0x00},
-    {0x06, 0x03, 0x01, 0xff, 0xfd, 0xff, 0x00},
-    {0x06, 0x04, 0x01, 0xfe, 0xfc, 0xfe, 0x00},
+static void PrintTimer(struct BerryCrushGame_Gfx * gfx, u16 frames);
+static void CreatePlayerNameWindows(struct BerryCrushGame * game);
+static void DrawPlayerNameWindows(struct BerryCrushGame * game);
+static void CopyPlayerNameWindowGfxToBg(struct BerryCrushGame * game);
+static void CreateGameSprites(struct BerryCrushGame * game);
+static void DestroyGameSprites(struct BerryCrushGame * game);
+static void SpriteCB_Impact(struct Sprite * sprite);
+static void SpriteCB_Sparkle_End(struct Sprite * sprite);
+static void SpriteCB_Sparkle(struct Sprite * sprite);
+static void SpriteCB_Sparkle_Init(struct Sprite * sprite);
+static struct BerryCrushGame *GetBerryCrushGame(void);
+static u32 QuitBerryCrush(MainCallback callback);
+static void ChooseBerry(void);
+static void BerryCrush_SetVBlankCallback(void);
+static void BerryCrush_InitVBlankCB(void);
+static void SaveResults(void);
+static void RunOrScheduleCommand(u16 command, u8 runMode, u8 *args);
+static void SetPaletteFadeArgs(u8 *args, bool8 communicateAfter, u32 selectedPals, s8 delay, u8 startY, u8 targetY, u16 palette);
+static s32 UpdateGame(struct BerryCrushGame *game);
+static s32 ShowGameDisplay(void);
+static s32 HideGameDisplay(void);
+static void CreateBerrySprites(struct BerryCrushGame *game, struct BerryCrushGame_Gfx *spritesManager);
+static void BerryCrushFreeBerrySpriteGfx(struct BerryCrushGame *game, struct BerryCrushGame_Gfx *gfx);
+static void UpdateInputEffects(struct BerryCrushGame *game, struct BerryCrushGame_Gfx *gfx);
+static bool32 AreEffectsFinished(struct BerryCrushGame *game, struct BerryCrushGame_Gfx *gfx);
+static bool32 OpenResultsWindow(struct BerryCrushGame *game, struct BerryCrushGame_Gfx *spriteManager);
+static void CloseResultsWindow(struct BerryCrushGame *game);
+static void ResetCrusherPos(struct BerryCrushGame *game);
+static void HideTimer(struct BerryCrushGame_Gfx *gfx);
+static void SpriteCB_DropBerryIntoCrusher(struct Sprite * sprite);
+
+static const u8 sBitTable[] = {
+    1 << 0,
+    1 << 1,
+    1 << 2,
+    1 << 3,
+    1 << 4,
+    1 << 5,
+    1 << 6,
+    1 << 7,
 };
 
-ALIGNED(4) const u8 gUnknown_846E314[][4] = {
-    {0x03, 0x02, 0x01, 0x00},
-    {0x03, 0x03, 0x01, 0x00},
-    {0x03, 0x03, 0x02, 0x00},
-    {0x03, 0x04, 0x02, 0x00},
-    {0x03, 0x05, 0x03, 0x00}
+// Additional A presses are counted depending on the number of players
+// The bonus of 5 is unobtainable
+static const u8 sSyncPressBonus[MAX_RFU_PLAYERS] = {0, 1, 2, 3, 5 };
+
+ALIGNED(4)
+static const s8 sIntroOutroVibrationData[][7] = {
+    {  4,  1,  0, -1,  0,  0,  0},
+    {  4,  2,  0, -1,  0,  0,  0},
+    {  4,  2,  0, -2,  0,  0,  0},
+    {  6,  3,  1, -1, -3, -1,  0},
+    {  6,  4,  1, -2, -4, -2,  0},
 };
 
-static const u8 *const sBerryCrushMessages[] = {
-    gText_BerryCrush_AreYouReady,
-    gText_BerryCrush_WaitForOthersToChooseBerry,
-    gText_BerryCrush_GainedXUnitsOfPowder,
-    gText_BerryCrush_RecordingGameResults,
-    gText_BerryCrush_WantToPlayAgain,
-    gText_BerryCrush_NoBerries,
-    gText_BerryCrush_MemberDroppedOut,
-    gText_BerryCrush_TimeUp,
-    gText_BerryCrush_CommunicationStandby
+ALIGNED(4)
+const u8 sVibrationData[MAX_RFU_PLAYERS][4] = {
+    { 3, 2, 1, 0},
+    { 3, 3, 1, 0},
+    { 3, 3, 2, 0},
+    { 3, 4, 2, 0},
+    { 3, 5, 3, 0}
 };
 
-static u32 (*const sBerryCrushCommands[])(struct BerryCrushGame * berryCrushGame, u8 *params) = {
-    NULL,
-    BerryCrushCommand_BeginNormalPaletteFade,
-    BerryCrushCommand_WaitPaletteFade,
-    BerryCrushCommand_PrintMessage,
-    BerryCrushCommand_InitGfx,
-    BerryCrushCommand_TeardownGfx,
-    BerryCrushCommand_SignalReadyToBegin,
-    BerryCrushCommand_AskPickBerry,
-    BerryCrushCommand_GoToBerryPouch,
-    BerryCrushCommand_WaitForOthersToPickBerries,
-    BerryCrushCommand_DropBerriesIntoCrusher,
-    BerryCrushCommand_DropLid,
-    BerryCrushCommand_Countdown,
-    BerryCrushCommand_PlayGame_Master,
-    BerryCrushCommand_PlayGame_Slave,
-    BerryCrushCommand_FinishGame,
-    BerryCrushCommand_HandleTimeUp,
-    BerryCrushCommand_TabulateResults,
-    BerryCrushCommand_ShowResults,
-    BerryCrushCommand_SaveTheGame,
-    BerryCrushCommand_AskPlayAgain,
-    BerryCrushCommand_CommunicatePlayAgainResponses,
-    BerryCrushCommand_FadeOutToPlayAgain,
-    BerryCrushCommand_PlayAgainFailureMessage,
-    BerryCrushCommand_GracefulExit,
-    BerryCrushCommand_Quit
+static const u8 *const sMessages[] = {
+    [MSG_PICK_BERRY]   = gText_BerryCrush_AreYouReady,
+    [MSG_WAIT_PICK]    = gText_BerryCrush_WaitForOthersToChooseBerry,
+    [MSG_POWDER]       = gText_BerryCrush_GainedXUnitsOfPowder,
+    [MSG_SAVING]       = gText_BerryCrush_RecordingGameResults,
+    [MSG_PLAY_AGAIN]   = gText_BerryCrush_WantToPlayAgain,
+    [MSG_NO_BERRIES]   = gText_BerryCrush_NoBerries,
+    [MSG_DROPPED]      = gText_BerryCrush_MemberDroppedOut,
+    [MSG_TIMES_UP]     = gText_BerryCrush_TimeUp,
+    [MSG_COMM_STANDBY] = gText_BerryCrush_CommunicationStandby
 };
 
-static const u8 gUnknown_846E3B4[][4] = {
-    {0x02, 0x04, 0x06, 0x07},
-    {0x03, 0x05, 0x08, 0x0b},
-    {0x03, 0x07, 0x0b, 0x0f},
-    {0x04, 0x08, 0x0c, 0x11}
+static u32 (*const sBerryCrushCommands[])(struct BerryCrushGame * berryCrushGame, u8 *args) = {
+    [CMD_NONE]             = NULL,
+    [CMD_FADE]             = Cmd_BeginNormalPaletteFade,
+    [CMD_WAIT_FADE]        = Cmd_WaitPaletteFade,
+    [CMD_PRINT_MSG]        = Cmd_PrintMessage,
+    [CMD_SHOW_GAME]        = Cmd_ShowGameDisplay,
+    [CMD_HIDE_GAME]        = Cmd_HideGameDisplay,
+    [CMD_READY_BEGIN]      = Cmd_SignalReadyToBegin,
+    [CMD_ASK_PICK_BERRY]   = Cmd_AskPickBerry,
+    [CMD_PICK_BERRY]       = Cmd_GoToBerryPouch,
+    [CMD_WAIT_BERRIES]     = Cmd_WaitForOthersToPickBerries,
+    [CMD_DROP_BERRIES]     = Cmd_DropBerriesIntoCrusher,
+    [CMD_DROP_LID]         = Cmd_DropLid,
+    [CMD_COUNTDOWN]        = Cmd_Countdown,
+    [CMD_PLAY_GAME_LEADER] = Cmd_PlayGame_Leader,
+    [CMD_PLAY_GAME_MEMBER] = Cmd_PlayGame_Member,
+    [CMD_FINISH_GAME]      = Cmd_FinishGame,
+    [CMD_TIMES_UP]         = Cmd_HandleTimeUp,
+    [CMD_CALC_RESULTS]     = Cmd_TabulateResults,
+    [CMD_SHOW_RESULTS]     = Cmd_ShowResults,
+    [CMD_SAVE]             = Cmd_SaveGame,
+    [CMD_ASK_PLAY_AGAIN]   = Cmd_AskPlayAgain,
+    [CMD_COMM_PLAY_AGAIN]  = Cmd_CommunicatePlayAgainResponses,
+    [CMD_PLAY_AGAIN_YES]   = Cmd_PlayAgain,
+    [CMD_PLAY_AGAIN_NO]    = Cmd_StopGame,
+    [CMD_CLOSE_LINK]       = Cmd_CloseLink,
+    [CMD_QUIT]             = Cmd_Quit
 };
 
-static const u8 gUnknown_846E3C4[] = {5, 7, 9, 12};
+static const u8 sSparkleThresholds[MAX_RFU_PLAYERS - 1][4] = {
+    {2,  4,  6,  7}, // 2 players
+    {3,  5,  8, 11}, // 3 players
+    {3,  7, 11, 15}, // 4 players
+    {4,  8, 12, 17}, // 5 players
+};
+
+static const u8 sBigSparkleThresholds[MAX_RFU_PLAYERS - 1] = {5, 7, 9, 12};
 
-static const u8 sReceivedPlayerBitmasks[] = {0x03, 0x07, 0x0F, 0x1F};
+static const u8 sReceivedPlayerBitmasks[MAX_RFU_PLAYERS - 1] = {0x03, 0x07, 0x0F, 0x1F};
 
 static const struct BgTemplate sBgTemplates[] = {
     {
@@ -398,31 +534,12 @@ static const struct BgTemplate sBgTemplates[] = {
 };
 
 static const u8 sBerryCrushTextColorTable[][3] = {
-    {
-        TEXT_COLOR_WHITE,
-        TEXT_COLOR_DARK_GRAY,
-        TEXT_COLOR_LIGHT_GRAY
-    }, {
-        TEXT_COLOR_TRANSPARENT,
-        TEXT_COLOR_WHITE,
-        TEXT_COLOR_DARK_GRAY
-    }, {
-        TEXT_COLOR_TRANSPARENT,
-        TEXT_COLOR_LIGHT_GRAY,
-        TEXT_COLOR_RED
-    }, {
-        TEXT_COLOR_WHITE,
-        TEXT_COLOR_BLUE,
-        TEXT_COLOR_LIGHT_BLUE
-    }, {
-        TEXT_COLOR_WHITE,
-        TEXT_COLOR_GREEN,
-        TEXT_COLOR_LIGHT_GREEN
-    }, {
-        TEXT_COLOR_WHITE,
-        TEXT_COLOR_RED,
-        TEXT_COLOR_LIGHT_RED
-    }
+    [COLORID_GRAY] =       { TEXT_COLOR_WHITE,       TEXT_COLOR_DARK_GRAY,  TEXT_COLOR_LIGHT_GRAY },
+    [COLORID_BLACK] =      { TEXT_COLOR_TRANSPARENT, TEXT_COLOR_WHITE,      TEXT_COLOR_DARK_GRAY },
+    [COLORID_LIGHT_GRAY] = { TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_GRAY, TEXT_COLOR_RED },
+    [COLORID_BLUE] =       { TEXT_COLOR_WHITE,       TEXT_COLOR_BLUE,       TEXT_COLOR_LIGHT_BLUE },
+    [COLORID_GREEN] =      { TEXT_COLOR_WHITE,       TEXT_COLOR_GREEN,      TEXT_COLOR_LIGHT_GREEN },
+    [COLORID_RED] =        { TEXT_COLOR_WHITE,       TEXT_COLOR_RED,        TEXT_COLOR_LIGHT_RED }
 };
 
 static const struct WindowTemplate sWindowTemplate_BerryCrushRankings = {
@@ -435,7 +552,7 @@ static const struct WindowTemplate sWindowTemplate_BerryCrushRankings = {
     .baseBlock = 0x001
 };
 
-static const struct WindowTemplate gUnknown_846E3F8[] = {
+static const struct WindowTemplate sWindowTemplates_PlayerNames[] = {
     {
         .bg = 0,
         .tilemapLeft = 0,
@@ -479,8 +596,9 @@ static const struct WindowTemplate gUnknown_846E3F8[] = {
     }, DUMMY_WIN_TEMPLATE
 };
 
-static const struct WindowTemplate gUnknown_846E428[] = {
-    {
+static const struct WindowTemplate sWindowTemplates_Results[] = {
+
+    [STATE_RESULTS_PRESSES - RESULTS_STATE_START] = {
         .bg = 0,
         .tilemapLeft = 4,
         .tilemapTop = 2,
@@ -488,7 +606,8 @@ static const struct WindowTemplate gUnknown_846E428[] = {
         .height = 16,
         .paletteNum = 0xF,
 	    .baseBlock = 0x001
-    }, {
+    },
+    [STATE_RESULTS_RANDOM - RESULTS_STATE_START] = {
         .bg = 0,
         .tilemapLeft = 4,
         .tilemapTop = 2,
@@ -496,7 +615,8 @@ static const struct WindowTemplate gUnknown_846E428[] = {
         .height = 16,
         .paletteNum = 0xF,
 	    .baseBlock = 0x001
-    }, {
+    },
+    [STATE_RESULTS_CRUSHING - RESULTS_STATE_START] = {
         .bg = 0,
         .tilemapLeft = 3,
         .tilemapTop = 2,
@@ -507,14 +627,13 @@ static const struct WindowTemplate gUnknown_846E428[] = {
     }, DUMMY_WIN_TEMPLATE
 };
 
-static const u8 gUnknown_846E448[][4] = {
-    {  6,  8,  9, 11 },
-    { 12, 14, 15, 16}
+static const u8 sResultsWindowHeights[][MAX_RFU_PLAYERS - 1] = {
+    {  6,  8,  9, 11 },  // "Presses" and "Neatness/Cooperative/Power" pages
+    { 12, 14, 15, 16 },  // "Crushing" page
 };
 
 static const u32 sPressingSpeedConversionTable[] = {
-    // Decimal point is vertically aligned with the pixel
-    // directly between the >< below.
+    // Hundred-millionths of a second
     50000000, // 50
     25000000, // 25
     12500000, // 12.5
@@ -525,41 +644,83 @@ static const u32 sPressingSpeedConversionTable[] = {
       390625  //  0.390625
 };
 
-static const u16 sBerryCrushCorePal[] = INCBIN_U16("graphics/link_games/unk_846E4D0.gbapal");
-static const u16 sBerryCrushImpactAndSparklesPal[] = INCBIN_U16("graphics/link_games/unk_846E7FC.gbapal");
-static const u16 sBerryCrushTImerPal[] = INCBIN_U16("graphics/link_games/unk_846ECC4.gbapal");
+static const u16 sBerryCrushCorePal[] = INCBIN_U16("graphics/berry_crush/crusher_base.gbapal");
+static const u16 sBerryCrushImpactAndSparklesPal[] = INCBIN_U16("graphics/berry_crush/impact.gbapal");
+static const u16 sBerryCrushTimerPal[] = INCBIN_U16("graphics/berry_crush/timer_digits.gbapal");
 
-static const u32 sBerryCrushCoreTiles[] = INCBIN_U32("graphics/link_games/unk_846E4D0.4bpp.lz");
-static const u32 sBerryCrushImpactTiles[] = INCBIN_U32("graphics/link_games/unk_846E7FC.4bpp.lz");
-static const u32 sBerryCrushPowderSparklesTiles[] = INCBIN_U32("graphics/link_games/unk_846EB78.4bpp.lz");
-static const u32 sBerryCrushTimerTiles[] = INCBIN_U32("graphics/link_games/unk_846ECC4.4bpp.lz");
+static const u32 sBerryCrushCoreTiles[] = INCBIN_U32("graphics/berry_crush/crusher_base.4bpp.lz");
+static const u32 sBerryCrushImpactTiles[] = INCBIN_U32("graphics/berry_crush/impact.4bpp.lz");
+static const u32 sBerryCrushPowderSparklesTiles[] = INCBIN_U32("graphics/berry_crush/sparkle.4bpp.lz");
+static const u32 sBerryCrushTimerTiles[] = INCBIN_U32("graphics/berry_crush/timer_digits.4bpp.lz");
 
-static const u32 gBerryCrushGrinderTopTilemap[] = INCBIN_U32("graphics/link_games/unk_846ED90.bin.lz");
-static const u32 gBerryCrushContainerCapTilemap[] = INCBIN_U32("graphics/link_games/unk_846EEC0.bin.lz");
-static const u32 gBerryCrushBackgroundTilemap[] = INCBIN_U32("graphics/link_games/unk_846F058.bin.lz");
+static const u32 sCrusherTop_Tilemap[] = INCBIN_U32("graphics/berry_crush/crusher_top.bin.lz");
+static const u32 sContainerCap_Tilemap[] = INCBIN_U32("graphics/berry_crush/container_cap.bin.lz");
+static const u32 sBg_Tilemap[] = INCBIN_U32("graphics/berry_crush/bg.bin.lz");
 
-static const u8 gUnknown_846F280[][5] = {
+// Takes the number of players - 2 and a player id and returns the
+// index into sPlayerCoords where that player should be seated
+static const u8 gUnknown_846F280[MAX_RFU_PLAYERS - 1][MAX_RFU_PLAYERS] = {
     {1, 3},
     {0, 1, 3},
     {1, 3, 2, 4},
     {0, 1, 3, 2, 4}
 };
 
-static const struct BerryCrushPlayerSeatCoords gUnknown_846F294[] = {
-    {0, 0, 0, 0, -16, 0, 0},
-    {1, 0, 3, -28, -4, -24, 16},
-    {2, 0, 6, -16, 20, -8, 16},
-    {3, 20, 3, 28, -4, 32, -8},
-    {4, 20, 6, 16, 20, 16, -8}
+static const struct BerryCrushPlayerCoords sPlayerCoords[] = {
+    {
+        .playerId = 0,
+        .windowGfxX = 0,
+        .windowGfxY = 0,
+        .impactXOffset = 0,
+        .impactYOffset = -16,
+        .berryXOffset = 0,
+        .berryXDest = 0
+    },
+    {
+        .playerId = 1,
+        .windowGfxX = 0,
+        .windowGfxY = 3,
+        .impactXOffset = -28,
+        .impactYOffset = -4,
+        .berryXOffset = -24,
+        .berryXDest = 16
+    },
+    {
+        .playerId = 2,
+        .windowGfxX = 0,
+        .windowGfxY = 6,
+        .impactXOffset = -16,
+        .impactYOffset = 20,
+        .berryXOffset = -8,
+        .berryXDest = 16
+    },
+    {
+        .playerId = 3,
+        .windowGfxX = 20,
+        .windowGfxY = 3,
+        .impactXOffset = 28,
+        .impactYOffset = -4,
+        .berryXOffset = 32,
+        .berryXDest = -8
+    },
+    {
+        .playerId = 4,
+        .windowGfxX = 20,
+        .windowGfxY = 6,
+        .impactXOffset = 16,
+        .impactYOffset = 20,
+        .berryXOffset = 16,
+        .berryXDest = -8
+    },
 };
 
-static const s8 gUnknown_846F2D0[][2] = {
+static const s8 sImpactCoords[][2] = {
     { 0,  0},
     {-1,  0},
     { 1,  1}
 };
 
-static const s8 gUnknown_846F2D6[][2] = {
+static const s8 sSparkleCoords[][2] = {
     {  0,   0},
     {-16,  -4},
     { 16,  -4},
@@ -574,37 +735,41 @@ static const s8 gUnknown_846F2D6[][2] = {
 };
 
 static const u16 sPlayerBerrySpriteTags[] = {
-    5, 6, 7, 8, 9
+    TAG_PLAYER1_BERRY,
+    TAG_PLAYER2_BERRY,
+    TAG_PLAYER3_BERRY,
+    TAG_PLAYER4_BERRY,
+    TAG_PLAYER5_BERRY,
 };
 
 static const struct CompressedSpriteSheet sSpriteSheets[] = {
-    {sBerryCrushCoreTiles, 0x0800, 1},
-    {sBerryCrushImpactTiles, 0x0e00, 2},
-    {sBerryCrushPowderSparklesTiles, 0x0700, 3},
-    {sBerryCrushTimerTiles, 0x02c0, 4},
+    {sBerryCrushCoreTiles, 0x0800, TAG_CRUSHER_BASE},
+    {sBerryCrushImpactTiles, 0x0e00, GFXTAG_IMPACT},
+    {sBerryCrushPowderSparklesTiles, 0x0700, GFXTAG_SPARKLE},
+    {sBerryCrushTimerTiles, 0x02c0, TAG_TIMER_DIGITS},
     {}
 };
 
 static const struct SpritePalette sSpritePals[] = {
-    {sBerryCrushCorePal, 1},
-    {sBerryCrushImpactAndSparklesPal, 2},
-    {sBerryCrushTImerPal, 4},
+    {sBerryCrushCorePal,              TAG_CRUSHER_BASE},
+    {sBerryCrushImpactAndSparklesPal, PALTAG_EFFECT},
+    {sBerryCrushTimerPal,             TAG_TIMER_DIGITS},
     {}
 };
 
-static const union AnimCmd gUnknown_846F340[] = {
+static const union AnimCmd sAnim_CrusherBase[] = {
     ANIMCMD_FRAME(0x00, 0),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_846F348[] = {
+static const union AnimCmd sAnim_Impact_Small[] = {
     ANIMCMD_FRAME(0x00, 4),
     ANIMCMD_FRAME(0x10, 4),
     ANIMCMD_FRAME(0x20, 4),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_846F358[] = {
+static const union AnimCmd sAnim_Impact_Big[] = {
     ANIMCMD_FRAME(0x30, 2),
     ANIMCMD_FRAME(0x40, 2),
     ANIMCMD_FRAME(0x50, 2),
@@ -612,7 +777,7 @@ static const union AnimCmd gUnknown_846F358[] = {
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_846F36C[] = {
+static const union AnimCmd sAnim_Sparkle_Small[] = {
     ANIMCMD_FRAME(0x00, 2),
     ANIMCMD_FRAME(0x04, 2),
     ANIMCMD_FRAME(0x08, 2),
@@ -622,7 +787,7 @@ static const union AnimCmd gUnknown_846F36C[] = {
     ANIMCMD_JUMP(0)
 };
 
-static const union AnimCmd gUnknown_846F388[] = {
+static const union AnimCmd sAnim_Sparkle_Big[] = {
     ANIMCMD_FRAME(0x18, 4),
     ANIMCMD_FRAME(0x1c, 4),
     ANIMCMD_FRAME(0x20, 4),
@@ -634,59 +799,59 @@ static const union AnimCmd gUnknown_846F388[] = {
     ANIMCMD_JUMP(0)
 };
 
-static const union AnimCmd gUnknown_846F3AC[] = {
+static const union AnimCmd sAnim_Timer[] = {
     ANIMCMD_FRAME(0x14, 0),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_846F3B4[] = {
+static const union AnimCmd sAnim_PlayerBerry[] = {
     ANIMCMD_FRAME(0x00, 0),
     ANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_846F3BC[] = {
-    AFFINEANIMCMD_FRAME(256, 256, 0, 0),
+static const union AffineAnimCmd sAffineAnim_PlayerBerry_0[] = {
+    AFFINEANIMCMD_FRAME(Q_8_8(1.0), Q_8_8(1.0), 0, 0),
     AFFINEANIMCMD_FRAME(0, 0, 2, 1),
     AFFINEANIMCMD_JUMP(1)
 };
 
-static const union AffineAnimCmd gUnknown_846F3D4[] = {
-    AFFINEANIMCMD_FRAME(256, 256, 0, 0),
+static const union AffineAnimCmd sAffineAnim_PlayerBerry_1[] = {
+    AFFINEANIMCMD_FRAME(Q_8_8(1.0), Q_8_8(1.0), 0, 0),
     AFFINEANIMCMD_FRAME(0, 0, -2, 1),
     AFFINEANIMCMD_JUMP(1)
 };
 
 static const union AnimCmd *const sAnimTable_BerryCrushCore[] = {
-    gUnknown_846F340
+    sAnim_CrusherBase
 };
 
 static const union AnimCmd *const sAnimTable_BerryCrushImpact[] = {
-    gUnknown_846F348,
-    gUnknown_846F358
+    sAnim_Impact_Small,
+    sAnim_Impact_Big
 };
 
 static const union AnimCmd *const sAnimTable_BerryCrushPowderSparkles[] = {
-    gUnknown_846F36C,
-    gUnknown_846F388
+    sAnim_Sparkle_Small,
+    sAnim_Sparkle_Big
 };
 
 static const union AnimCmd *const sAnimTable_BerryCrushTimer[] = {
-    gUnknown_846F3AC
+    sAnim_Timer
 };
 
-static const union AnimCmd *const gUnknown_846F404[] = {
-    gUnknown_846F3B4
+static const union AnimCmd *const sAnimTable_PlayerBerry[] = {
+    sAnim_PlayerBerry
 };
 
-static const union AffineAnimCmd *const gUnknown_846F408[] = {
-    gUnknown_846F3BC,
-    gUnknown_846F3D4
+static const union AffineAnimCmd *const sAffineAnimTable_PlayerBerry[] = {
+    sAffineAnim_PlayerBerry_0,
+    sAffineAnim_PlayerBerry_1
 };
 
 
 static const struct SpriteTemplate sSpriteTemplate_BerryCrushCore = {
-    .tileTag = 1,
-    .paletteTag = 1,
+    .tileTag = TAG_CRUSHER_BASE,
+    .paletteTag = TAG_CRUSHER_BASE,
     .oam = &gOamData_AffineOff_ObjNormal_64x64,
     .anims = sAnimTable_BerryCrushCore,
     .affineAnims = gDummySpriteAffineAnimTable,
@@ -694,17 +859,17 @@ static const struct SpriteTemplate sSpriteTemplate_BerryCrushCore = {
 };
 
 static const struct SpriteTemplate sSpriteTemplate_BerryCrushImpact = {
-    .tileTag = 2,
-    .paletteTag = 2,
+    .tileTag = GFXTAG_IMPACT,
+    .paletteTag = PALTAG_EFFECT,
     .oam = &gOamData_AffineOff_ObjNormal_32x32,
     .anims = sAnimTable_BerryCrushImpact,
     .affineAnims = gDummySpriteAffineAnimTable,
-    .callback = SpriteCB_BerryCrushImpact
+    .callback = SpriteCB_Impact
 };
 
 static const struct SpriteTemplate sSpriteTemplate_BerryCrushPowderSparkles = {
-    .tileTag = 3,
-    .paletteTag = 2,
+    .tileTag = GFXTAG_SPARKLE,
+    .paletteTag = PALTAG_EFFECT,
     .oam = &gOamData_AffineOff_ObjNormal_16x16,
     .anims = sAnimTable_BerryCrushPowderSparkles,
     .affineAnims = gDummySpriteAffineAnimTable,
@@ -712,8 +877,8 @@ static const struct SpriteTemplate sSpriteTemplate_BerryCrushPowderSparkles = {
 };
 
 static const struct SpriteTemplate sSpriteTemplate_BerryCrushTimer = {
-    .tileTag = 4,
-    .paletteTag = 4,
+    .tileTag = TAG_TIMER_DIGITS,
+    .paletteTag = TAG_TIMER_DIGITS,
     .oam = &gOamData_AffineOff_ObjNormal_8x16,
     .anims = sAnimTable_BerryCrushTimer,
     .affineAnims = gDummySpriteAffineAnimTable,
@@ -721,11 +886,11 @@ static const struct SpriteTemplate sSpriteTemplate_BerryCrushTimer = {
 };
 
 static const struct SpriteTemplate sSpriteTemplate_PlayerBerry = {
-    .tileTag = 5,
-    .paletteTag = 5,
+    .tileTag = TAG_PLAYER1_BERRY,
+    .paletteTag = TAG_PLAYER1_BERRY,
     .oam = &gOamData_AffineDouble_ObjNormal_32x32,
-    .anims = gUnknown_846F404,
-    .affineAnims = gUnknown_846F408,
+    .anims = sAnimTable_PlayerBerry,
+    .affineAnims = sAffineAnimTable_PlayerBerry,
     .callback = SpriteCallbackDummy
 };
 
@@ -767,29 +932,30 @@ static const struct DigitObjUtilTemplate sDigitObjTemplates[] = {
 };
 
 static const u8 *const sBCRankingHeaders[] = {
-    gText_SpaceTimes,
-    gText_XDotY,
-    gText_StrVar1Berry,
-    gText_NeatnessRankings,
-    gText_CooperativeRankings,
-    gText_PressingPowerRankings
+    [RESULTS_PAGE_PRESSES]  = gText_SpaceTimes,
+    [RESULTS_PAGE_RANDOM]   = gText_XDotY,
+    [RESULTS_PAGE_CRUSHING] = gText_StrVar1Berry,
+
+    [RESULTS_PAGE_NEATNESS + NUM_RESULTS_PAGES]    = gText_NeatnessRankings,
+    [RESULTS_PAGE_COOPERATIVE + NUM_RESULTS_PAGES] = gText_CooperativeRankings,
+    [RESULTS_PAGE_POWER + NUM_RESULTS_PAGES]       = gText_PressingPowerRankings
 };
 
-struct BerryCrushGame *GetBerryCrushGame(void)
+static struct BerryCrushGame *GetBerryCrushGame(void)
 {
-    return sBerryCrushGamePtr;
+    return sGame;
 }
 
-u32 ExitBerryCrushWithCallback(MainCallback callback)
+static u32 QuitBerryCrush(MainCallback callback)
 {
-    if (sBerryCrushGamePtr == NULL)
+    if (sGame == NULL)
         return 2;
 
     if (callback == NULL)
-        callback = sBerryCrushGamePtr->savedCallback;
+        callback = sGame->savedCallback;
 
-    DestroyTask(sBerryCrushGamePtr->mainTask);
-    FREE_AND_SET_NULL(sBerryCrushGamePtr);
+    DestroyTask(sGame->mainTask);
+    FREE_AND_SET_NULL(sGame);
     SetMainCallback2(callback);
     if (callback == CB2_ReturnToField)
     {
@@ -800,6 +966,15 @@ u32 ExitBerryCrushWithCallback(MainCallback callback)
     return 0;
 }
 
+#define ERROR_EXIT(exitCallback)        \
+    {                                   \
+        SetMainCallback2(exitCallback); \
+        Rfu.linkman_param[0] = 0;       \
+        Rfu.linkman_param[1] = 0;       \
+        Rfu.errorState = 1;             \
+    }
+
+
 void StartBerryCrush(MainCallback callback)
 {
     u8 playerCount = 0;
@@ -807,10 +982,7 @@ void StartBerryCrush(MainCallback callback)
 
     if (!gReceivedRemoteLinkPlayers || gWirelessCommType == 0)
     {
-        SetMainCallback2(callback);
-        Rfu.linkman_param[0] = 0;
-        Rfu.linkman_param[1] = 0;
-        Rfu.errorState = 1;
+        ERROR_EXIT(callback);
         return;
     }
 
@@ -818,126 +990,121 @@ void StartBerryCrush(MainCallback callback)
     multiplayerId = GetMultiplayerId();
     if (playerCount < 2 || multiplayerId >= playerCount)
     {
-        SetMainCallback2(callback);
-        Rfu.linkman_param[0] = 0;
-        Rfu.linkman_param[1] = 0;
-        Rfu.errorState = 1;
+        ERROR_EXIT(callback);
         return;
     }
 
-    sBerryCrushGamePtr = AllocZeroed(sizeof(struct BerryCrushGame));
-    if (!sBerryCrushGamePtr)
+    sGame = AllocZeroed(sizeof(struct BerryCrushGame));
+    if (!sGame)
     {
-        SetMainCallback2(callback);
-        Rfu.linkman_param[0] = 0;
-        Rfu.linkman_param[1] = 0;
-        Rfu.errorState = 1;
+        ERROR_EXIT(callback);
         return;
     }
 
-    sBerryCrushGamePtr->savedCallback = callback;
-    sBerryCrushGamePtr->localId = multiplayerId;
-    sBerryCrushGamePtr->playerCount = playerCount;
-    BerryCrush_InitPlayerNamesAndTextSpeed(sBerryCrushGamePtr);
-    sBerryCrushGamePtr->gameState = 1;
-    sBerryCrushGamePtr->nextCmd = BCCMD_BeginNormalPaletteFade;
-    sBerryCrushGamePtr->afterPalFadeCmd = BCCMD_SignalReadyToBegin;
-    BerryCrush_SetPaletteFadeParams(sBerryCrushGamePtr->commandParams, TRUE, 0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
-    BerryCrush_RunOrScheduleCommand(BCCMD_InitGfx, 1, sBerryCrushGamePtr->commandParams);
-    SetMainCallback2(CB2_BerryCrush);
-    sBerryCrushGamePtr->mainTask = CreateTask(Task_RunBerryCrushGame, 8);
+    sGame->savedCallback = callback;
+    sGame->localId = multiplayerId;
+    sGame->playerCount = playerCount;
+    SetNamesAndTextSpeed(sGame);
+    sGame->gameState = STATE_INIT;
+    sGame->nextCmd = CMD_FADE;
+    sGame->afterPalFadeCmd = CMD_READY_BEGIN;
+    SetPaletteFadeArgs(sGame->commandParams, TRUE, PALETTES_ALL, 0, 16, 0, RGB_BLACK);
+    RunOrScheduleCommand(CMD_SHOW_GAME, SCHEDULE_CMD, sGame->commandParams);
+    SetMainCallback2(MainCB);
+    sGame->mainTask = CreateTask(MainTask, 8);
 }
 
-static void CB2_ReturnToBerryCrushGameFromBerryPouch(void)
+static void GetBerryFromBag(void)
 {
     if (gSpecialVar_ItemId < FIRST_BERRY_INDEX || gSpecialVar_ItemId > LAST_BERRY_INDEX + 1)
         gSpecialVar_ItemId = FIRST_BERRY_INDEX;
     else
         RemoveBagItem(gSpecialVar_ItemId, 1);
 
-    sBerryCrushGamePtr->unk98[sBerryCrushGamePtr->localId].unkC = gSpecialVar_ItemId - FIRST_BERRY_INDEX;
-    sBerryCrushGamePtr->nextCmd = BCCMD_BeginNormalPaletteFade;
-    sBerryCrushGamePtr->afterPalFadeCmd = BCCMD_WaitForOthersToPickBerries;
-    BerryCrush_SetPaletteFadeParams(sBerryCrushGamePtr->commandParams, FALSE, 0xFFFFFFFF, 0, 16, 0, RGB_BLACK);
-    BerryCrush_RunOrScheduleCommand(BCCMD_InitGfx, 1, sBerryCrushGamePtr->commandParams);
-    sBerryCrushGamePtr->mainTask = CreateTask(Task_RunBerryCrushGame, 8);
-    SetMainCallback2(CB2_BerryCrush);
+    sGame->players[sGame->localId].berryId = gSpecialVar_ItemId - FIRST_BERRY_INDEX;
+    sGame->nextCmd = CMD_FADE;
+    sGame->afterPalFadeCmd = CMD_WAIT_BERRIES;
+    SetPaletteFadeArgs(sGame->commandParams, FALSE, PALETTES_ALL, 0, 16, 0, RGB_BLACK);
+    RunOrScheduleCommand(CMD_SHOW_GAME, SCHEDULE_CMD, sGame->commandParams);
+    sGame->mainTask = CreateTask(MainTask, 8);
+    SetMainCallback2(MainCB);
 }
 
-void CB2_BerryCrush_GoToBerryPouch(void)
+static void ChooseBerry(void)
 {
-    DestroyTask(sBerryCrushGamePtr->mainTask);
-    InitBerryPouch(BERRYPOUCH_FROMBERRYCRUSH, CB2_ReturnToBerryCrushGameFromBerryPouch, FALSE);
+    DestroyTask(sGame->mainTask);
+    InitBerryPouch(BERRYPOUCH_FROMBERRYCRUSH, GetBerryFromBag, FALSE);
 }
 
-void BerryCrush_SetVBlankCallback(void)
+static void BerryCrush_SetVBlankCallback(void)
 {
-    SetVBlankCallback(VBlankCB_BerryCrush);
+    SetVBlankCallback(VBlankCB);
 }
 
-void BerryCrush_UnsetVBlankCallback(void)
+static void BerryCrush_InitVBlankCB(void)
 {
     SetVBlankCallback(NULL);
 }
 
-void BerryCrush_UpdateSav2Records(void)
+static void SaveResults(void)
 {
-    u32 var0, var1;
+    u32 time, presses;
 
-    var0 = sBerryCrushGamePtr->unk68.unk04;
-    var0 <<= 8;
-    var0 = MathUtil_Div32(var0, 60 << 8);
-    var1 = sBerryCrushGamePtr->unk68.unk0A;
-    var1 <<= 8;
-    var1 = MathUtil_Div32(var1, var0) & 0xFFFF;
-    sBerryCrushGamePtr->pressingSpeed = var1;
-    switch (sBerryCrushGamePtr->playerCount)
+    time = sGame->results.time;
+    time = Q_24_8(time);
+    time = Q_24_8_div(time, Q_24_8(60));
+    presses = sGame->results.totalAPresses;
+    presses = Q_24_8(presses);
+    presses = Q_24_8_div(presses, time) & 0xFFFF;
+    sGame->pressingSpeed = presses;
+
+    switch (sGame->playerCount)
     {
     case 2:
-        if (sBerryCrushGamePtr->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[0])
+        if (sGame->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[0])
         {
-            sBerryCrushGamePtr->unk25_1 = 1;
-            gSaveBlock2Ptr->berryCrush.berryCrushResults[0] = sBerryCrushGamePtr->pressingSpeed;
+            sGame->newRecord = TRUE;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[0] = sGame->pressingSpeed;
         }
         break;
     case 3:
-        if (sBerryCrushGamePtr->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[1])
+        if (sGame->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[1])
         {
-            sBerryCrushGamePtr->unk25_1 = 1;
-            gSaveBlock2Ptr->berryCrush.berryCrushResults[1] = sBerryCrushGamePtr->pressingSpeed;
+            sGame->newRecord = TRUE;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[1] = sGame->pressingSpeed;
         }
         break;
     case 4:
-        if (sBerryCrushGamePtr->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[2])
+        if (sGame->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[2])
         {
-            sBerryCrushGamePtr->unk25_1 = 1;
-            gSaveBlock2Ptr->berryCrush.berryCrushResults[2] = sBerryCrushGamePtr->pressingSpeed;
+            sGame->newRecord = TRUE;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[2] = sGame->pressingSpeed;
         }
         break;
     case 5:
-        if (sBerryCrushGamePtr->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[3])
+        if (sGame->pressingSpeed > gSaveBlock2Ptr->berryCrush.berryCrushResults[3])
         {
-            sBerryCrushGamePtr->unk25_1 = 1;
-            gSaveBlock2Ptr->berryCrush.berryCrushResults[3] = sBerryCrushGamePtr->pressingSpeed;
+            sGame->newRecord = TRUE;
+            gSaveBlock2Ptr->berryCrush.berryCrushResults[3] = sGame->pressingSpeed;
         }
         break;
     }
 
-    sBerryCrushGamePtr->powder = sBerryCrushGamePtr->unk68.unk00;
-    if (GiveBerryPowder(sBerryCrushGamePtr->powder))
+    sGame->powder = sGame->results.powder;
+    if (GiveBerryPowder(sGame->powder))
         return;
 
-    sBerryCrushGamePtr->unk25_0 = 1;
+    sGame->noRoomForPowder = TRUE;
 }
 
-static void VBlankCB_BerryCrush(void)
+static void VBlankCB(void)
 {
     TransferPlttBuffer();
     LoadOam();
     ProcessSpriteCopyRequests();
 }
 
-static void CB2_BerryCrush(void)
+static void MainCB(void)
 {
     RunTasks();
     RunTextPrinters();
@@ -945,27 +1112,27 @@ static void CB2_BerryCrush(void)
     BuildOamBuffer();
 }
 
-static void Task_RunBerryCrushGame(u8 taskId)
+static void MainTask(u8 taskId)
 {
-    if (sBerryCrushGamePtr->cmdCallback != NULL)
-        sBerryCrushGamePtr->cmdCallback(sBerryCrushGamePtr, sBerryCrushGamePtr->commandParams);
+    if (sGame->cmdCallback != NULL)
+        sGame->cmdCallback(sGame, sGame->commandParams);
 
-    sub_814D9CC(sBerryCrushGamePtr);
+    UpdateGame(sGame);
 }
 
-void BerryCrush_InitPlayerNamesAndTextSpeed(struct BerryCrushGame *game)
+static void SetNamesAndTextSpeed(struct BerryCrushGame *game)
 {
     u8 i;
 
     for (i = 0; i < game->playerCount; i++)
     {
-        StringCopy(game->unk98[i].unk0, gLinkPlayers[i].name);
-        game->unk98[i].unk0[PLAYER_NAME_LENGTH] = EOS;
+        StringCopy(game->players[i].name, gLinkPlayers[i].name);
+        game->players[i].name[PLAYER_NAME_LENGTH] = EOS;
     }
     for (; i < 5; i++)
     {
-        memset(game->unk98[i].unk0, 1, PLAYER_NAME_LENGTH);
-        game->unk98[i].unk0[PLAYER_NAME_LENGTH] = EOS;
+        memset(game->players[i].name, 1, PLAYER_NAME_LENGTH);
+        game->players[i].name[PLAYER_NAME_LENGTH] = EOS;
     }
 
     switch (gSaveBlock2Ptr->optionsTextSpeed)
@@ -982,32 +1149,34 @@ void BerryCrush_InitPlayerNamesAndTextSpeed(struct BerryCrushGame *game)
     }
 }
 
-void BerryCrush_RunOrScheduleCommand(u16 command, u8 runMode, u8 *params)
+// GF file break
+
+static void RunOrScheduleCommand(u16 command, u8 runMode, u8 *args)
 {
     struct BerryCrushGame * game = GetBerryCrushGame();
 
     if (command >= NELEMS(sBerryCrushCommands))
-        command = 0;
+        command = CMD_NONE;
     switch (runMode)
     {
-    case 0:
+    case RUN_CMD:
         // Call now and set followup to game->nextCmd
-        if (command != 0)
-            sBerryCrushCommands[command](game, params);
+        if (command != CMD_NONE)
+            sBerryCrushCommands[command](game, args);
         if (game->nextCmd >= NELEMS(sBerryCrushCommands))
-            game->nextCmd = 0;
+            game->nextCmd = CMD_NONE;
         game->cmdCallback = sBerryCrushCommands[game->nextCmd];
         break;
-    case 1:
+    case SCHEDULE_CMD:
         // Schedule for next frame
         game->cmdCallback = sBerryCrushCommands[command];
         break;
     }
 }
 
-static u32 BerryCrushCommand_BeginNormalPaletteFade(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_BeginNormalPaletteFade(struct BerryCrushGame * game, u8 *args)
 {
-    // params points to packed values:
+    // args points to packed values:
     // bytes 0-3: selectedPals (bitfield)
     // byte 4: delay
     // byte 5: startY
@@ -1018,46 +1187,47 @@ static u32 BerryCrushCommand_BeginNormalPaletteFade(struct BerryCrushGame * game
     u16 color;
     u32 selectedPals[2];
 
-    selectedPals[0] = (u32)params[0];
-    selectedPals[1] = (u32)params[1];
-    selectedPals[1] <<= 8;
+    selectedPals[0] = (u32)bSelectedPals(0);
 
+    selectedPals[1] = (u32)bSelectedPals(1);
+    selectedPals[1] <<= 8;
     selectedPals[0] |= selectedPals[1];
-    selectedPals[1] = (u32)params[2];
-    selectedPals[1] <<= 16;
 
+    selectedPals[1] = (u32)bSelectedPals(2);
+    selectedPals[1] <<= 16;
     selectedPals[0] |= selectedPals[1];
-    selectedPals[1] = (u32)params[3];
-    selectedPals[1] <<= 24;
 
+    selectedPals[1] = (u32)bSelectedPals(3);
+    selectedPals[1] <<= 24;
     selectedPals[0] |= selectedPals[1];
-    params[0] = params[9];
 
-    color = params[8];
+    bWaitFadeCommAfter = bCommunicateAfter;
+
+    color = bPalette(1);
     color <<= 8;
-    color |= params[7];
+    color |= bPalette(0);
 
     gPaletteFade.bufferTransferDisabled = FALSE;
-    BeginNormalPaletteFade(selectedPals[0], params[4], params[5], params[6], color);
+    BeginNormalPaletteFade(selectedPals[0], bDelay, bStartY, bTargetY, color);
     UpdatePaletteFade();
-    game->nextCmd = BCCMD_WaitPaletteFade;
+    game->nextCmd = CMD_WAIT_FADE;
     return 0;
 }
 
-static u32 BerryCrushCommand_WaitPaletteFade(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_WaitPaletteFade(struct BerryCrushGame * game, u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
         if (UpdatePaletteFade())
             return 0;
-        if(params[0] != 0)
+        if (bWaitFadeCommAfter)
             ++game->cmdState;
         else
             game->cmdState = 3;
         return 0;
     case 1:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         ++game->cmdState;
         return 0;
     case 2:
@@ -1068,7 +1238,7 @@ static u32 BerryCrushCommand_WaitPaletteFade(struct BerryCrushGame * game, u8 *p
         }
         return 0;
     case 3:
-        BerryCrush_RunOrScheduleCommand(game->afterPalFadeCmd, 1, NULL);
+        RunOrScheduleCommand(game->afterPalFadeCmd, SCHEDULE_CMD, NULL);
         game->cmdState = 0;
         return 0;
     default:
@@ -1077,78 +1247,85 @@ static u32 BerryCrushCommand_WaitPaletteFade(struct BerryCrushGame * game, u8 *p
     }
 }
 
-static u32 BerryCrushCommand_PrintMessage(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_PrintMessage(struct BerryCrushGame * game, u8 *args)
 {
-    u16 waitKeys;
+    // args[0]: msg id
+    // args[1]: flags
+    // args[2]: keys lo
+    // args[3]: keys hi
+    // args[4]: follow-up cmd state
+
+    u16 keys;
+
+    keys  = bKeys(1);
+    keys <<= 8;
+    keys |= bKeys(0) << 0;
 
-    waitKeys  = params[3];
-    waitKeys <<= 8;
-    waitKeys |= params[2] << 0;
     switch (game->cmdState)
     {
     case 0:
         DrawDialogueFrame(0, FALSE);
-        if (params[1] & 2)
+        if (bFlags & F_MSG_EXPAND)
         {
-            StringExpandPlaceholders(gStringVar4, sBerryCrushMessages[params[0]]);
+            StringExpandPlaceholders(gStringVar4, sMessages[bMsgId]);
             AddTextPrinterParameterized2(0, 2, gStringVar4, game->textSpeed, 0, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
         }
         else
         {
-            AddTextPrinterParameterized2(0, 2, sBerryCrushMessages[params[0]], game->textSpeed, NULL, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
+            AddTextPrinterParameterized2(0, 2, sMessages[bMsgId], game->textSpeed, NULL, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
         }
         CopyWindowToVram(0, COPYWIN_BOTH);
         break;
     case 1:
         if (!IsTextPrinterActive(0))
         {
-            if (waitKeys == 0)
+            if (keys == 0)
                 ++game->cmdState;
             break;
         }
         return 0;
     case 2:
-        if (!(waitKeys & gMain.newKeys))
+        if (!JOY_NEW(keys))
             return 0;
         break;
     case 3:
-        if (params[1] & 1)
+        if (bFlags & F_MSG_CLEAR)
             ClearDialogWindowAndFrame(0, TRUE);
-        BerryCrush_RunOrScheduleCommand(game->nextCmd, 1, NULL);
-        game->cmdState = params[4];
+        RunOrScheduleCommand(game->nextCmd, SCHEDULE_CMD, NULL);
+        game->cmdState = bNextCmdState;
         return 0;
     }
     ++game->cmdState;
     return 0;
 }
 
-static u32 BerryCrushCommand_InitGfx(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_ShowGameDisplay(struct BerryCrushGame * game, UNUSED u8 *args)
 {
-    if (BerryCrush_InitBgs() != 0)
-        BerryCrush_RunOrScheduleCommand(game->nextCmd, 0, game->commandParams);
+    if (ShowGameDisplay())
+        RunOrScheduleCommand(game->nextCmd, RUN_CMD, game->commandParams);
     return 0;
 }
 
-static u32 BerryCrushCommand_TeardownGfx(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_HideGameDisplay(struct BerryCrushGame * game, UNUSED u8 *args)
 {
-    if (BerryCrush_TeardownBgs() != 0)
-        BerryCrush_RunOrScheduleCommand(game->nextCmd, 0, game->commandParams);
+    if (HideGameDisplay())
+        RunOrScheduleCommand(game->nextCmd, RUN_CMD, game->commandParams);
     return 0;
 }
 
-static u32 BerryCrushCommand_SignalReadyToBegin(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_SignalReadyToBegin(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (IsLinkTaskFinished())
         {
             PlayNewMapMusic(MUS_GAME_CORNER);
-            BerryCrush_RunOrScheduleCommand(BCCMD_AskPickBerry, 1, NULL);
-            game->gameState = 3;
+            RunOrScheduleCommand(CMD_ASK_PICK_BERRY, SCHEDULE_CMD, NULL);
+            game->gameState = STATE_PICK_BERRY;
             game->cmdState = 0;
         }
         return 0;
@@ -1157,7 +1334,7 @@ static u32 BerryCrushCommand_SignalReadyToBegin(struct BerryCrushGame * game, UN
     return 0;
 }
 
-static u32 BerryCrushCommand_AskPickBerry(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_AskPickBerry(struct BerryCrushGame * game, u8 *args)
 {
     switch (game->cmdState)
     {
@@ -1165,72 +1342,72 @@ static u32 BerryCrushCommand_AskPickBerry(struct BerryCrushGame * game, u8 *para
         ++game->cmdState;
         break;
     case 0:
-        sub_814D4D8(game);
-        BerryCrush_SetShowMessageParams(params, BCTEXT_AREYOUREADY, 1, 0, BCCMD_BeginNormalPaletteFade);
-        game->nextCmd = BCCMD_AskPickBerry;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
+        ResetGame(game);
+        SetPrintMessageArgs(args, MSG_PICK_BERRY, F_MSG_CLEAR, 0, CMD_FADE);
+        game->nextCmd = CMD_ASK_PICK_BERRY;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
         break;
     case 1:
-        game->nextCmd = BCCMD_GoToBerryPouch;
-        BerryCrush_RunOrScheduleCommand(BCCMD_TeardownGfx, 1, NULL);
+        game->nextCmd = CMD_PICK_BERRY;
+        RunOrScheduleCommand(CMD_HIDE_GAME, SCHEDULE_CMD, NULL);
         game->cmdState = 2;
         break;
     }
     return 0;
 }
 
-static u32 BerryCrushCommand_GoToBerryPouch(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_GoToBerryPouch(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     game->cmdCallback = NULL;
-    SetMainCallback2(CB2_BerryCrush_GoToBerryPouch);
+    SetMainCallback2(ChooseBerry);
     return 0;
 }
 
-static u32 BerryCrushCommand_WaitForOthersToPickBerries(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_WaitForOthersToPickBerries(struct BerryCrushGame * game, u8 *args)
 {
     u8 i;
 
     switch (game->cmdState)
     {
     case 0:
-        BerryCrush_SetShowMessageParams(params, BCTEXT_WAITFOROTHERS, 0, 0, BCCMD_BeginNormalPaletteFade);
-        game->nextCmd = BCCMD_WaitForOthersToPickBerries;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
+        SetPrintMessageArgs(args, MSG_WAIT_PICK, 0, 0, CMD_FADE);
+        game->nextCmd = CMD_WAIT_BERRIES;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
         return 0;
     case 1:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 2:
         if (!IsLinkTaskFinished())
             return 0;
         memset(game->sendCmd, 0, sizeof(game->sendCmd));
-        game->sendCmd[0] = game->unk98[game->localId].unkC;
+        game->sendCmd[0] = game->players[game->localId].berryId;
         SendBlock(0, game->sendCmd, 2);
         break;
     case 3:
         if (!IsLinkTaskFinished())
             return 0;
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         break;
     case 4:
         if (GetBlockReceivedStatus() != sReceivedPlayerBitmasks[game->playerCount - 2])
             return 0;
         for (i = 0; i < game->playerCount; ++i)
         {
-            game->unk98[i].unkC = gBlockRecvBuffer[i][0];
-            if (game->unk98[i].unkC > 0xB0)
-                game->unk98[i].unkC = 0;
-            game->unk18 += gBerryCrushStats[game->unk98[i].unkC].unk0;
-            game->powder += gBerryCrushStats[game->unk98[i].unkC].powder;
+            game->players[i].berryId = gBlockRecvBuffer[i][0];
+            if (game->players[i].berryId > LAST_BERRY_INDEX + 1)
+                game->players[i].berryId = 0;
+            game->targetAPresses += gBerryCrush_BerryData[game->players[i].berryId].difficulty;
+            game->powder += gBerryCrush_BerryData[game->players[i].berryId].powder;
         }
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         ResetBlockReceivedFlags();
-        game->unk20 = MathUtil_Div32(game->unk18 << 8, 0x2000);
+        game->targetDepth = Q_24_8_div(Q_24_8(game->targetAPresses), Q_24_8(32));
         break;
     case 5:
         ClearDialogWindowAndFrame(0, TRUE);
-        BerryCrush_RunOrScheduleCommand(BCCMD_DropBerriesIntoCrusher, 1, NULL);
-        game->gameState = 4;
+        RunOrScheduleCommand(CMD_DROP_BERRIES, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_DROP_BERRIES;
         game->cmdState = 0;
         return 0;
     }
@@ -1238,54 +1415,54 @@ static u32 BerryCrushCommand_WaitForOthersToPickBerries(struct BerryCrushGame *
     return 0;
 }
 
-static u32 BerryCrushCommand_DropBerriesIntoCrusher(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_DropBerriesIntoCrusher(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        BerryCrush_CreateBerrySprites(game, &game->spritesManager);
-        LinkRfu_SetRfuFuncToSend6600();
+        CreateBerrySprites(game, &game->gfx);
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (!IsLinkTaskFinished())
             return 0;
-        game->spritesManager.animBerryIdx = 0;
-        game->spritesManager.unk1 = 0;
-        game->spritesManager.unk2 = 0;
-        game->spritesManager.unk3 = 0;
+        game->gfx.counter = 0;
+        game->gfx.vibrationIdx = 0;
+        game->gfx.numVibrations = 0;
+        game->gfx.vibrating = 0;
         break;
     case 2:
-        game->spritesManager.berrySprites[game->spritesManager.animBerryIdx]->callback = SpriteCB_DropBerryIntoCrusher;
-        game->spritesManager.berrySprites[game->spritesManager.animBerryIdx]->affineAnimPaused = FALSE;
+        game->gfx.berrySprites[game->gfx.counter]->callback = SpriteCB_DropBerryIntoCrusher;
+        game->gfx.berrySprites[game->gfx.counter]->affineAnimPaused = FALSE;
         PlaySE(SE_BALL_THROW);
         break;
     case 3:
-        if (game->spritesManager.berrySprites[game->spritesManager.animBerryIdx]->callback == SpriteCB_DropBerryIntoCrusher)
+        if (game->gfx.berrySprites[game->gfx.counter]->callback == SpriteCB_DropBerryIntoCrusher)
             return 0;
-        game->spritesManager.berrySprites[game->spritesManager.animBerryIdx] = NULL;
-        ++game->spritesManager.animBerryIdx;
-        LinkRfu_SetRfuFuncToSend6600();
+        game->gfx.berrySprites[game->gfx.counter] = NULL;
+        ++game->gfx.counter;
+        Rfu_SetLinkStandbyCallback();
         break;
     case 4:
         if (!IsLinkTaskFinished())
             return 0;
-        if (game->spritesManager.animBerryIdx < game->playerCount)
+        if (game->gfx.counter < game->playerCount)
         {
             game->cmdState = 2;
             return 0;
         }
-        game->spritesManager.animBerryIdx = 0;
+        game->gfx.counter = 0;
         break;
     case 5:
-        BerryCrushFreeBerrySpriteGfx(game, &game->spritesManager);
-        LinkRfu_SetRfuFuncToSend6600();
+        BerryCrushFreeBerrySpriteGfx(game, &game->gfx);
+        Rfu_SetLinkStandbyCallback();
         break;
     case 6:
         if (!IsLinkTaskFinished())
             return 0;
         PlaySE(SE_FALL);
-        BerryCrush_RunOrScheduleCommand(BCCMD_DropLid, 1, NULL);
-        game->gameState = 5;
+        RunOrScheduleCommand(CMD_DROP_LID, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_DROP_LID;
         game->cmdState = 0;
         return 0;
     }
@@ -1293,7 +1470,7 @@ static u32 BerryCrushCommand_DropBerriesIntoCrusher(struct BerryCrushGame * game
     return 0;
 }
 
-static u32 BerryCrushCommand_DropLid(struct BerryCrushGame * game,  UNUSED u8 *params)
+static u32 Cmd_DropLid(struct BerryCrushGame * game,  UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
@@ -1302,37 +1479,37 @@ static u32 BerryCrushCommand_DropLid(struct BerryCrushGame * game,  UNUSED u8 *p
         if (game->depth < 0)
             return 0;
         game->depth = 0;
-        game->spritesManager.unk1 = 4;
-        game->spritesManager.animBerryIdx = 0;
-        game->spritesManager.unk2 = gUnknown_846E2F0[game->spritesManager.unk1][0];
+        game->gfx.vibrationIdx = 4;
+        game->gfx.counter = 0;
+        game->gfx.numVibrations = sIntroOutroVibrationData[game->gfx.vibrationIdx][0];
         PlaySE(SE_M_STRENGTH);
         break;
     case 1:
-        game->vibration = gUnknown_846E2F0[game->spritesManager.unk1][game->spritesManager.animBerryIdx];
+        game->vibration = sIntroOutroVibrationData[game->gfx.vibrationIdx][game->gfx.counter];
         SetGpuReg(REG_OFFSET_BG0VOFS, -game->vibration);
         SetGpuReg(REG_OFFSET_BG2VOFS, -game->vibration);
         SetGpuReg(REG_OFFSET_BG3VOFS, -game->vibration);
-        ++game->spritesManager.animBerryIdx;
-        if (game->spritesManager.animBerryIdx < game->spritesManager.unk2)
+        ++game->gfx.counter;
+        if (game->gfx.counter < game->gfx.numVibrations)
             return 0;
-        if (game->spritesManager.unk1 == 0)
+        if (game->gfx.vibrationIdx == 0)
             break;
-        --game->spritesManager.unk1;
-        game->spritesManager.unk2 = gUnknown_846E2F0[game->spritesManager.unk1][0];
-        game->spritesManager.animBerryIdx = 0;
+        --game->gfx.vibrationIdx;
+        game->gfx.numVibrations = sIntroOutroVibrationData[game->gfx.vibrationIdx][0];
+        game->gfx.counter = 0;
         return 0;
     case 2:
         game->vibration = 0;
         SetGpuReg(REG_OFFSET_BG0VOFS, 0);
         SetGpuReg(REG_OFFSET_BG2VOFS, 0);
         SetGpuReg(REG_OFFSET_BG3VOFS, 0);
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 3:
         if (!IsLinkTaskFinished())
             return 0;
-        BerryCrush_RunOrScheduleCommand(BCCMD_Countdown, 1, NULL);
-        game->gameState = 6;
+        RunOrScheduleCommand(CMD_COUNTDOWN, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_COUNTDOWN;
         game->cmdState = 0;
         return 0;
     }
@@ -1340,12 +1517,12 @@ static u32 BerryCrushCommand_DropLid(struct BerryCrushGame * game,  UNUSED u8 *p
     return 0;
 }
 
-static u32 BerryCrushCommand_Countdown(struct BerryCrushGame * game,  UNUSED u8 *params)
+static u32 Cmd_Countdown(struct BerryCrushGame * game,  UNUSED u8 *args)
 {
     switch (game-> cmdState)
     {
     case 0:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (!IsLinkTaskFinished())
@@ -1355,21 +1532,21 @@ static u32 BerryCrushCommand_Countdown(struct BerryCrushGame * game,  UNUSED u8
     case 2:
         if (IsMinigameCountdownRunning())
             return 0;
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 3:
         if (!IsLinkTaskFinished())
             return 0;
-        game->spritesManager.animBerryIdx = 0;
-        game->spritesManager.unk1 = 0;
-        game->spritesManager.unk2 = 0;
-        game->spritesManager.unk3 = 0;
-        game->unk10 = 0;
+        game->gfx.counter = 0;
+        game->gfx.vibrationIdx = 0;
+        game->gfx.numVibrations = 0;
+        game->gfx.vibrating = FALSE;
+        game->cmdTimer = 0;
         if (game->localId == 0)
-            BerryCrush_RunOrScheduleCommand(BCCMD_PlayGame_Master, 1, NULL);
+            RunOrScheduleCommand(CMD_PLAY_GAME_LEADER, SCHEDULE_CMD, NULL);
         else
-            BerryCrush_RunOrScheduleCommand(BCCMD_PlayGame_Slave, 1, NULL);
-        game->gameState = 7;
+            RunOrScheduleCommand(CMD_PLAY_GAME_MEMBER, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_PLAYING;
         game->cmdState = 0;
         return 0;
     }
@@ -1377,333 +1554,368 @@ static u32 BerryCrushCommand_Countdown(struct BerryCrushGame * game,  UNUSED u8
     return 0;
 }
 
-static void BerryCrush_ProcessGamePartnerInput(struct BerryCrushGame * game)
+static void HandlePartnerInput(struct BerryCrushGame * game)
 {
-    u8 numPressedA = 0;
-    u16 r3;
-    u16 *curRecvCmd;
+    u8 numPlayersPressed = 0;
     u8 i = 0;
-    s32 r2_ = 0;
-    s32 r0;
+    u16 timeDiff;
+    s32 temp = 0;
+    struct BerryCrushGame_LinkState *linkState;
 
     for (i = 0; i < game->playerCount; ++i)
     {
-        curRecvCmd = gRecvCmds[i];
-        if ((curRecvCmd[0] & 0xFF00) == 0x2F00
-            && curRecvCmd[1] == 2)
+        linkState = (struct BerryCrushGame_LinkState *)gRecvCmds[i];
+
+        if ((linkState->rfuCmd & 0xFF00) != RFUCMD_SEND_PACKET)
+            continue;
+        if (linkState->sendFlag != SEND_GAME_STATE)
+            continue;
+
+        if (linkState->pushedAButton)
         {
-            if ((u8)curRecvCmd[2] & 4) // pushedAButton
+            game->localState.playerPressedAFlags |= sBitTable[i];
+            game->players[i].inputState = 1;
+            ++game->players[i].numAPresses;
+            ++numPlayersPressed;
+            timeDiff = game->timer - game->players[i].inputTime;
+
+            // If the interval between inputs is regular, the input is considered "neat"
+            // This counts toward the player's neatness score
+            if (timeDiff >= game->players[i].timeSincePrevInput - 1
+             && timeDiff <= game->players[i].timeSincePrevInput + 1)
             {
-                game->localState.unk02_3 |= gUnknown_846E2E0[i];
-                game->unk98[i].unk1C = 1;
-                ++game->unk98[i].unk16;
-                ++numPressedA;
-                r3 = game->timer - game->unk98[i].unkE;
-                if (r3 >= game->unk98[i].unk12 - 1 && r3 <= game->unk98[i].unk12 + 1)
-                {
-                    ++game->unk98[i].unk10;
-                    game->unk98[i].unk12 = r3;
-                    if (game->unk98[i].unk10 > game->unk98[i].unk14)
-                        game->unk98[i].unk14 = game->unk98[i].unk10;
-                }
-                else
-                {
-                    game->unk98[i].unk10 = 0;
-                    game->unk98[i].unk12 = r3;
-                }
-                game->unk98[i].unkE = game->timer;
-                if (++game->unk98[i].unk1B > 2)
-                    game->unk98[i].unk1B = 0;
+                // On neat input streak
+                ++game->players[i].neatInputStreak;
+                game->players[i].timeSincePrevInput = timeDiff;
+                if (game->players[i].neatInputStreak > game->players[i].maxNeatInputStreak)
+                    game->players[i].maxNeatInputStreak = game->players[i].neatInputStreak;
             }
             else
             {
-                game->unk98[i].unk1C = 0;
+                // End neat input streak
+                game->players[i].neatInputStreak = 0;
+                game->players[i].timeSincePrevInput = timeDiff;
             }
+
+            game->players[i].inputTime = game->timer;
+            ++game->players[i].inputFlags;
+            if (game->players[i].inputFlags > F_INPUT_HIT_B)
+                game->players[i].inputFlags = 0;
         }
-    }
-    if (numPressedA > 1)
-    {
-        for (i = 0; i < game->playerCount; ++i)
+        else
         {
-            if (game->unk98[i].unk1C != 0)
-            {
-                game->unk98[i].unk1C |= 2;
-                ++game->unk98[i].unk18;
-            }
+            game->players[i].inputState = INPUT_STATE_NONE;
         }
     }
-    if (numPressedA != 0)
+    if (numPlayersPressed > 1)
     {
-        game->unk2E += numPressedA;
-        numPressedA += gUnknown_846E2E8[numPressedA - 1];
-        game->unk34 += numPressedA;
-        game->unk1A += numPressedA;
-        r0 = game->unk18;
-        r2_ = game->unk1A;
-        if (r0 - r2_ > 0)
-        {
-            r2_ <<= 8;
-            r2_ = MathUtil_Div32(r2_, game->unk20);
-            r2_ >>= 8;
-            game->unk24 = r2_;
-        }
-        else
+        // For each player that pressed A, flag their input as synchronous
+        // This is used to change their impact sprite to a big impact
+        for (i = 0; i < game->playerCount; ++i)
         {
-            game->unk24 = 32;
-            game->localState.unk02_0 = 1;
+            if (game->players[i].inputState == INPUT_STATE_NONE)
+                continue;
+            game->players[i].inputState |= INPUT_STATE_HIT_SYNC;
+            ++game->players[i].numSyncedAPresses;
         }
     }
+    if (numPlayersPressed == 0)
+        return;
+
+    game->bigSparkleCounter += numPlayersPressed;
+    numPlayersPressed += sSyncPressBonus[numPlayersPressed - 1];
+    game->sparkleCounter += numPlayersPressed;
+    game->totalAPresses += numPlayersPressed;
+    if (game->targetAPresses - game->totalAPresses > 0)
+    {
+        temp = game->totalAPresses;
+        temp = Q_24_8(temp);
+        temp = Q_24_8_div(temp, game->targetDepth);
+        temp = Q_24_8_TO_INT(temp);
+        game->newDepth = (u8)temp;
+        return;
+    }
+
+    // Target number of A presses has been reached, game is complete
+    game->newDepth = 32;
+    game->localState.endGame = TRUE;
 }
 
 static void BerryCrush_BuildLocalState(struct BerryCrushGame * game)
 {
-    u8 count = 0;
+    u8 numPlayersPressed = 0;
     u16 r1 = 0;
     u8 i = 0;
 
     for (i = 0; i < game->playerCount; ++i)
     {
-        if (game->unk98[i].unk1C != 0)
+        if (game->players[i].inputState != 0)
         {
-            ++count;
-            r1 = game->unk98[i].unk1B + 1;
-            if (game->unk98[i].unk1C & 2)
+            ++numPlayersPressed;
+            r1 = game->players[i].inputFlags + 1;
+            if (game->players[i].inputState & 2)
                 r1 |= 4;
             r1 <<= 3 * i;
-            game->localState.unk08 |= r1;
+            game->localState.inputFlags |= r1;
         }
     }
-    game->localState.unk04 = game->unk24;
-    if (count == 0)
+    game->localState.depth = game->newDepth;
+    if (numPlayersPressed == 0)
     {
-        if (game->spritesManager.unk3 != 0)
-            ++game->spritesManager.animBerryIdx;
+        if (game->gfx.vibrating != 0)
+            ++game->gfx.counter;
     }
-    else if (game->spritesManager.unk3 != 0)
+    else if (game->gfx.vibrating != 0)
     {
-        if (count != game->spritesManager.unk1)
+        if (numPlayersPressed != game->gfx.vibrationIdx)
         {
-            game->spritesManager.unk1 = count - 1;
-            game->spritesManager.unk2 = gUnknown_846E314[count - 1][0];
+            game->gfx.vibrationIdx = numPlayersPressed - 1;
+            game->gfx.numVibrations = sVibrationData[numPlayersPressed - 1][0];
         }
         else
         {
-            ++game->spritesManager.animBerryIdx;
+            ++game->gfx.counter;
         }
     }
     else
     {
-        game->spritesManager.animBerryIdx = 0;
-        game->spritesManager.unk1 = count - 1;
-        game->spritesManager.unk2 = gUnknown_846E314[count - 1][0];
-        game->spritesManager.unk3 = 1;
+        game->gfx.counter = 0;
+        game->gfx.vibrationIdx = numPlayersPressed - 1;
+        game->gfx.numVibrations = sVibrationData[numPlayersPressed - 1][0];
+        game->gfx.vibrating = 1;
     }
 
-    if (game->spritesManager.unk3 != 0)
+    if (game->gfx.vibrating != 0)
     {
-        if (game->spritesManager.animBerryIdx >= game->spritesManager.unk2)
+        if (game->gfx.counter >= game->gfx.numVibrations)
         {
-            game->spritesManager.animBerryIdx = 0;
-            game->spritesManager.unk1 = 0;
-            game->spritesManager.unk2 = 0;
-            game->spritesManager.unk3 = 0;
+            game->gfx.counter = 0;
+            game->gfx.vibrationIdx = 0;
+            game->gfx.numVibrations = 0;
+            game->gfx.vibrating = 0;
             r1 = 0;
         }
         else
         {
-            r1 = gUnknown_846E314[game->spritesManager.unk1][game->spritesManager.animBerryIdx + 1];
+            r1 = sVibrationData[game->gfx.vibrationIdx][game->gfx.counter + 1];
         }
-        game->localState.unk03 = r1;
+        game->localState.vibration = r1;
     }
     else
     {
-        game->localState.unk03 = 0;
+        game->localState.vibration = 0;
     }
-    game->localState.unk06 = game->unk26;
+    game->localState.timer = game->leaderTimer;
 }
 
-static void BerryCrush_HandlePlayerInput(struct BerryCrushGame * game)
+static void HandlePlayerInput(struct BerryCrushGame * game)
 {
     if (JOY_NEW(A_BUTTON))
         game->localState.pushedAButton = TRUE;
+
     if (JOY_HELD(A_BUTTON))
     {
-        if (game->unk98[game->localId].unk1A < game->timer)
-            ++game->unk98[game->localId].unk1A;
+        if (game->players[game->localId].timePressingA < game->timer)
+            ++game->players[game->localId].timePressingA;
     }
+
+    // Only send data to other players if you are the leader or you pressed A
     if (game->localId != 0 && !game->localState.pushedAButton)
         return;
-    game->localState.unk00 = 2;
+    game->localState.sendFlag = SEND_GAME_STATE;
+
+    // Every 30 frames, check whether the sparkles produced should be big,
+    // depending on how many A presses there were in that time
     if (game->timer % 30 == 0)
     {
-        if (game->unk2E > gUnknown_846E3C4[game->playerCount - 2])
+        if (game->bigSparkleCounter > sBigSparkleThresholds[game->playerCount - 2])
         {
-            ++game->unk30;
-            game->unk25_4 = 1;
+            ++game->numBigSparkles;
+            game->bigSparkle = TRUE;
         }
         else
         {
-            game->unk25_4 = 0;
+            game->bigSparkle = FALSE;
         }
-        game->unk2E = 0;
-        ++game->unk32;
+        game->bigSparkleCounter = 0;
+        ++game->numBigSparkleChecks;
     }
+
+    // Every 15 frames, update the amount of sparkles that should be produced,
+    // depending on how many A presses there were in that time (including the bonus)
     if (game->timer % 15 == 0)
     {
-        if (game->unk34 < gUnknown_846E3B4[game->playerCount - 2][0])
-            game->unk25_5 = 0;
-        else if (game->unk34 < gUnknown_846E3B4[game->playerCount - 2][1])
-            game->unk25_5 = 1;
-        else if (game->unk34 < gUnknown_846E3B4[game->playerCount - 2][2])
-            game->unk34 = 2; // typo since game->unk34 will be reset?
-        else if (game->unk34 < gUnknown_846E3B4[game->playerCount - 2][3])
-            game->unk34 = 3; // typo since game->unk34 will be reset?
+        // BUG: The wrong field is used twice below
+        // As a result, only a sparkleAmount of 0, 1, or 4 is attainable
+#ifdef BUGFIX
+#define field sparkleAmount
+#else
+#define field sparkleCounter
+#endif
+        if (game->sparkleCounter < sSparkleThresholds[game->playerCount - 2][0])
+            game->sparkleAmount = 0;
+        else if (game->sparkleCounter < sSparkleThresholds[game->playerCount - 2][1])
+            game->sparkleAmount = 1;
+        else if (game->sparkleCounter < sSparkleThresholds[game->playerCount - 2][2])
+            game->field = 2;
+        else if (game->sparkleCounter < sSparkleThresholds[game->playerCount - 2][3])
+            game->field = 3;
         else
-            game->unk25_5 = 4;
-        game->unk34 = 0;
+            game->sparkleAmount = 4;
+        game->sparkleCounter = 0;
+#undef field
     }
     else
     {
-        ++game->unk10;
-        if (game->unk10 > 60)
+        ++game->cmdTimer;
+        if (game->cmdTimer > 60)
         {
-            if (game->unk10 > 70)
+            if (game->cmdTimer > 70)
             {
-                sub_80FBA44();
-                game->unk10 = 0;
+                ClearRecvCommands();
+                game->cmdTimer = 0;
             }
-            else if (game->localState.unk02_3 == 0)
+            else if (game->localState.playerPressedAFlags == 0)
             {
-                sub_80FBA44();
-                game->unk10 = 0;
+                ClearRecvCommands();
+                game->cmdTimer = 0;
             }
         }
 
     }
-    if (game->timer >= 36000)
-        game->localState.unk02_0 = 1;
-    game->localState.unk02_1 = game->unk25_4;
-    game->localState.unk0A = game->unk25_5;
+    if (game->timer >= MAX_TIME)
+        game->localState.endGame = TRUE;
+    game->localState.bigSparkle = game->bigSparkle;
+    game->localState.sparkleAmount = game->sparkleAmount;
     memcpy(&game->sendCmd, &game->localState, sizeof(game->sendCmd));
-    RfuPrepareSend0x2f00(game->sendCmd);
+    Rfu_SendPacket(game->sendCmd);
 }
 
-static void BerryCrush_UpdateGameState(struct BerryCrushGame * game)
+static void RecvLinkData(struct BerryCrushGame * game)
 {
     u8 i = 0;
-    struct BerryCrushGame_4E * r4_ = NULL;
+    struct BerryCrushGame_LinkState * linkState = NULL;
 
     for (i = 0; i < game->playerCount; ++i)
-        game->unk98[i].unk1C = 0;
-    if ((gRecvCmds[0][0] & 0xFF00) != 0x2F00 || gRecvCmds[0][1] != 2)
+        game->players[i].inputState = INPUT_STATE_NONE;
+
+    if ((gRecvCmds[0][0] & 0xFF00) != RFUCMD_SEND_PACKET)
     {
-        game->unk25_2 = 0;
+        game->playedSound = FALSE;
         return;
     }
 
-    memcpy(game->recvCmd, gRecvCmds[0], 14);
-    r4_ = (struct BerryCrushGame_4E *)&game->recvCmd;
-    game->depth = r4_->unk6;
-    game->vibration = r4_->unk5;
-    game->timer = r4_->unk8;
-    sub_814DC5C(game, &game->spritesManager);
-    if (r4_->unk4_0)
-        game->unk25_3 = 1;
+    if (gRecvCmds[0][1] != SEND_GAME_STATE)
+    {
+        game->playedSound = FALSE;
+        return;
+    }
+
+    memcpy(game->recvCmd, gRecvCmds[0], sizeof(game->recvCmd));
+    linkState = (struct BerryCrushGame_LinkState *)&game->recvCmd;
+    game->depth = linkState->depth;
+    game->vibration = linkState->vibration;
+    game->timer = linkState->timer;
+    UpdateInputEffects(game, &game->gfx);
+
+    if (linkState->endGame)
+        game->endGame = TRUE;
 }
 
-static u32 BerryCrushCommand_PlayGame_Master(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_PlayGame_Leader(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     memset(&game->localState, 0, sizeof(game->localState));
     memset(&game->recvCmd, 0, sizeof(game->recvCmd));
-    BerryCrush_UpdateGameState(game);
+    RecvLinkData(game);
     SetGpuReg(REG_OFFSET_BG0VOFS, -game->vibration);
     SetGpuReg(REG_OFFSET_BG2VOFS, -game->vibration);
     SetGpuReg(REG_OFFSET_BG3VOFS, -game->vibration);
-    if (game->unk25_3)
+    if (game->endGame)
     {
-        if (game->timer >= 36000)
+        if (game->timer >= MAX_TIME)
         {
-            game->timer = 36000;
-            BerryCrush_RunOrScheduleCommand(BCCMD_HandleTimeUp, 1, NULL);
+            game->timer = MAX_TIME;
+            RunOrScheduleCommand(CMD_TIMES_UP, SCHEDULE_CMD, NULL);
         }
         else
         {
-            BerryCrush_RunOrScheduleCommand(BCCMD_FinishGame, 1, NULL);
+            RunOrScheduleCommand(CMD_FINISH_GAME, SCHEDULE_CMD, NULL);
         }
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         game->cmdState = 0;
         return 0;
     }
     else
     {
-        ++game->unk26;
-        BerryCrush_ProcessGamePartnerInput(game);
+        ++game->leaderTimer;
+        HandlePartnerInput(game);
         BerryCrush_BuildLocalState(game);
-        BerryCrush_HandlePlayerInput(game);
+        HandlePlayerInput(game);
         return 0;
     }
 }
 
-static u32 BerryCrushCommand_PlayGame_Slave(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_PlayGame_Member(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     memset(&game->localState, 0, sizeof(game->localState));
     memset(&game->recvCmd, 0, sizeof(game->recvCmd));
-    BerryCrush_UpdateGameState(game);
+    RecvLinkData(game);
     SetGpuReg(REG_OFFSET_BG0VOFS, -game->vibration);
     SetGpuReg(REG_OFFSET_BG2VOFS, -game->vibration);
     SetGpuReg(REG_OFFSET_BG3VOFS, -game->vibration);
-    if (game->unk25_3)
+    if (game->endGame)
     {
-        if (game->timer >= 36000)
+        if (game->timer >= MAX_TIME)
         {
-            game->timer = 36000;
-            BerryCrush_RunOrScheduleCommand(BCCMD_HandleTimeUp, 1, NULL);
+            game->timer = MAX_TIME;
+            RunOrScheduleCommand(CMD_TIMES_UP, SCHEDULE_CMD, NULL);
         }
         else
         {
-            BerryCrush_RunOrScheduleCommand(BCCMD_FinishGame, 1, NULL);
+            RunOrScheduleCommand(CMD_FINISH_GAME, SCHEDULE_CMD, NULL);
         }
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         game->cmdState = 0;
         return 0;
     }
     else
     {
-        BerryCrush_HandlePlayerInput(game);
+        HandlePlayerInput(game);
         return 0;
     }
 }
 
-static u32 BerryCrushCommand_FinishGame(struct BerryCrushGame * game, UNUSED u8 *params)
+// Game was 'won', crusher was pushed down fully before time was up
+static u32 Cmd_FinishGame(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        game->gameState = 8;
+        game->gameState = STATE_FINISHED;
         PlaySE(SE_M_STRENGTH);
-        BlendPalettes(0xFFFFFFFF, 8, RGB(31, 31, 0));
-        game->spritesManager.animBerryIdx = 2;
+        BlendPalettes(PALETTES_ALL, 8, RGB(31, 31, 0));
+        game->gfx.counter = 2;
         break;
     case 1:
-        if (--game->spritesManager.animBerryIdx != 255)
+        if (--game->gfx.counter != UINT8_MAX)
             return 0;
-        BlendPalettes(0xFFFFFFFF, 0, RGB(31, 31, 0));
-        game->spritesManager.unk1 = 4;
-        game->spritesManager.animBerryIdx = 0;
-        game->spritesManager.unk2 = gUnknown_846E2F0[game->spritesManager.unk1][0];
+        BlendPalettes(PALETTES_ALL, 0, RGB(31, 31, 0));
+        game->gfx.vibrationIdx = 4;
+        game->gfx.counter = 0;
+        game->gfx.numVibrations = sIntroOutroVibrationData[game->gfx.vibrationIdx][0];
         break;
     case 2:
-        game->vibration = gUnknown_846E2F0[game->spritesManager.unk1][game->spritesManager.animBerryIdx];
+        game->vibration = sIntroOutroVibrationData[game->gfx.vibrationIdx][game->gfx.counter];
         SetGpuReg(REG_OFFSET_BG0VOFS, -game->vibration);
         SetGpuReg(REG_OFFSET_BG2VOFS, -game->vibration);
         SetGpuReg(REG_OFFSET_BG3VOFS, -game->vibration);
-        if (++game->spritesManager.animBerryIdx < game->spritesManager.unk2)
+        if (++game->gfx.counter < game->gfx.numVibrations)
             return 0;
-        if (game->spritesManager.unk1 != 0)
+        if (game->gfx.vibrationIdx != 0)
         {
-            --game->spritesManager.unk1;
-            game->spritesManager.unk2 = gUnknown_846E2F0[game->spritesManager.unk1][0];
-            game->spritesManager.animBerryIdx = 0;
+            --game->gfx.vibrationIdx;
+            game->gfx.numVibrations = sIntroOutroVibrationData[game->gfx.vibrationIdx][0];
+            game->gfx.counter = 0;
             return 0;
         }
         break;
@@ -1714,16 +1926,16 @@ static u32 BerryCrushCommand_FinishGame(struct BerryCrushGame * game, UNUSED u8
         SetGpuReg(REG_OFFSET_BG3VOFS, 0);
         break;
     case 4:
-        if (!sub_814DE50(game, &game->spritesManager))
+        if (!AreEffectsFinished(game, &game->gfx))
             return 0;
-        LinkRfu_SetRfuFuncToSend6600();
-        game->unk10 = 0;
+        Rfu_SetLinkStandbyCallback();
+        game->cmdTimer = 0;
         break;
     case 5:
         if (!IsLinkTaskFinished())
             return 0;
-        BerryCrush_RunOrScheduleCommand(BCCMD_TabulateResults, 1, NULL);
-        game->unk10 = 0;
+        RunOrScheduleCommand(CMD_CALC_RESULTS, SCHEDULE_CMD, NULL);
+        game->cmdTimer = 0;
         game->cmdState = 0;
         return 0;
     }
@@ -1731,27 +1943,27 @@ static u32 BerryCrushCommand_FinishGame(struct BerryCrushGame * game, UNUSED u8
     return 0;
 }
 
-static u32 BerryCrushCommand_HandleTimeUp(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_HandleTimeUp(struct BerryCrushGame * game, u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        game->gameState = 9;
+        game->gameState = STATE_TIMES_UP;
         PlaySE(SE_FAILURE);
-        BlendPalettes(0xFFFFFFFF, 8, RGB(31, 0, 0));
-        game->spritesManager.animBerryIdx = 4;
+        BlendPalettes(PALETTES_ALL, 8, RGB(31, 0, 0));
+        game->gfx.counter = 4;
         break;
     case 1:
-        if (--game->spritesManager.animBerryIdx != 255)
+        if (--game->gfx.counter != UINT8_MAX)
             return 0;
-        BlendPalettes(0xFFFFFFFF, 0, RGB(31, 0, 0));
-        game->spritesManager.animBerryIdx = 0;
+        BlendPalettes(PALETTES_ALL, 0, RGB(31, 0, 0));
+        game->gfx.counter = 0;
         break;
     case 2:
-        if (!sub_814DE50(game, &game->spritesManager))
+        if (!AreEffectsFinished(game, &game->gfx))
             return 0;
-        LinkRfu_SetRfuFuncToSend6600();
-        game->unk10 = 0;
+        Rfu_SetLinkStandbyCallback();
+        game->cmdTimer = 0;
         SetGpuReg(REG_OFFSET_BG0VOFS, 0);
         SetGpuReg(REG_OFFSET_BG2VOFS, 0);
         SetGpuReg(REG_OFFSET_BG3VOFS, 0);
@@ -1760,10 +1972,10 @@ static u32 BerryCrushCommand_HandleTimeUp(struct BerryCrushGame * game, u8 *para
         if (!IsLinkTaskFinished())
             return 0;
         ConvertIntToDecimalStringN(gStringVar1, game->powder, STR_CONV_MODE_LEFT_ALIGN, 6);
-        BerryCrush_SetShowMessageParams(params, BCTEXT_TIMEUP, 1, 0, 0);
-        game->nextCmd = BCCMD_SaveTheGame;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
-        game->unk10 = 0;
+        SetPrintMessageArgs(args, MSG_TIMES_UP, F_MSG_CLEAR, 0, CMD_NONE);
+        game->nextCmd = CMD_SAVE;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
+        game->cmdTimer = 0;
         game->cmdState = 0;
         return 0;
     }
@@ -1771,116 +1983,136 @@ static u32 BerryCrushCommand_HandleTimeUp(struct BerryCrushGame * game, u8 *para
     return 0;
 }
 
-static u32 BerryCrushCommand_TabulateResults(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_TabulateResults(struct BerryCrushGame * game, UNUSED u8 *args)
 {
-    u8 i, j, r3;
-    s32 r2;
-    s32 r4;
-    u16 r6;
+    u8 i, j, tempPlayerId;
+    s32 temp1, temp2;
+    u16 tempStat;
 
     switch (game->cmdState)
     {
     case 0:
         memset(game->sendCmd, 0, 2 * sizeof(u16));
-        if (game->unk98[game->localId].unk1A > game->timer)
-            game->unk98[game->localId].unk1A = game->timer;
-        game->sendCmd[0] = game->unk98[game->localId].unk1A;
+        if (game->players[game->localId].timePressingA > game->timer)
+            game->players[game->localId].timePressingA = game->timer;
+        game->sendCmd[0] = game->players[game->localId].timePressingA;
         SendBlock(0, game->sendCmd, 2);
         break;
     case 1:
         if (!IsLinkTaskFinished())
             return 0;
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         break;
     case 2:
         if (GetBlockReceivedStatus() != sReceivedPlayerBitmasks[game->playerCount - 2])
             return 0;
         for (i = 0; i < game->playerCount; ++i)
-            game->unk98[i].unk1A = gBlockRecvBuffer[i][0];
-        game->unk10 = 0;
+            game->players[i].timePressingA = gBlockRecvBuffer[i][0];
+        game->cmdTimer = 0;
         game->sendCmd[0] = 0;
         ResetBlockReceivedFlags();
+
+        // If player is not leader, skip the steps
+        // where the results are calculated and sent.
+        // Group members just read the results sent
+        // to them by the leader.
         if (game->localId == 0)
             game->cmdState = 3;
         else
             game->cmdState = 6;
         return 0;
     case 3:
-        memset(&game->unk68, 0, sizeof(struct BerryCrushGame_68));
-        game->unk68.unk04 = game->timer;
-        game->unk68.unk06 = game->unk18 / (game->timer / 60);
-        // (unk30 * 50 / unk32) + 50
-        r2 = MathUtil_Mul32(game->unk30 << 8, 50 << 8);
-        r2 = MathUtil_Div32(r2, game->unk32 << 8) + (50 << 8);
-        r2 >>= 8;
-        game->unk68.unk08 = r2 & 0x7F;
-        // powder + playerCount * (r2 / 100)
-        r2 <<= 8;
-        r2 = MathUtil_Div32(r2, 100 << 8);
-        r4 = (game->powder * game->playerCount) << 8;
-        r4 = MathUtil_Mul32(r4, r2);
-        game->unk68.unk00 = r4 >> 8;
-        game->unk68.unk20[0][7] = Random() % 3;
+        memset(&game->results, 0, sizeof(struct BerryCrushGame_Results));
+        game->results.time = game->timer;
+        game->results.targetPressesPerSec = game->targetAPresses / (game->timer / 60);
+
+        // Calculate silkiness
+        // Silkiness is the percentage of times big sparkles were produced when possible,
+        // which itself depends on the number of A presses every 30 frames
+        // (numBigSparkles * 50 / numBigSparkleChecks) + 50
+        temp1 = Q_24_8_mul(Q_24_8(game->numBigSparkles), Q_24_8(50));
+        temp1 = Q_24_8_div(temp1, Q_24_8(game->numBigSparkleChecks)) + Q_24_8(50);
+        temp1 = Q_24_8_TO_INT(temp1);
+        game->results.silkiness = temp1 & 0x7F;
+
+        // Calculate amount of powder
+        temp1 = Q_24_8(temp1);
+        temp1 = Q_24_8_div(temp1, Q_24_8(100));
+        temp2 = Q_24_8(game->powder * game->playerCount);
+        temp2 = Q_24_8_mul(temp2, temp1);
+        game->results.powder = Q_24_8_TO_INT(temp2);
+
+        // Choose random second results page
+        game->results.randomPageId = Random() % NUM_RANDOM_RESULTS_PAGES;
         for (i = 0; i < game->playerCount; ++i)
         {
-            game->unk68.unk20[0][i] = i;
-            game->unk68.unk20[1][i] = i;
-            game->unk68.stats[0][i] = game->unk98[i].unk16;
-            game->unk68.unk0A += game->unk68.stats[0][i];
-            switch (game->unk68.unk20[0][7])
+            game->results.playerIdsRanked[0][i] = i;
+            game->results.playerIdsRanked[1][i] = i;
+            game->results.stats[RESULTS_PAGE_PRESSES][i] = game->players[i].numAPresses;
+            game->results.totalAPresses += game->results.stats[RESULTS_PAGE_PRESSES][i];
+
+            // Calculate value for random second results page
+            switch (game->results.randomPageId)
             {
-            case 0:
-                if (game->unk98[i].unk16 != 0)
+            case RESULTS_PAGE_NEATNESS:
+                if (game->players[i].numAPresses != 0)
                 {
-                    r2 = game->unk98[i].unk14;
-                    r2 <<= 8;
-                    r2 = MathUtil_Mul32(r2, 0x6400);
-                    r4 = game->unk98[i].unk16;
-                    r4 <<= 8;
-                    r4 = MathUtil_Div32(r2, r4);
+                    // Calculate percentage of inputs that were in largest "neat" streak
+                    // "Neat" inputs are those done at a regular interval
+                    temp1 = game->players[i].maxNeatInputStreak;
+                    temp1 = Q_24_8(temp1);
+                    temp1 = Q_24_8_mul(temp1, Q_24_8(100));
+                    temp2 = game->players[i].numAPresses;
+                    temp2 = Q_24_8(temp2);
+                    temp2 = Q_24_8_div(temp1, temp2);
                 }
                 else
                 {
-                    r4 = 0;
+                    temp2 = 0;
                 }
                 break;
-            case 1:
-                if (game->unk98[i].unk16 != 0)
+            case RESULTS_PAGE_COOPERATIVE:
+                if (game->players[i].numAPresses != 0)
                 {
-                    r2 = game->unk98[i].unk18;
-                    r2 <<= 8;
-                    r2 = MathUtil_Mul32(r2, 0x6400);
-                    r4 = game->unk98[i].unk16;
-                    r4 <<= 8;
-                    r4 = MathUtil_Div32(r2, r4);
+                    // Calculate percentage of inputs that were
+                    // done at the same time as another player
+                    temp1 = game->players[i].numSyncedAPresses;
+                    temp1 = Q_24_8(temp1);
+                    temp1 = Q_24_8_mul(temp1, Q_24_8(100));
+                    temp2 = game->players[i].numAPresses;
+                    temp2 = Q_24_8(temp2);
+                    temp2 = Q_24_8_div(temp1, temp2);
                 }
                 else
                 {
-                    r4 = 0;
+                    temp2 = 0;
                 }
                 break;
-            case 2:
-                if (game->unk98[i].unk16 == 0)
+            case RESULTS_PAGE_POWER:
+                if (game->players[i].numAPresses == 0)
                 {
-                    r4 = 0;
+                    temp2 = 0;
                 }
-                else if (game->unk98[i].unk1A >= game->timer)
+                else if (game->players[i].timePressingA >= game->timer)
                 {
-                    r4 = 0x6400;
+                    // Spent 100% of the time pressing A
+                    temp2 = Q_24_8(100);
                 }
                 else
                 {
-                    r2 = game->unk98[i].unk1A;
-                    r2 <<= 8;
-                    r2 = MathUtil_Mul32(r2, 0x6400);
-                    r4 = game->timer;
-                    r4 <<= 8;
-                    r4 = MathUtil_Div32(r2, r4);
+                    // Calculate percentage of time the
+                    // player spent pressing A
+                    temp1 = game->players[i].timePressingA;
+                    temp1 = Q_24_8(temp1);
+                    temp1 = Q_24_8_mul(temp1, Q_24_8(100));
+                    temp2 = game->timer;
+                    temp2 = Q_24_8(temp2);
+                    temp2 = Q_24_8_div(temp1, temp2);
                 }
                 break;
             }
-            r4 >>= 4;
-            game->unk68.stats[1][i] = r4;
+            temp2 >>= 4;
+            game->results.stats[RESULTS_PAGE_RANDOM][i] = temp2;
         }
         break;
     case 4:
@@ -1888,78 +2120,70 @@ static u32 BerryCrushCommand_TabulateResults(struct BerryCrushGame * game, UNUSE
         {
             for (j = game->playerCount - 1; j > i; --j)
             {
-                if (game->unk68.stats[0][j - 1] < game->unk68.stats[0][j])
+                if (game->results.stats[RESULTS_PAGE_PRESSES][j - 1] < game->results.stats[RESULTS_PAGE_PRESSES][j])
                 {
-                    r6 = game->unk68.stats[0][j];
-                    game->unk68.stats[0][j] = game->unk68.stats[0][j - 1];
-                    game->unk68.stats[0][j - 1] = r6;
-                    r3 = game->unk68.unk20[0][j];
-                    game->unk68.unk20[0][j] = game->unk68.unk20[0][j - 1];
-                    game->unk68.unk20[0][j - 1] = r3;
+                    SWAP(game->results.stats[RESULTS_PAGE_PRESSES][j], game->results.stats[RESULTS_PAGE_PRESSES][j - 1], tempStat);
+                    SWAP(game->results.playerIdsRanked[0][j], game->results.playerIdsRanked[0][j - 1], tempPlayerId);
                 }
-                if (game->unk68.stats[1][j - 1] < game->unk68.stats[1][j])
+                if (game->results.stats[RESULTS_PAGE_RANDOM][j - 1] < game->results.stats[RESULTS_PAGE_RANDOM][j])
                 {
-                    r6 = game->unk68.stats[1][j];
-                    game->unk68.stats[1][j] = game->unk68.stats[1][j - 1];
-                    game->unk68.stats[1][j - 1] = r6;
-                    r3 = game->unk68.unk20[1][j];
-                    game->unk68.unk20[1][j] = game->unk68.unk20[1][j - 1];
-                    game->unk68.unk20[1][j - 1] = r3;
+                    SWAP(game->results.stats[RESULTS_PAGE_RANDOM][j], game->results.stats[RESULTS_PAGE_RANDOM][j - 1], tempStat);
+                    SWAP(game->results.playerIdsRanked[1][j], game->results.playerIdsRanked[1][j - 1], tempPlayerId);
                 }
             }
         }
-        SendBlock(0, &game->unk68, sizeof(struct BerryCrushGame_68));
+        SendBlock(0, &game->results, sizeof(struct BerryCrushGame_Results));
         break;
     case 5:
         if (!IsLinkTaskFinished())
             return 0;
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         break;
     case 6:
         if (GetBlockReceivedStatus() != 1)
             return 0;
-        memset(&game->unk68, 0, sizeof(struct BerryCrushGame_68));
-        memcpy(&game->unk68, gBlockRecvBuffer, sizeof(struct BerryCrushGame_68));
+        memset(&game->results, 0, sizeof(struct BerryCrushGame_Results));
+        memcpy(&game->results, gBlockRecvBuffer, sizeof(struct BerryCrushGame_Results));
         ResetBlockReceivedFlags();
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         break;
     case 7:
-        BerryCrush_UpdateSav2Records();
-        BerryCrush_RunOrScheduleCommand(BCCMD_ShowResults, 1, NULL);
-        game->gameState = 11;
+        SaveResults();
+        RunOrScheduleCommand(CMD_SHOW_RESULTS, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_RESULTS_PRESSES;
         game->cmdState = 0;
-        game->unk24 = 0;
+        game->newDepth = 0;
         return 0;
     }
     ++game->cmdState;
     return 0;
 }
 
-static u32 BerryCrushCommand_ShowResults(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_ShowResults(struct BerryCrushGame * game, u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        if (!sub_814E644(game, &game->spritesManager))
+        if (!OpenResultsWindow(game, &game->gfx))
             return 0;
         break;
     case 1:
         CopyBgTilemapBufferToVram(0);
-        game->spritesManager.animBerryIdx = 30;
+        game->gfx.counter = 30;
         break;
     case 2:
-        if (game->spritesManager.animBerryIdx != 0)
+        if (game->gfx.counter != 0)
         {
-            --game->spritesManager.animBerryIdx;
+            --game->gfx.counter;
             return 0;
         }
         if (!JOY_NEW(A_BUTTON))
             return 0;
         PlaySE(SE_SELECT);
-        sub_814E80C(game);
+        CloseResultsWindow(game);
         break;
     case 3:
-        if (game->gameState <= 12)
+        if (game->gameState <= STATE_RESULTS_RANDOM)
         {
             ++game->gameState;
             game->cmdState = 0;
@@ -1969,9 +2193,9 @@ static u32 BerryCrushCommand_ShowResults(struct BerryCrushGame * game, u8 *param
     case 4:
         ConvertIntToDecimalStringN(gStringVar1, game->powder, STR_CONV_MODE_LEFT_ALIGN, 6);
         ConvertIntToDecimalStringN(gStringVar2, GetBerryPowder(), STR_CONV_MODE_LEFT_ALIGN, 6);
-        BerryCrush_SetShowMessageParams(params, BCTEXT_GAINEDPOWDER, 3, 0, 0);
-        game->nextCmd = BCCMD_SaveTheGame;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
+        SetPrintMessageArgs(args, MSG_POWDER, F_MSG_CLEAR | F_MSG_EXPAND, 0, CMD_NONE);
+        game->nextCmd = CMD_SAVE;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
         game->cmdState = 0;
         return 0;
     }
@@ -1979,36 +2203,36 @@ static u32 BerryCrushCommand_ShowResults(struct BerryCrushGame * game, u8 *param
     return 0;
 }
 
-static u32 BerryCrushCommand_SaveTheGame(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_SaveGame(struct BerryCrushGame * game, u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        if (game->timer >= 36000)
-            BerryCrush_HideTimerSprites(&game->spritesManager);
-        BerryCrush_SetShowMessageParams(params, BCTEXT_COMMSTANDBY, 0, 0, BCCMD_BeginNormalPaletteFade);
-        game->nextCmd = BCCMD_SaveTheGame;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
+        if (game->timer >= MAX_TIME)
+            HideTimer(&game->gfx);
+        SetPrintMessageArgs(args, MSG_COMM_STANDBY, 0, 0, CMD_FADE);
+        game->nextCmd = CMD_SAVE;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
         game->cmdState = 0;
         return 0;
     case 1:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 2:
         if (!IsLinkTaskFinished())
             return 0;
         DrawDialogueFrame(0, FALSE);
-        AddTextPrinterParameterized2(0, 2, gText_SavingDontTurnOffThePower2, 0, NULL, 2, 1, 3);
+        AddTextPrinterParameterized2(0, 2, gText_SavingDontTurnOffThePower2, 0, NULL, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
         CopyWindowToVram(0, COPYWIN_BOTH);
-        CreateTask(Task_SaveGame_UpdatedLinkRecords, 0);
+        CreateTask(Task_LinkSave, 0);
         break;
     case 3:
-        if (FuncIsActiveTask(Task_SaveGame_UpdatedLinkRecords))
+        if (FuncIsActiveTask(Task_LinkSave))
             return 0;
         break;
     case 4:
-        BerryCrush_RunOrScheduleCommand(BCCMD_AskPlayAgain, 1, NULL);
-        game->gameState = 15;
+        RunOrScheduleCommand(CMD_ASK_PLAY_AGAIN, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_PLAY_AGAIN;
         game->cmdState = 0;
         return 0;
     }
@@ -2016,41 +2240,41 @@ static u32 BerryCrushCommand_SaveTheGame(struct BerryCrushGame * game, u8 *param
     return 0;
 }
 
-static u32 BerryCrushCommand_AskPlayAgain(struct BerryCrushGame * game, u8 *params)
+static u32 Cmd_AskPlayAgain(struct BerryCrushGame * game, u8 *args)
 {
-    s8 r4 = 0;
+    s8 input = 0;
 
     switch (game->cmdState)
     {
     case 0:
-        BerryCrush_SetShowMessageParams(params, BCTEXT_ASKPLAYAGAIN, 0, 0, BCCMD_BeginNormalPaletteFade);
-        game->nextCmd = BCCMD_AskPlayAgain;
-        BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
-        game->cmdState = 0; // dunno what it's doing because it's already in case 0
+        SetPrintMessageArgs(args, MSG_PLAY_AGAIN, 0, 0, CMD_FADE);
+        game->nextCmd = CMD_ASK_PLAY_AGAIN;
+        RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
+        game->cmdState = 0; // State is progressed by CMD_PRINT_MSG
         return 0;
     case 1:
         DisplayYesNoMenuDefaultYes();
         break;
     case 2:
-        r4 = Menu_ProcessInputNoWrapClearOnChoose();
-        if (r4 != -2)
+        input = Menu_ProcessInputNoWrapClearOnChoose();
+        if (input != LIST_CANCEL)
         {
             memset(game->sendCmd, 0, sizeof(game->sendCmd));
-            if (r4 == 0)
+            if (input == 0)
             {
-                if (CheckHasAtLeastOneBerry())
-                    game->unk14 = 0;
+                if (HasAtLeastOneBerry())
+                    game->playAgainState = PLAY_AGAIN_YES;
                 else
-                    game->unk14 = 3;
+                    game->playAgainState = PLAY_AGAIN_NO_BERRIES;
             }
             else
             {
-                game->unk14 = 1;
+                game->playAgainState = PLAY_AGAIN_NO;
             }
             ClearDialogWindowAndFrame(0, TRUE);
-            BerryCrush_SetShowMessageParams(params, BCTEXT_COMMSTANDBY, 0, 0, 0);
-            game->nextCmd = BCCMD_CommunicatePlayAgainResponses;
-            BerryCrush_RunOrScheduleCommand(BCCMD_PrintMessage, 1, NULL);
+            SetPrintMessageArgs(args, MSG_COMM_STANDBY, 0, 0, CMD_NONE);
+            game->nextCmd = CMD_COMM_PLAY_AGAIN;
+            RunOrScheduleCommand(CMD_PRINT_MSG, SCHEDULE_CMD, NULL);
             game->cmdState = 0;
         }
         return 0;
@@ -2059,40 +2283,46 @@ static u32 BerryCrushCommand_AskPlayAgain(struct BerryCrushGame * game, u8 *para
     return 0;
 }
 
-static u32 BerryCrushCommand_CommunicatePlayAgainResponses(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_CommunicatePlayAgainResponses(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     u8 i = 0;
 
     switch (game->cmdState)
     {
     case 0:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (!IsLinkTaskFinished())
             return 0;
-        game->sendCmd[0] = game->unk14;
+
+        // Send player's Yes/No response to partners
+        game->sendCmd[0] = game->playAgainState;
         game->recvCmd[0] = 0;
         SendBlock(0, game->sendCmd, sizeof(u16));
         break;
     case 2:
         if (!IsLinkTaskFinished())
             return 0;
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         break;
     case 3:
+        // Wait for partners responses
         if (GetBlockReceivedStatus() != sReceivedPlayerBitmasks[game->playerCount - 2])
             return 0;
-        for (; i < game->playerCount; ++i)
+
+        // Read partners responses
+        for (i = 0; i < game->playerCount; ++i)
             game->recvCmd[0] += gBlockRecvBuffer[i][0];
-        if (game->recvCmd[0] != 0)
-            BerryCrush_RunOrScheduleCommand(BCCMD_PlayAgainFailureMessage, 1, NULL);
+
+        if (game->recvCmd[0] != PLAY_AGAIN_YES)
+            RunOrScheduleCommand(CMD_PLAY_AGAIN_NO, SCHEDULE_CMD, NULL);
         else
-            BerryCrush_RunOrScheduleCommand(BCCMD_FadeOutToPlayAgain, 1, NULL);
+            RunOrScheduleCommand(CMD_PLAY_AGAIN_YES, SCHEDULE_CMD, NULL);
         ResetBlockReceivedFlags();
         game->sendCmd[0] = 0;
         game->recvCmd[0] = 0;
-        game->unk10 = 0;
+        game->cmdTimer = 0;
         game->cmdState = 0;
         return 0;
     }
@@ -2100,12 +2330,12 @@ static u32 BerryCrushCommand_CommunicatePlayAgainResponses(struct BerryCrushGame
     return 0;
 }
 
-static u32 BerryCrushCommand_FadeOutToPlayAgain(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_PlayAgain(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        BeginNormalPaletteFade(0xFFFFFFFF, 1, 0, 0x10, RGB_BLACK);
+        BeginNormalPaletteFade(PALETTES_ALL, 1, 0, 0x10, RGB_BLACK);
         UpdatePaletteFade();
         break;
     case 1:
@@ -2114,15 +2344,15 @@ static u32 BerryCrushCommand_FadeOutToPlayAgain(struct BerryCrushGame * game, UN
         break;
     case 2:
         ClearDialogWindowAndFrame(0, TRUE);
-        sub_814DA04(game);
-        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK);
+        ResetCrusherPos(game);
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB_BLACK);
         UpdatePaletteFade();
         break;
     case 3:
         if (UpdatePaletteFade())
             return 0;
-        BerryCrush_RunOrScheduleCommand(BCCMD_AskPickBerry, 1, NULL);
-        game->gameState = 3;
+        RunOrScheduleCommand(CMD_ASK_PICK_BERRY, SCHEDULE_CMD, NULL);
+        game->gameState = STATE_PICK_BERRY;
         game->cmdState = 0;
         return 0;
     }
@@ -2130,29 +2360,29 @@ static u32 BerryCrushCommand_FadeOutToPlayAgain(struct BerryCrushGame * game, UN
     return 0;
 }
 
-static u32 BerryCrushCommand_PlayAgainFailureMessage(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_StopGame(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
         DrawDialogueFrame(0, FALSE);
-        if (game->unk14 == 3)
-            AddTextPrinterParameterized2(0, 2, sBerryCrushMessages[BCTEXT_CANCEL_NOBERRIES], game->textSpeed, NULL, 2, 1, 3);
+        if (game->playAgainState == PLAY_AGAIN_NO_BERRIES)
+            AddTextPrinterParameterized2(0, 2, sMessages[MSG_NO_BERRIES], game->textSpeed, NULL, 2, 1, 3);
         else
-            AddTextPrinterParameterized2(0, 2, sBerryCrushMessages[BCTEXT_CANCEL_DROPPEDOUT], game->textSpeed, NULL, 2, 1, 3);
+            AddTextPrinterParameterized2(0, 2, sMessages[MSG_DROPPED], game->textSpeed, NULL, 2, 1, 3);
         CopyWindowToVram(0, COPYWIN_BOTH);
         break;
     case 1:
         if (IsTextPrinterActive(0))
             return 0;
-        game->spritesManager.animBerryIdx = 120;
+        game->gfx.counter = 120;
         break;
     case 2:
-        if (game->spritesManager.animBerryIdx != 0)
-            --game->spritesManager.animBerryIdx;
+        if (game->gfx.counter != 0)
+            --game->gfx.counter;
         else
         {
-            BerryCrush_RunOrScheduleCommand(BCCMD_GracefulExit, 1, NULL);
+            RunOrScheduleCommand(CMD_CLOSE_LINK, SCHEDULE_CMD, NULL);
             game->cmdState = 0;
         }
         return 0;
@@ -2161,12 +2391,12 @@ static u32 BerryCrushCommand_PlayAgainFailureMessage(struct BerryCrushGame * gam
     return 0;
 }
 
-static u32 BerryCrushCommand_GracefulExit(struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_CloseLink(struct BerryCrushGame * game, UNUSED u8 *args)
 {
     switch (game->cmdState)
     {
     case 0:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (!IsLinkTaskFinished())
@@ -2176,86 +2406,88 @@ static u32 BerryCrushCommand_GracefulExit(struct BerryCrushGame * game, UNUSED u
     case 2:
         if (gReceivedRemoteLinkPlayers)
             return 0;
-        game->nextCmd = BCCMD_Quit;
-        BerryCrush_RunOrScheduleCommand(BCCMD_TeardownGfx, 1, NULL);
-        game->cmdState = 2; // ???
+        game->nextCmd = CMD_QUIT;
+        RunOrScheduleCommand(CMD_HIDE_GAME, SCHEDULE_CMD, NULL);
+        game->cmdState = 2; // State is not progressed
         return 0;
     }
     ++game->cmdState;
     return 0;
 }
 
-static u32 BerryCrushCommand_Quit(UNUSED struct BerryCrushGame * game, UNUSED u8 *params)
+static u32 Cmd_Quit(UNUSED struct BerryCrushGame * game, UNUSED u8 *args)
 {
-    ExitBerryCrushWithCallback(NULL);
+    QuitBerryCrush(NULL);
     return 0;
 }
 
-static void sub_814D4D8(struct BerryCrushGame * game)
+static void ResetGame(struct BerryCrushGame * game)
 {
-    u8 r5 = 0;
+    u8 i = 0;
 
     IncrementGameStat(GAME_STAT_BERRY_CRUSH_POINTS);
-    game->unkD = 0;
-    game->unk10 = 0;
-    game->gameState = 2;
-    game->unk14 = 0;
+    game->unused = 0;
+    game->cmdTimer = 0;
+    game->gameState = STATE_RESET;
+    game->playAgainState = PLAY_AGAIN_YES;
     game->powder = 0;
-    game->unk18 = 0;
-    game->unk1A = 0;
-    game->unk20 = 0;
-    game->unk24 = 0;
-    game->unk25_0 = 0;
-    game->unk25_1 = 0;
-    game->unk25_2 = 0;
-    game->unk25_3 = FALSE;
-    game->unk25_4 = 0;
-    game->unk25_5 = 0;
-    game->unk26 = 0;
+    game->targetAPresses = 0;
+    game->totalAPresses = 0;
+    game->targetDepth = 0;
+    game->newDepth = 0;
+    game->noRoomForPowder = FALSE;
+    game->newRecord = FALSE;
+    game->playedSound = FALSE;
+    game->endGame = FALSE;
+    game->bigSparkle = FALSE;
+    game->sparkleAmount = 0;
+    game->leaderTimer = 0;
     game->timer = 0;
-    game->unk2E = 0;
-    game->unk32 = -1;
-    game->unk30 = 0;
-    game->unk34 = 0;
-    for (; r5 < 5; ++r5)
+    game->bigSparkleCounter = 0;
+    game->numBigSparkleChecks = -1;
+    game->numBigSparkles = 0;
+    game->sparkleCounter = 0;
+    for (i = 0; i < MAX_RFU_PLAYERS; ++i)
     {
-        game->unk98[r5].unkC = -1;
-        game->unk98[r5].unkE = 0;
-        game->unk98[r5].unk10 = 0;
-        game->unk98[r5].unk12 = 1;
-        game->unk98[r5].unk14 = 0;
-        game->unk98[r5].unk16 = 0;
-        game->unk98[r5].unk18 = 0;
-        game->unk98[r5].unk1A = 0;
-        game->unk98[r5].unk1B = 0;
-        game->unk98[r5].unk1C = 0;
+        game->players[i].berryId = -1;
+        game->players[i].inputTime = 0;
+        game->players[i].neatInputStreak = 0;
+        game->players[i].timeSincePrevInput = 1;
+        game->players[i].maxNeatInputStreak = 0;
+        game->players[i].numAPresses = 0;
+        game->players[i].numSyncedAPresses = 0;
+        game->players[i].timePressingA = 0;
+        game->players[i].inputFlags = 0;
+        game->players[i].inputState = INPUT_STATE_NONE;
     }
 }
 
-void BerryCrush_SetPaletteFadeParams(u8 *params, bool8 communicateAfter, u32 selectedPals, s8 delay, u8 startY, u8 targetY, u16 palette)
+static void SetPaletteFadeArgs(u8 *args, bool8 communicateAfter, u32 selectedPals, s8 delay, u8 startY, u8 targetY, u16 palette)
 {
-    params[0] = ((u8 *)&selectedPals)[0];
-    params[1] = ((u8 *)&selectedPals)[1];
-    params[2] = ((u8 *)&selectedPals)[2];
-    params[3] = ((u8 *)&selectedPals)[3];
-    params[4] = delay;
-    params[5] = startY;
-    params[6] = targetY;
-    params[7] = ((u8 *)&palette)[0];
-    params[8] = ((u8 *)&palette)[1];
-    params[9] = communicateAfter;
+    bSelectedPals(0) = ((u8 *)&selectedPals)[0];
+    bSelectedPals(1) = ((u8 *)&selectedPals)[1];
+    bSelectedPals(2) = ((u8 *)&selectedPals)[2];
+    bSelectedPals(3) = ((u8 *)&selectedPals)[3];
+    bDelay = delay;
+    bStartY = startY;
+    bTargetY = targetY;
+    bPalette(0) = ((u8 *)&palette)[0];
+    bPalette(1) = ((u8 *)&palette)[1];
+    bCommunicateAfter = communicateAfter;
 }
 
-void BerryCrush_SetShowMessageParams(u8 *params, u8 stringId, u8 flags, u16 waitKeys, u8 followupCmd)
+static void SetPrintMessageArgs(u8 *args, u8 stringId, u8 flags, u16 waitKeys, u8 followupCmd)
 {
-    params[0] = stringId;
-    params[1] = flags;
-    params[2] = ((u8 *)&waitKeys)[0];
-    params[3] = ((u8 *)&waitKeys)[1];
-    params[4] = followupCmd;
+    bMsgId = stringId;
+    bFlags = flags;
+    bKeys(0) = ((u8 *)&waitKeys)[0];
+    bKeys(1) = ((u8 *)&waitKeys)[1];
+    bNextCmdState = followupCmd;
 }
 
-int BerryCrush_InitBgs(void)
+// GF file break
+
+static s32 ShowGameDisplay(void)
 {
     struct BerryCrushGame * game = GetBerryCrushGame();
     if (game == NULL)
@@ -2283,9 +2515,9 @@ int BerryCrush_InitBgs(void)
     case 3:
         ResetBgsAndClearDma3BusyFlags(FALSE);
         InitBgsFromTemplates(0, sBgTemplates, NELEMS(sBgTemplates));
-        SetBgTilemapBuffer(1, game->spritesManager.bgBuffers[0]);
-        SetBgTilemapBuffer(2, game->spritesManager.bgBuffers[2]);
-        SetBgTilemapBuffer(3, game->spritesManager.bgBuffers[3]);
+        SetBgTilemapBuffer(1, game->gfx.bgBuffers[0]);
+        SetBgTilemapBuffer(2, game->gfx.bgBuffers[2]);
+        SetBgTilemapBuffer(3, game->gfx.bgBuffers[3]);
         ChangeBgX(0, 0, 0);
         ChangeBgY(0, 0, 0);
         ChangeBgX(2, 0, 0);
@@ -2306,24 +2538,24 @@ int BerryCrush_InitBgs(void)
         CopyBgTilemapBufferToVram(1);
         CopyBgTilemapBufferToVram(2);
         CopyBgTilemapBufferToVram(3);
-        DecompressAndCopyTileDataToVram(1, gUnknown_8EAFFC0, 0, 0, 0);
+        DecompressAndCopyTileDataToVram(1, gBerryCrush_Crusher_Gfx, 0, 0, 0);
         break;
     case 6:
         if (FreeTempTileDataBuffersIfPossible())
             return 0;
 
         InitStandardTextBoxWindows();
-        ResetBg0();
-        sub_814EB38(game);
-        sub_814EBB0(game);
+        InitTextBoxGfxAndPrinters();
+        CreatePlayerNameWindows(game);
+        DrawPlayerNameWindows(game);
         gPaletteFade.bufferTransferDisabled = TRUE;
         break;
     case 7:
-        LoadPalette(gUnknown_8EAFEA0, 0, 0x180);
-        CopyToBgTilemapBuffer(1, gBerryCrushGrinderTopTilemap, 0, 0);
-        CopyToBgTilemapBuffer(2, gBerryCrushContainerCapTilemap, 0, 0);
-        CopyToBgTilemapBuffer(3, gBerryCrushBackgroundTilemap, 0, 0);
-        sub_814EC80(game);
+        LoadPalette(gBerryCrush_Crusher_Pal, 0, 0x180);
+        CopyToBgTilemapBuffer(1, sCrusherTop_Tilemap, 0, 0);
+        CopyToBgTilemapBuffer(2, sContainerCap_Tilemap, 0, 0);
+        CopyToBgTilemapBuffer(3, sBg_Tilemap, 0, 0);
+        CopyPlayerNameWindowGfxToBg(game);
         CopyBgTilemapBufferToVram(1);
         CopyBgTilemapBufferToVram(2);
         CopyBgTilemapBufferToVram(3);
@@ -2331,14 +2563,14 @@ int BerryCrush_InitBgs(void)
     case 8:
         LoadWirelessStatusIndicatorSpriteGfx();
         CreateWirelessStatusIndicatorSprite(0,  0);
-        sub_814ECE0(game);
+        CreateGameSprites(game);
         SetGpuReg(REG_OFFSET_BG1VOFS, -gSpriteCoordOffsetY);
         ChangeBgX(1, 0, 0);
         ChangeBgY(1, 0, 0);
         break;
     case 9:
         gPaletteFade.bufferTransferDisabled = FALSE;
-        BlendPalettes(0xFFFFFFFF, 16, RGB_BLACK);
+        BlendPalettes(PALETTES_ALL, 16, RGB_BLACK);
         ShowBg(0);
         ShowBg(1);
         ShowBg(2);
@@ -2353,16 +2585,16 @@ int BerryCrush_InitBgs(void)
     return 0;
 }
 
-int BerryCrush_TeardownBgs(void)
+static s32 HideGameDisplay(void)
 {
-    struct BerryCrushGame * var0 = GetBerryCrushGame();
-    if (!var0)
+    struct BerryCrushGame * game = GetBerryCrushGame();
+    if (!game)
         return -1;
 
-    switch (var0->cmdState)
+    switch (game->cmdState)
     {
     case 0:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         break;
     case 1:
         if (!IsLinkTaskFinished())
@@ -2370,7 +2602,7 @@ int BerryCrush_TeardownBgs(void)
         // fall through. The original author forgot to use "break" here
         // because this will call BeginNormalPaletteFade() twice.
     case 2:
-        BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK);
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB_BLACK);
         UpdatePaletteFade();
         break;
     case 3:
@@ -2401,47 +2633,62 @@ int BerryCrush_TeardownBgs(void)
         break;
     case 6:
         DestroyWirelessStatusIndicatorSprite();
-        sub_814EF10(var0);
-        DigitObjUtil_Teardown();
+        DestroyGameSprites(game);
+        DigitObjUtil_Free();
         break;
     case 7:
-        var0->cmdState = 0;
+        game->cmdState = 0;
         return 1;
     }
 
-    var0->cmdState++;
+    game->cmdState++;
     return 0;
 }
 
-int sub_814D9CC(struct BerryCrushGame * game)
+static s32 UpdateGame(struct BerryCrushGame * game)
 {
     gSpriteCoordOffsetY = game->depth + game->vibration;
     SetGpuReg(REG_OFFSET_BG1VOFS, -gSpriteCoordOffsetY);
-    if (game->gameState == 7)
+    if (game->gameState == STATE_PLAYING)
     {
-        BerryCrush_PrintTimeOnSprites(&game->spritesManager, game->timer);
+        PrintTimer(&game->gfx, game->timer);
     }
 
     return 0;
 }
 
-void sub_814DA04(struct BerryCrushGame * game)
+static void ResetCrusherPos(struct BerryCrushGame * game)
 {
-    game->depth = -104;
+    game->depth = CRUSHER_START_Y;
     game->vibration = 0;
     gSpriteCoordOffsetX = 0;
-    gSpriteCoordOffsetY = -104;
-}
-
-void BerryCrush_CreateBerrySprites(struct BerryCrushGame * game, struct BerryCrushGame_138 * spritesManager)
+    gSpriteCoordOffsetY = CRUSHER_START_Y;
+}
+
+// Sprite data for berry sprites. Identical to fields for sparkle sprites
+#define sX         data[0]
+#define sYSpeed    data[1]
+#define sYAccel    data[2]
+#define sXSpeed    data[3]
+#define sSinIdx    data[4]
+#define sSinSpeed  data[5]
+#define sAmplitude data[6]
+// The last element (data[7]) is a bitfield.
+// The first 15 bits are the y coord to stop at.
+// The last bit is a flag for whether or not to move horizontally too
+#define sBitfield  data[7]
+#define MASK_TARGET_Y 0x7FFF
+#define F_MOVE_HORIZ  0x8000
+
+static void CreateBerrySprites(struct BerryCrushGame * game, struct BerryCrushGame_Gfx * spritesManager)
 {
     u8 i;
     u8 spriteId;
-    s16 var0, var1;
+    s16 distance, var1;
     s16 *data;
-    int var3;
-    s16 var5;
-    u32 var6;
+    s32 amplitude;
+    s16 speed;
+    u32 var2;
 
     for (i = 0; i < game->playerCount; i++)
     {
@@ -2449,58 +2696,58 @@ void BerryCrush_CreateBerrySprites(struct BerryCrushGame * game, struct BerryCru
             &sSpriteTemplate_PlayerBerry,
             sPlayerBerrySpriteTags[i],
             sPlayerBerrySpriteTags[i],
-            game->unk98[i].unkC + FIRST_BERRY_INDEX);
+            game->players[i].berryId + FIRST_BERRY_INDEX);
         spritesManager->berrySprites[i] = &gSprites[spriteId];
         spritesManager->berrySprites[i]->oam.priority = 3;
         spritesManager->berrySprites[i]->affineAnimPaused = TRUE;
-        spritesManager->berrySprites[i]->pos1.x = spritesManager->seatCoords[i]->unk8 + 120;
+        spritesManager->berrySprites[i]->pos1.x = spritesManager->playerCoords[i]->berryXOffset + 120;
         spritesManager->berrySprites[i]->pos1.y = -16;
         data = spritesManager->berrySprites[i]->data;
-        var5 = 512;
-        data[1] = var5;
-        data[2] = 32;
-        data[7] = 112;
-        var0 = spritesManager->seatCoords[i]->unkA - spritesManager->seatCoords[i]->unk8;
-        var3 = var0;
-        if (var0 < 0)
-            var3 += 3;
-
-        data[6] = var3 >> 2;
-        var0 *= 128;
-        var6 = var5 + 32;
-        var6 = var6 / 2;
-        var1 = MathUtil_Div16Shift(7, 0x3F80, var6);
-        data[0] = (u16)spritesManager->berrySprites[i]->pos1.x * 128;
-        data[3] = MathUtil_Div16Shift(7, var0, var1);
-        var1 = MathUtil_Mul16Shift(7, var1, 85);
-        data[4] = 0;
-        data[5] = MathUtil_Div16Shift(7, 0x3F80, var1);
-        data[7] |= 0x8000;
-        if (spritesManager->seatCoords[i]->unk8 < 0)
+        speed = Q_8_8(2.0);
+        sYSpeed = speed;
+        sYAccel = Q_8_8(0.125);
+        sBitfield = 112; // Setting bits in MASK_TARGET_Y
+        distance = spritesManager->playerCoords[i]->berryXDest - spritesManager->playerCoords[i]->berryXOffset;
+        amplitude = distance;
+        if (distance < 0)
+            amplitude += 3;
+
+        sAmplitude = amplitude >> 2;
+        distance = Q_N_S(7, distance);
+        var2 = speed + Q_8_8(0.125);
+        var2 = var2 / 2; // go from Q8.8 to Q9.7
+        var1 = Q_N_S_div(7, Q_N_S(7, 127), var2);
+        sX = Q_N_S(7, (u16)spritesManager->berrySprites[i]->pos1.x);
+        sXSpeed = Q_N_S_div(7, distance, var1);
+        var1 = Q_N_S_mul(7, var1, Q_N_S(7, 0.666666667));
+        sSinIdx = 0;
+        sSinSpeed = Q_N_S_div(7, Q_N_S(7, 127), var1);
+        sBitfield |= F_MOVE_HORIZ;
+        if (spritesManager->playerCoords[i]->berryXOffset < 0)
             StartSpriteAffineAnim(spritesManager->berrySprites[i], 1);
     }
 }
 
-void SpriteCB_DropBerryIntoCrusher(struct Sprite * sprite)
+static void SpriteCB_DropBerryIntoCrusher(struct Sprite * sprite)
 {
     s16 *data = sprite->data;
 
-    data[1] += data[2];
-    sprite->pos2.y += data[1] >> 8;
-    if (data[7] & 0x8000)
+    sYSpeed += sYAccel;
+    sprite->pos2.y += Q_8_8_TO_INT(sYSpeed);
+    if (sBitfield & F_MOVE_HORIZ)
     {
-        sprite->data[0] += data[3];
-        data[4] += data[5];
-        sprite->pos2.x = Sin(data[4] >> 7, data[6]);
-        if ((data[7] & 0x8000) && (data[4] >> 7) > 126)
+        sprite->sX += sXSpeed;
+        sSinIdx += sSinSpeed;
+        sprite->pos2.x = Sin(Q_N_S_TO_INT(7, sSinIdx), sAmplitude);
+        if ((sBitfield & F_MOVE_HORIZ) && Q_N_S_TO_INT(7, sSinIdx) > 126)
         {
             sprite->pos2.x = 0;
-            data[7] &= 0x7FFF;
+            sBitfield &= MASK_TARGET_Y;
         }
     }
 
-    sprite->pos1.x = data[0] >> 7;
-    if (sprite->pos1.y + sprite->pos2.y >= (data[7] & 0x7FFF))
+    sprite->pos1.x = Q_N_S_TO_INT(7, sX);
+    if (sprite->pos1.y + sprite->pos2.y >= (sBitfield & MASK_TARGET_Y))
     {
         sprite->callback = SpriteCallbackDummy;
         FreeSpriteOamMatrix(sprite);
@@ -2508,127 +2755,143 @@ void SpriteCB_DropBerryIntoCrusher(struct Sprite * sprite)
     }
 }
 
-void BerryCrushFreeBerrySpriteGfx(struct BerryCrushGame * arg0, UNUSED struct BerryCrushGame_138 * arg1)
+#undef sX
+#undef sYSpeed
+#undef sYAccel
+#undef sXSpeed
+#undef sSinIdx
+#undef sSinSpeed
+#undef sAmplitude
+#undef sBitfield
+#undef MASK_TARGET_Y
+#undef F_MOVE_HORIZ
+
+static void BerryCrushFreeBerrySpriteGfx(struct BerryCrushGame * game, UNUSED struct BerryCrushGame_Gfx * gfx)
 {
     u8 i;
-    for (i = 0; i < arg0->playerCount; i++)
+    for (i = 0; i < game->playerCount; i++)
     {
         FreeSpritePaletteByTag(sPlayerBerrySpriteTags[i]);
         FreeSpriteTilesByTag(sPlayerBerrySpriteTags[i]);
     }
 }
 
-void sub_814DC5C(struct BerryCrushGame * game, struct BerryCrushGame_138 * manager)
+static void UpdateInputEffects(struct BerryCrushGame * game, struct BerryCrushGame_Gfx * gfx)
 {
-    u8 sp4;
-    struct BerryCrushGame_4E * var4E;
+    u8 numPlayersPressed;
+    struct BerryCrushGame_LinkState * linkState;
     u8 i;
-    u16 var, var2;
+    u16 temp1, xModifier;
 
-    sp4 = 0;
-    var4E = (struct BerryCrushGame_4E *)&game->recvCmd;
+    numPlayersPressed = 0;
+    linkState = (struct BerryCrushGame_LinkState *)&game->recvCmd;
     for (i = 0; i < game->playerCount; i++)
     {
-        var = var4E->unkA >> (i * 3);
-        var &= 7;
-        if (var)
+#define flags temp1
+        flags = linkState->inputFlags >> (i * INPUT_FLAGS_PER_PLAYER);
+        flags &= INPUT_FLAG_MASK;
+        if (flags)
         {
-            sp4++;
-            if (var & 0x4)
-                StartSpriteAnim(manager->impactSprites[i], 1);
+            numPlayersPressed++;
+            if (flags & F_INPUT_HIT_SYNC)
+                StartSpriteAnim(gfx->impactSprites[i], 1);
             else
-                StartSpriteAnim(manager->impactSprites[i], 0);
+                StartSpriteAnim(gfx->impactSprites[i], 0);
 
-            manager->impactSprites[i]->invisible = FALSE;
-            manager->impactSprites[i]->animPaused = FALSE;
-            manager->impactSprites[i]->pos2.x = gUnknown_846F2D0[(var % 4) - 1][0];
-            manager->impactSprites[i]->pos2.y = gUnknown_846F2D0[(var % 4) - 1][1];
+            gfx->impactSprites[i]->invisible = FALSE;
+            gfx->impactSprites[i]->animPaused = FALSE;
+            gfx->impactSprites[i]->pos2.x = sImpactCoords[(flags % (NELEMS(sImpactCoords) + 1)) - 1][0];
+            gfx->impactSprites[i]->pos2.y = sImpactCoords[(flags % (NELEMS(sImpactCoords) + 1)) - 1][1];
+#undef flags
         }
     }
 
-    if (sp4 == 0)
+    if (numPlayersPressed == 0)
     {
-        game->unk25_2 = 0;
+        game->playedSound = FALSE;
     }
     else
     {
-        var = (u8)(game->timer % 3);
-        var2 = var;
-        for (i = 0; i < var4E->unkC * 2 + 3; i++)
+#define yModifier temp1
+        yModifier = (u8)(game->timer % 3);
+        xModifier = yModifier;
+        for (i = 0; i < linkState->sparkleAmount * 2 + 3; i++)
         {
-            if (manager->sparkleSprites[i]->invisible)
+            if (gfx->sparkleSprites[i]->invisible)
             {
-                manager->sparkleSprites[i]->callback = sub_814F0D8;
-                manager->sparkleSprites[i]->pos1.x = gUnknown_846F2D6[i][0] + 120;
-                manager->sparkleSprites[i]->pos1.y = gUnknown_846F2D6[i][1] + 136 - (var * 4);
-                manager->sparkleSprites[i]->pos2.x = gUnknown_846F2D6[i][0] + (gUnknown_846F2D6[i][0] / (var2 * 4));
-                manager->sparkleSprites[i]->pos2.y = gUnknown_846F2D6[i][1];
-                if (var4E->unk4_1)
-                    StartSpriteAnim(manager->sparkleSprites[i], 1);
+                gfx->sparkleSprites[i]->callback = SpriteCB_Sparkle_Init;
+                gfx->sparkleSprites[i]->pos1.x = sSparkleCoords[i][0] + 120;
+                gfx->sparkleSprites[i]->pos1.y = sSparkleCoords[i][1] + 136 - (yModifier * 4);
+                gfx->sparkleSprites[i]->pos2.x = sSparkleCoords[i][0] + (sSparkleCoords[i][0] / (xModifier * 4));
+                gfx->sparkleSprites[i]->pos2.y = sSparkleCoords[i][1];
+                if (linkState->bigSparkle)
+                    StartSpriteAnim(gfx->sparkleSprites[i], 1);
                 else
-                    StartSpriteAnim(manager->sparkleSprites[i], 0);
+                    StartSpriteAnim(gfx->sparkleSprites[i], 0);
 
-                var++;
-                if (var > 3)
-                    var = 0;
+                yModifier++;
+                if (yModifier > 3)
+                    yModifier = 0;
             }
         }
 
-        if (game->unk25_2)
+#undef yModifier
+
+        if (game->playedSound)
         {
-            game->unk25_2 = 0;
+            game->playedSound = FALSE;
         }
         else
         {
-            if (sp4 == 1)
+            if (numPlayersPressed == 1)
                 PlaySE(SE_MUD_BALL);
             else
                 PlaySE(SE_BREAKABLE_DOOR);
 
-            game->unk25_2 = 1;
+            game->playedSound = TRUE;
         }
     }
 }
 
-bool32 sub_814DE50(struct BerryCrushGame * arg0, struct BerryCrushGame_138 * arg1)
+static bool32 AreEffectsFinished(struct BerryCrushGame * game, struct BerryCrushGame_Gfx * gfx)
 {
     u8 i;
 
-    for (i = 0; i < arg0->playerCount; i++)
+    for (i = 0; i < game->playerCount; i++)
     {
-        if (!arg1->impactSprites[i]->invisible)
+        if (!gfx->impactSprites[i]->invisible)
             return FALSE;
     }
 
-    for (i = 0; i < 11; i++)
+    for (i = 0; i < NELEMS(gfx->sparkleSprites); i++)
     {
-        if (!arg1->sparkleSprites[i]->invisible)
+        if (!gfx->sparkleSprites[i]->invisible)
             return FALSE;
     }
 
-    if (arg0->vibration != 0)
-        arg0->vibration = 0;
+    if (game->vibration != 0)
+        game->vibration = 0;
 
     return TRUE;
 }
 
-static void FramesToMinSec(struct BerryCrushGame_138 * manager, u16 frames)
+static void FramesToMinSec(struct BerryCrushGame_Gfx * gfx, u16 frames)
 {
     u8 i = 0;
     u32 fractionalFrames = 0;
-    s16 r3 = 0;
+    s16 frac_secs = 0;
 
-    manager->minutes = frames / 3600;
-    manager->secondsInt = (frames % 3600) / 60;
-    r3 = MathUtil_Mul16((frames % 60) << 8, 4);
+    gfx->minutes = frames / 3600;
+    gfx->secondsInt = (frames % 3600) / 60;
+    frac_secs = Q_8_8_mul(Q_8_8(frames % 60), Q_8_8(0.016666667));
 
     for (i = 0; i < 8; i++)
     {
-        if ((r3 >> (7 - i)) & 1)
+        if ((frac_secs >> (7 - i)) & 1)
             fractionalFrames += sPressingSpeedConversionTable[i];
     }
 
-    manager->secondsFrac = fractionalFrames / 1000000;
+    gfx->secondsFrac = fractionalFrames / 1000000;
 }
 
 static void PrintTextCentered(u8 windowId, u8 left, u8 colorId, const u8 *string)
@@ -2637,7 +2900,7 @@ static void PrintTextCentered(u8 windowId, u8 left, u8 colorId, const u8 *string
     AddTextPrinterParameterized3(windowId, 2, left, 0, sBerryCrushTextColorTable[colorId], 0, string);
 }
 
-static void PrintBerryCrushResultWindow(struct BerryCrushGame * game, u8 command, u8 x, u8 y)
+static void PrintResultsText(struct BerryCrushGame * game, u8 command, u8 x, u8 y)
 {
     u8 i = 0;
     u8 linkPlayerId = 0;
@@ -2645,27 +2908,27 @@ static void PrintBerryCrushResultWindow(struct BerryCrushGame * game, u8 command
     u8 j;
     s32 score;
     u8 realX;
-    struct BerryCrushGame_68 * bcPlayers = &game->unk68;
+    struct BerryCrushGame_Results * bcPlayers = &game->results;
     s32 realX2;
 
-    for (; i < game->playerCount; i++)
+    for (i = 0; i < game->playerCount; i++)
     {
         DynamicPlaceholderTextUtil_Reset();
         switch (command)
         {
-        case 0:
+        case RESULTS_PAGE_PRESSES:
             // Number of presses
-            linkPlayerId = bcPlayers->unk20[command][i];
+            linkPlayerId = bcPlayers->playerIdsRanked[command][i];
             if (i != 0 && bcPlayers->stats[command][i] != bcPlayers->stats[command][i - 1])
                 linkIdToPrint = i;
             ConvertIntToDecimalStringN(gStringVar1, bcPlayers->stats[command][i], STR_CONV_MODE_RIGHT_ALIGN, 4);
             realX = x - GetStringWidth(2, sBCRankingHeaders[command], -1) - 4;
-            AddTextPrinterParameterized3(game->spritesManager.unk82, 2, realX, y + 14 * i, sBerryCrushTextColorTable[0], 0, sBCRankingHeaders[command]);
-            AddTextPrinterParameterized3(game->spritesManager.unk82, 2, realX - 24, y + 14 * i, sBerryCrushTextColorTable[0], 0, gStringVar1);
+            AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, realX, y + 14 * i, sBerryCrushTextColorTable[COLORID_GRAY], 0, sBCRankingHeaders[command]);
+            AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, realX - 24, y + 14 * i, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar1);
             break;
-        case 1:
+        case RESULTS_PAGE_RANDOM:
             // Neatness
-            linkPlayerId = bcPlayers->unk20[command][i];
+            linkPlayerId = bcPlayers->playerIdsRanked[command][i];
             if (i != 0 && bcPlayers->stats[command][i] != bcPlayers->stats[command][i - 1])
                 linkIdToPrint = i;
             ConvertIntToDecimalStringN(gStringVar1, bcPlayers->stats[command][i] >> 4, STR_CONV_MODE_RIGHT_ALIGN, 3);
@@ -2680,18 +2943,18 @@ static void PrintBerryCrushResultWindow(struct BerryCrushGame * game, u8 command
             ConvertIntToDecimalStringN(gStringVar2, realX, STR_CONV_MODE_LEADING_ZEROS, 2);
             StringExpandPlaceholders(gStringVar4, sBCRankingHeaders[command]);
             realX2 = x - 4;
-            AddTextPrinterParameterized3(game->spritesManager.unk82, 2, realX2 - GetStringWidth(2, gStringVar4, 0), y + 14 * i, sBerryCrushTextColorTable[0], 0, gStringVar4);
+            AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, realX2 - GetStringWidth(2, gStringVar4, 0), y + 14 * i, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
             break;
-        case 2:
+        case RESULTS_PAGE_CRUSHING:
             // Berry names
             linkPlayerId = i;
             linkIdToPrint = i;
-            j = game->unk98[i].unkC;
+            j = game->players[i].berryId;
             if (j >= LAST_BERRY_INDEX - FIRST_BERRY_INDEX + 2)
                 j = 0;
             StringCopy(gStringVar1, gBerries[j].name);
             StringExpandPlaceholders(gStringVar4, sBCRankingHeaders[command]);
-            AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x - GetStringWidth(2, gStringVar4, -1) - 4, y + 14 * i, sBerryCrushTextColorTable[0], 0, gStringVar4);
+            AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x - GetStringWidth(2, gStringVar4, -1) - 4, y + 14 * i, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
             break;
         }
         if (linkPlayerId == game->localId)
@@ -2699,45 +2962,45 @@ static void PrintBerryCrushResultWindow(struct BerryCrushGame * game, u8 command
         else
             StringCopy(gStringVar3, gText_1_Dynamic0);
         gStringVar3[0] = linkIdToPrint + CHAR_1;
-        DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, game->unk98[linkPlayerId].unk0);
+        DynamicPlaceholderTextUtil_SetPlaceholderPtr(0, game->players[linkPlayerId].name);
         DynamicPlaceholderTextUtil_ExpandPlaceholders(gStringVar4, gStringVar3);
-        AddTextPrinterParameterized3(game->spritesManager.unk82, 2, 4, y + 14 * i, sBerryCrushTextColorTable[0], 0, gStringVar4);
+        AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, 4, y + 14 * i, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
     }
 }
 
-static void sub_814E32C(struct BerryCrushGame * game)
+static void printCrushingResults(struct BerryCrushGame * game)
 {
     u8 i = 0;
     u8 x = 0;
     u32 score = 0;
-    struct BerryCrushGame_68 *players = &game->unk68;
-    u8 y = GetWindowAttribute(game->spritesManager.unk82, WINDOW_HEIGHT) * 8 - 42;
+    struct BerryCrushGame_Results *players = &game->results;
+    u8 y = GetWindowAttribute(game->gfx.resultsWindowId, WINDOW_HEIGHT) * 8 - 42;
 
-    FramesToMinSec(&game->spritesManager, players->unk04);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, 2, y, sBerryCrushTextColorTable[0], 0, gText_TimeColon);
+    FramesToMinSec(&game->gfx, players->time);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, 2, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_TimeColon);
 
     x = 190 - (u8)GetStringWidth(2, gText_SpaceSec, 0);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gText_SpaceSec);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_SpaceSec);
 
     x -= 32;
-    ConvertIntToDecimalStringN(gStringVar1, game->spritesManager.secondsInt, STR_CONV_MODE_LEADING_ZEROS, 2);
-    ConvertIntToDecimalStringN(gStringVar2, game->spritesManager.secondsFrac, STR_CONV_MODE_LEADING_ZEROS, 2);
+    ConvertIntToDecimalStringN(gStringVar1, game->gfx.secondsInt, STR_CONV_MODE_LEADING_ZEROS, 2);
+    ConvertIntToDecimalStringN(gStringVar2, game->gfx.secondsFrac, STR_CONV_MODE_LEADING_ZEROS, 2);
     StringExpandPlaceholders(gStringVar4, gText_XDotY2);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gStringVar4);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
 
     x -= (u8)GetStringWidth(2, gText_SpaceMin, 0) + 3;
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gText_SpaceMin);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_SpaceMin);
 
     x -= 9;
-    ConvertIntToDecimalStringN(gStringVar1, game->spritesManager.minutes, STR_CONV_MODE_LEADING_ZEROS, 1);
+    ConvertIntToDecimalStringN(gStringVar1, game->gfx.minutes, STR_CONV_MODE_LEADING_ZEROS, 1);
     StringExpandPlaceholders(gStringVar4, gText_StrVar1);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gStringVar4);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
 
     y += 14;
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, 2, y, sBerryCrushTextColorTable[0], 0, gText_PressingSpeed);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, 2, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_PressingSpeed);
 
     x = 190 - (u8)GetStringWidth(2, gText_TimesPerSec, 0);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 3, x, y, sBerryCrushTextColorTable[0], 0, gText_TimesPerSec);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 3, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_TimesPerSec);
 
     for (i = 0; i < 8; ++i)
         if (((u8)game->pressingSpeed >> (7 - i)) & 1)
@@ -2746,84 +3009,89 @@ static void sub_814E32C(struct BerryCrushGame * game)
     ConvertIntToDecimalStringN(gStringVar2, score / 1000000, STR_CONV_MODE_LEADING_ZEROS, 2);
     StringExpandPlaceholders(gStringVar4, gText_XDotY3);
     x -= 38;
-    if (game->unk25_1)
-        AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[5], 0, gStringVar4);
+    if (game->newRecord)
+        AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_RED], 0, gStringVar4);
     else
-        AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gStringVar4);
+        AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
 
     y += 14;
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, 2, y, sBerryCrushTextColorTable[0], 0, gText_Silkiness);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, 2, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gText_Silkiness);
 
-    ConvertIntToDecimalStringN(gStringVar1, players->unk08, STR_CONV_MODE_RIGHT_ALIGN, 3);
+    ConvertIntToDecimalStringN(gStringVar1, players->silkiness, STR_CONV_MODE_RIGHT_ALIGN, 3);
     StringExpandPlaceholders(gStringVar4, gText_Var1Percent);
     x = 190 - (u8)GetStringWidth(2, gStringVar4, 0);
-    AddTextPrinterParameterized3(game->spritesManager.unk82, 2, x, y, sBerryCrushTextColorTable[0], 0, gStringVar4);
+    AddTextPrinterParameterized3(game->gfx.resultsWindowId, 2, x, y, sBerryCrushTextColorTable[COLORID_GRAY], 0, gStringVar4);
 }
 
-bool32 sub_814E644(struct BerryCrushGame * game, struct BerryCrushGame_138 * spriteManager)
+static bool32 OpenResultsWindow(struct BerryCrushGame * game, struct BerryCrushGame_Gfx * spriteManager)
 {
     u8 playerCountMinus2;
     struct WindowTemplate template;
 
-    switch (spriteManager->unk80)
+    switch (spriteManager->resultsState)
     {
     case 0:
         playerCountMinus2 = game->playerCount - 2;
-        BerryCrush_HideTimerSprites(spriteManager);
-        memcpy(&template, &gUnknown_846E428[game->gameState - 11], sizeof(struct WindowTemplate));
-        if (game->gameState == 13)
-            template.height = gUnknown_846E448[1][playerCountMinus2];
+        HideTimer(spriteManager);
+//        template = sWindowTemplates_Results[game->gameState - STATE_RESULTS_PRESSES];
+        memcpy(&template, &sWindowTemplates_Results[game->gameState - STATE_RESULTS_PRESSES], sizeof(struct WindowTemplate));
+        if (game->gameState == STATE_RESULTS_CRUSHING)
+            template.height = sResultsWindowHeights[1][playerCountMinus2];
         else
-            template.height = gUnknown_846E448[0][playerCountMinus2];
-        spriteManager->unk82 = AddWindow(&template);
+            template.height = sResultsWindowHeights[0][playerCountMinus2];
+        spriteManager->resultsWindowId = AddWindow(&template);
         break;
     case 1:
-        PutWindowTilemap(spriteManager->unk82);
-        FillWindowPixelBuffer(spriteManager->unk82, PIXEL_FILL(0));
+        PutWindowTilemap(spriteManager->resultsWindowId);
+        FillWindowPixelBuffer(spriteManager->resultsWindowId, PIXEL_FILL(0));
         break;
     case 2:
-        TextWindow_SetStdFrame0_WithPal(spriteManager->unk82, 0x21D, 0xD0);
-        DrawStdFrameWithCustomTileAndPalette(spriteManager->unk82, FALSE, 541, 13);
+        TextWindow_SetStdFrame0_WithPal(spriteManager->resultsWindowId, 0x21D, 0xD0);
+        DrawStdFrameWithCustomTileAndPalette(spriteManager->resultsWindowId, FALSE, 541, 13);
         break;
     case 3:
         playerCountMinus2 = game->playerCount - 2;
         switch (game->gameState)
         {
-        case 11:
-            PrintTextCentered(spriteManager->unk82, 22, 3, gText_PressesRankings);
-            PrintBerryCrushResultWindow(game, 0, 0xB0, 8 * gUnknown_846E448[0][playerCountMinus2] - game->playerCount * 14);
-            spriteManager->unk80 = 5;
+        case STATE_RESULTS_PRESSES:
+            PrintTextCentered(spriteManager->resultsWindowId, 22, COLORID_BLUE, gText_PressesRankings);
+            PrintResultsText(game, RESULTS_PAGE_PRESSES, 0xB0, 8 * sResultsWindowHeights[0][playerCountMinus2] - game->playerCount * 14);
+            spriteManager->resultsState = 5;
             return FALSE;
-        case 12:
-            PrintTextCentered(spriteManager->unk82, 22, 4, sBCRankingHeaders[game->unk68.unk20[0][7] + 3]);
-            PrintBerryCrushResultWindow(game, 1, 0xB0, 8 * gUnknown_846E448[0][playerCountMinus2] - game->playerCount * 14);
-            spriteManager->unk80 = 5;
+        case STATE_RESULTS_RANDOM:
+            PrintTextCentered(spriteManager->resultsWindowId, 22, COLORID_GREEN, sBCRankingHeaders[game->results.randomPageId + 3]);
+            PrintResultsText(game, RESULTS_PAGE_RANDOM, 0xB0, 8 * sResultsWindowHeights[0][playerCountMinus2] - game->playerCount * 14);
+            spriteManager->resultsState = 5;
             return FALSE;
-        case 13:
-            PrintTextCentered(spriteManager->unk82, 24, 3, gText_CrushingResults);
-            PrintBerryCrushResultWindow(game, 2, 0xC0, 0x10);
+        case STATE_RESULTS_CRUSHING:
+            PrintTextCentered(spriteManager->resultsWindowId, 24, COLORID_BLUE, gText_CrushingResults);
+            PrintResultsText(game, RESULTS_PAGE_CRUSHING, 0xC0, 0x10);
             break;
         }
         break;
     case 4:
-        sub_814E32C(game);
+        printCrushingResults(game);
         break;
     case 5:
-        CopyWindowToVram(spriteManager->unk82, COPYWIN_BOTH);
-        spriteManager->unk80 = 0;
+        CopyWindowToVram(spriteManager->resultsWindowId, COPYWIN_BOTH);
+        spriteManager->resultsState = 0;
         return TRUE;
     }
-    ++spriteManager->unk80;
+    ++spriteManager->resultsState;
     return FALSE;
 }
 
-void sub_814E80C(struct BerryCrushGame * game)
+static void CloseResultsWindow(struct BerryCrushGame * game)
 {
-    ClearStdWindowAndFrameToTransparent(game->spritesManager.unk82, 1);
-    RemoveWindow(game->spritesManager.unk82);
-    sub_814EBB0(game);
+    ClearStdWindowAndFrameToTransparent(game->gfx.resultsWindowId, TRUE);
+    RemoveWindow(game->gfx.resultsWindowId);
+    DrawPlayerNameWindows(game);
 }
 
+#define tState             data[0]
+#define tWindowId          data[1]
+#define tPressingSpeeds(i) data[2 + (i)] // data[2]-[5], for different group sizes
+
 static void Task_ShowBerryCrushRankings(u8 taskId)
 {
     u8 i = 0, j, xPos, yPos;
@@ -2831,33 +3099,33 @@ static void Task_ShowBerryCrushRankings(u8 taskId)
     s16 *data = gTasks[taskId].data;
     u8 *str;
 
-    switch (data[0])
+    switch (tState)
     {
     case 0:
-        data[1] = AddWindow(&sWindowTemplate_BerryCrushRankings);
-        PutWindowTilemap(data[1]);
-        FillWindowPixelBuffer(data[1], PIXEL_FILL(0));
-        TextWindow_SetStdFrame0_WithPal(data[1], 0x21D, 0xD0);
-        DrawStdFrameWithCustomTileAndPalette(data[1], 0, 0x21D, 0xD);
+        tWindowId = AddWindow(&sWindowTemplate_BerryCrushRankings);
+        PutWindowTilemap(tWindowId);
+        FillWindowPixelBuffer(tWindowId, PIXEL_FILL(0));
+        TextWindow_SetStdFrame0_WithPal(tWindowId, 0x21D, 0xD0);
+        DrawStdFrameWithCustomTileAndPalette(tWindowId, 0, 0x21D, 0xD);
         break;
     case 1:
         xPos = 96 - GetStringWidth(2, gText_BerryCrush2, -1) / 2u;
         AddTextPrinterParameterized3(
-            data[1],
+            tWindowId,
             2,
             xPos,
             2,
-            sBerryCrushTextColorTable[3],
+            sBerryCrushTextColorTable[COLORID_BLUE],
             0,
             gText_BerryCrush2
         );
         xPos = 96 - GetStringWidth(2, gText_PressingSpeedRankings, -1) / 2u;
         AddTextPrinterParameterized3(
-            data[1],
+            tWindowId,
             2,
             xPos,
             18,
-            sBerryCrushTextColorTable[3],
+            sBerryCrushTextColorTable[COLORID_BLUE],
             0,
             gText_PressingSpeedRankings
         );
@@ -2867,55 +3135,55 @@ static void Task_ShowBerryCrushRankings(u8 taskId)
             ConvertIntToDecimalStringN(gStringVar1, i + 2, STR_CONV_MODE_LEFT_ALIGN, 1);
             StringExpandPlaceholders(gStringVar4, gText_Var1Players);
             AddTextPrinterParameterized3(
-                data[1],
+                tWindowId,
                 2,
                 4,
                 yPos,
-                sBerryCrushTextColorTable[0],
+                sBerryCrushTextColorTable[COLORID_GRAY],
                 0,
                 gStringVar4
             );
             for (j = 0; j < 8; ++j)
             {
-                if (((data[i + 2] & 0xFF) >> (7 - j)) & 1)
+                if (((tPressingSpeeds(i) & 0xFF) >> (7 - j)) & 1)
                     score += sPressingSpeedConversionTable[j];
             }
-            ConvertIntToDecimalStringN(gStringVar1, (u16)data[i + 2] >> 8, STR_CONV_MODE_RIGHT_ALIGN, 3);
+            ConvertIntToDecimalStringN(gStringVar1, (u16)tPressingSpeeds(i) >> 8, STR_CONV_MODE_RIGHT_ALIGN, 3);
             ConvertIntToDecimalStringN(gStringVar2, score / 1000000, STR_CONV_MODE_LEADING_ZEROS, 2);
             str = StringExpandPlaceholders(gStringVar4, gText_XDotY3);
             *str++ = CHAR_SPACE;
             StringCopy(str, gText_TimesPerSec);
             xPos = 192 - (u8)GetStringWidth(3, gStringVar4, 0);
             AddTextPrinterParameterized3(
-                data[1],
+                tWindowId,
                 3,
                 xPos,
                 yPos,
-                sBerryCrushTextColorTable[0],
+                sBerryCrushTextColorTable[COLORID_GRAY],
                 0,
                 gStringVar4
             );
             yPos += 14;
             score = 0;
         }
-        CopyWindowToVram(data[1], COPYWIN_BOTH);
+        CopyWindowToVram(tWindowId, COPYWIN_BOTH);
         break;
     case 2:
-        if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+        if (JOY_NEW(A_BUTTON | B_BUTTON))
             break;
         else
             return;
     case 3:
-        ClearStdWindowAndFrameToTransparent(data[1], 1);
-        ClearWindowTilemap(data[1]);
-        RemoveWindow(data[1]);
+        ClearStdWindowAndFrameToTransparent(tWindowId, TRUE);
+        ClearWindowTilemap(tWindowId);
+        RemoveWindow(tWindowId);
         DestroyTask(taskId);
         EnableBothScriptContexts();
         ScriptContext2_Disable();
-        data[0] = 0;
+        tState = 0;
         return;
     }
-    ++data[0];
+    ++tState;
 }
 
 void ShowBerryCrushRankings(void)
@@ -2924,95 +3192,96 @@ void ShowBerryCrushRankings(void)
 
     ScriptContext2_Enable();
     taskId = CreateTask(Task_ShowBerryCrushRankings, 0);
-    gTasks[taskId].data[2] = gSaveBlock2Ptr->berryCrush.berryCrushResults[0];
-    gTasks[taskId].data[3] = gSaveBlock2Ptr->berryCrush.berryCrushResults[1];
-    gTasks[taskId].data[4] = gSaveBlock2Ptr->berryCrush.berryCrushResults[2];
-    gTasks[taskId].data[5] = gSaveBlock2Ptr->berryCrush.berryCrushResults[3];
+    gTasks[taskId].tPressingSpeeds(0) = gSaveBlock2Ptr->berryCrush.berryCrushResults[0];
+    gTasks[taskId].tPressingSpeeds(1) = gSaveBlock2Ptr->berryCrush.berryCrushResults[1];
+    gTasks[taskId].tPressingSpeeds(2) = gSaveBlock2Ptr->berryCrush.berryCrushResults[2];
+    gTasks[taskId].tPressingSpeeds(3) = gSaveBlock2Ptr->berryCrush.berryCrushResults[3];
 }
 
-static void BerryCrush_PrintTimeOnSprites(struct BerryCrushGame_138 * manager, u16 frames)
+static void PrintTimer(struct BerryCrushGame_Gfx * gfx, u16 frames)
 {
-    FramesToMinSec(manager, frames);
-    DigitObjUtil_PrintNumOn(0, manager->minutes);
-    DigitObjUtil_PrintNumOn(1, manager->secondsInt);
-    DigitObjUtil_PrintNumOn(2, manager->secondsFrac);
+    FramesToMinSec(gfx, frames);
+    DigitObjUtil_PrintNumOn(0, gfx->minutes);
+    DigitObjUtil_PrintNumOn(1, gfx->secondsInt);
+    DigitObjUtil_PrintNumOn(2, gfx->secondsFrac);
 }
 
-void BerryCrush_HideTimerSprites(struct BerryCrushGame_138 * manager)
+static void HideTimer(struct BerryCrushGame_Gfx * gfx)
 {
-    manager->timerSprites[0]->invisible = TRUE;
-    manager->timerSprites[1]->invisible = TRUE;
+    gfx->timerSprites[0]->invisible = TRUE;
+    gfx->timerSprites[1]->invisible = TRUE;
     DigitObjUtil_HideOrShow(2, 1);
     DigitObjUtil_HideOrShow(1, 1);
     DigitObjUtil_HideOrShow(0, 1);
 }
 
-static void sub_814EB38(struct BerryCrushGame * game)
+static void CreatePlayerNameWindows(struct BerryCrushGame * game)
 {
     u8 i;
 
     for (i = 0; i < game->playerCount; ++i)
     {
-        game->spritesManager.seatCoords[i] = &gUnknown_846F294[gUnknown_846F280[game->playerCount - 2][i]];
-        game->spritesManager.unk83[i] = AddWindow(&gUnknown_846E3F8[game->spritesManager.seatCoords[i]->unk0]);
-        PutWindowTilemap(game->spritesManager.unk83[i]);
-        FillWindowPixelBuffer(game->spritesManager.unk83[i], PIXEL_FILL(0));
+        game->gfx.playerCoords[i] = &sPlayerCoords[gUnknown_846F280[game->playerCount - 2][i]];
+        game->gfx.nameWindowIds[i] = AddWindow(&sWindowTemplates_PlayerNames[game->gfx.playerCoords[i]->playerId]);
+        PutWindowTilemap(game->gfx.nameWindowIds[i]);
+        FillWindowPixelBuffer(game->gfx.nameWindowIds[i], PIXEL_FILL(0));
     }
 }
 
-static void sub_814EBB0(struct BerryCrushGame * game)
+static void DrawPlayerNameWindows(struct BerryCrushGame * game)
 {
     u8 i;
 
     for (i = 0; i < game->playerCount; ++i)
     {
-        PutWindowTilemap(game->spritesManager.unk83[i]);
+        PutWindowTilemap(game->gfx.nameWindowIds[i]);
         if (i == game->localId)
         {
             AddTextPrinterParameterized4(
-                game->spritesManager.unk83[i],
+                game->gfx.nameWindowIds[i],
                 2,
-                36 - GetStringWidth(2, game->unk98[i].unk0, 0) / 2u,
+                36 - GetStringWidth(2, game->players[i].name, 0) / 2u,
                 1,
                 0,
                 0,
-                sBerryCrushTextColorTable[1],
+                sBerryCrushTextColorTable[COLORID_BLACK],
                 0,
-                game->unk98[i].unk0
+                game->players[i].name
             );
         }
         else
         {
             AddTextPrinterParameterized4(
-                game->spritesManager.unk83[i],
+                game->gfx.nameWindowIds[i],
                 2,
-                36 - GetStringWidth(2, game->unk98[i].unk0, 0) / 2u,
+                36 - GetStringWidth(2, game->players[i].name, 0) / 2u,
                 1,
                 0,
                 0,
-                sBerryCrushTextColorTable[2],
+                sBerryCrushTextColorTable[COLORID_LIGHT_GRAY],
                 0,
-                game->unk98[i].unk0
+                game->players[i].name
             );
         }
-        CopyWindowToVram(game->spritesManager.unk83[i], COPYWIN_BOTH);
+        CopyWindowToVram(game->gfx.nameWindowIds[i], COPYWIN_BOTH);
     }
     CopyBgTilemapBufferToVram(0);
 }
 
-static void sub_814EC80(struct BerryCrushGame * game)
+// Each player name window border uses a color that corresponds to a slot of the crusher lid
+static void CopyPlayerNameWindowGfxToBg(struct BerryCrushGame * game)
 {
     u8 i = 0;
-    u8 *r4;
+    u8 *crusherGfx;
 
-    LZ77UnCompWram(gUnknown_8EB0ADC, gDecompressionBuffer);
-    for (r4 = gDecompressionBuffer; i < game->playerCount; ++i)
+    LZ77UnCompWram(gBerryCrush_Crusher_Tilemap, gDecompressionBuffer);
+    for (crusherGfx = gDecompressionBuffer; i < game->playerCount; ++i)
     {
         CopyToBgTilemapBufferRect(
             3,
-            &r4[game->spritesManager.seatCoords[i]->unk0 * 40],
-            game->spritesManager.seatCoords[i]->unk1,
-            game->spritesManager.seatCoords[i]->unk2,
+            &crusherGfx[game->gfx.playerCoords[i]->playerId * 40],
+            game->gfx.playerCoords[i]->windowGfxX,
+            game->gfx.playerCoords[i]->windowGfxY,
             10,
             2
         );
@@ -3020,52 +3289,60 @@ static void sub_814EC80(struct BerryCrushGame * game)
     CopyBgTilemapBufferToVram(3);
 }
 
-static void sub_814ECE0(struct BerryCrushGame * game)
+static void CreateGameSprites(struct BerryCrushGame * game)
 {
     u8 i = 0;
     u8 spriteId;
 
-    game->depth = -104;
+    game->depth = CRUSHER_START_Y;
     game->vibration = 0;
     gSpriteCoordOffsetX = 0;
-    gSpriteCoordOffsetY = -104;
-    for (; i < 4; ++i)
+    gSpriteCoordOffsetY = CRUSHER_START_Y;
+    for (i = 0; i < NELEMS(sSpriteSheets) - 1; ++i)
         LoadCompressedSpriteSheet(&sSpriteSheets[i]);
     LoadSpritePalettes(sSpritePals);
+
+    // Create sprite for crusher base
     spriteId = CreateSprite(&sSpriteTemplate_BerryCrushCore, 120, 88, 5);
-    game->spritesManager.coreSprite = &gSprites[spriteId];
-    game->spritesManager.coreSprite->oam.priority = 3;
-    game->spritesManager.coreSprite->coordOffsetEnabled = TRUE;
-    game->spritesManager.coreSprite->animPaused = TRUE;
+    game->gfx.coreSprite = &gSprites[spriteId];
+    game->gfx.coreSprite->oam.priority = 3;
+    game->gfx.coreSprite->coordOffsetEnabled = TRUE;
+    game->gfx.coreSprite->animPaused = TRUE;
+
+    // Create sprites for the impact effect
     for (i = 0; i < game->playerCount; ++i)
     {
         spriteId = CreateSprite(
             &sSpriteTemplate_BerryCrushImpact,
-            game->spritesManager.seatCoords[i]->unk4 + 120,
-            game->spritesManager.seatCoords[i]->unk6 + 32,
+            game->gfx.playerCoords[i]->impactXOffset + 120,
+            game->gfx.playerCoords[i]->impactYOffset + 32,
             0
         );
-        game->spritesManager.impactSprites[i] = &gSprites[spriteId];
-        game->spritesManager.impactSprites[i]->oam.priority = 1;
-        game->spritesManager.impactSprites[i]->invisible = TRUE;
-        game->spritesManager.impactSprites[i]->coordOffsetEnabled = TRUE;
-        game->spritesManager.impactSprites[i]->animPaused = TRUE;
+        game->gfx.impactSprites[i] = &gSprites[spriteId];
+        game->gfx.impactSprites[i]->oam.priority = 1;
+        game->gfx.impactSprites[i]->invisible = TRUE;
+        game->gfx.impactSprites[i]->coordOffsetEnabled = TRUE;
+        game->gfx.impactSprites[i]->animPaused = TRUE;
     }
-    for (i = 0; i < NELEMS(game->spritesManager.sparkleSprites); ++i)
+
+    // Create sprites for sparkle effect
+    for (i = 0; i < NELEMS(game->gfx.sparkleSprites); ++i)
     {
         spriteId = CreateSprite(
             &sSpriteTemplate_BerryCrushPowderSparkles,
-            gUnknown_846F2D6[i][0] + 120,
-            gUnknown_846F2D6[i][1] + 136,
+            sSparkleCoords[i][0] + 120,
+            sSparkleCoords[i][1] + 136,
             6
         );
-        game->spritesManager.sparkleSprites[i] = &gSprites[spriteId];
-        game->spritesManager.sparkleSprites[i]->oam.priority = 3;
-        game->spritesManager.sparkleSprites[i]->invisible = TRUE;
-        game->spritesManager.sparkleSprites[i]->animPaused = TRUE;
-        game->spritesManager.sparkleSprites[i]->data[0] = i;
+        game->gfx.sparkleSprites[i] = &gSprites[spriteId];
+        game->gfx.sparkleSprites[i]->oam.priority = 3;
+        game->gfx.sparkleSprites[i]->invisible = TRUE;
+        game->gfx.sparkleSprites[i]->animPaused = TRUE;
+        game->gfx.sparkleSprites[i]->data[0] = i;
     }
-    for (i = 0; i < NELEMS(game->spritesManager.timerSprites); ++i)
+
+    // Create sprites for timer
+    for (i = 0; i < NELEMS(game->gfx.timerSprites); ++i)
     {
         spriteId = CreateSprite(
             &sSpriteTemplate_BerryCrushTimer,
@@ -3073,43 +3350,44 @@ static void sub_814ECE0(struct BerryCrushGame * game)
             8,
             0
         );
-        game->spritesManager.timerSprites[i] = &gSprites[spriteId];
-        game->spritesManager.timerSprites[i]->oam.priority = 0;
-        game->spritesManager.timerSprites[i]->invisible = FALSE;
-        game->spritesManager.timerSprites[i]->animPaused = FALSE;
+        game->gfx.timerSprites[i] = &gSprites[spriteId];
+        game->gfx.timerSprites[i]->oam.priority = 0;
+        game->gfx.timerSprites[i]->invisible = FALSE;
+        game->gfx.timerSprites[i]->animPaused = FALSE;
     }
     DigitObjUtil_CreatePrinter(0, 0, &sDigitObjTemplates[0]);
     DigitObjUtil_CreatePrinter(1, 0, &sDigitObjTemplates[1]);
     DigitObjUtil_CreatePrinter(2, 0, &sDigitObjTemplates[2]);
-    if (game->gameState == 1)
-            BerryCrush_HideTimerSprites(&game->spritesManager);
+
+    if (game->gameState == STATE_INIT)
+        HideTimer(&game->gfx);
 }
 
-static void sub_814EF10(struct BerryCrushGame * r5)
+static void DestroyGameSprites(struct BerryCrushGame * game)
 {
-    u8 r4 = 0;
+    u8 i = 0;
 
-    FreeSpriteTilesByTag(4);
-    FreeSpriteTilesByTag(3);
-    FreeSpriteTilesByTag(2);
-    FreeSpriteTilesByTag(1);
-    FreeSpritePaletteByTag(4);
-    FreeSpritePaletteByTag(2);
-    FreeSpritePaletteByTag(1);
-    for (; r4 < NELEMS(r5->spritesManager.timerSprites); ++r4)
-        DestroySprite(r5->spritesManager.timerSprites[r4]);
+    FreeSpriteTilesByTag(TAG_TIMER_DIGITS);
+    FreeSpriteTilesByTag(GFXTAG_SPARKLE);
+    FreeSpriteTilesByTag(GFXTAG_IMPACT);
+    FreeSpriteTilesByTag(TAG_CRUSHER_BASE);
+    FreeSpritePaletteByTag(TAG_TIMER_DIGITS);
+    FreeSpritePaletteByTag(PALTAG_EFFECT);
+    FreeSpritePaletteByTag(TAG_CRUSHER_BASE);
+    for (; i < NELEMS(game->gfx.timerSprites); ++i)
+        DestroySprite(game->gfx.timerSprites[i]);
     DigitObjUtil_DeletePrinter(2);
     DigitObjUtil_DeletePrinter(1);
     DigitObjUtil_DeletePrinter(0);
-    for (r4 = 0; r4 < NELEMS(r5->spritesManager.sparkleSprites); ++r4)
-        DestroySprite(r5->spritesManager.sparkleSprites[r4]);
-    for (r4 = 0; r4 < r5->playerCount; ++r4)
-        DestroySprite(r5->spritesManager.impactSprites[r4]);
-    if (r5->spritesManager.coreSprite->inUse)
-        DestroySprite(r5->spritesManager.coreSprite);
+    for (i = 0; i < NELEMS(game->gfx.sparkleSprites); ++i)
+        DestroySprite(game->gfx.sparkleSprites[i]);
+    for (i = 0; i < game->playerCount; ++i)
+        DestroySprite(game->gfx.impactSprites[i]);
+    if (game->gfx.coreSprite->inUse)
+        DestroySprite(game->gfx.coreSprite);
 }
 
-static void SpriteCB_BerryCrushImpact(struct Sprite * sprite)
+static void SpriteCB_Impact(struct Sprite * sprite)
 {
     if (sprite->animEnded)
     {
@@ -3118,7 +3396,7 @@ static void SpriteCB_BerryCrushImpact(struct Sprite * sprite)
     }
 }
 
-static void sub_814EFFC(struct Sprite * sprite)
+static void SpriteCB_Sparkle_End(struct Sprite * sprite)
 {
     u8 r1 = 0;
     SpriteCallback r5 = SpriteCallbackDummy;
@@ -3132,51 +3410,79 @@ static void sub_814EFFC(struct Sprite * sprite)
     sprite->callback = r5;
 }
 
-static void sub_814F044(struct Sprite * sprite)
+// Redefining from above
+#define sX         data[0]
+#define sYSpeed    data[1]
+#define sYAccel    data[2]
+#define sXSpeed    data[3]
+#define sSinIdx    data[4]
+#define sSinSpeed  data[5]
+#define sAmplitude data[6]
+// The last element (data[7]) is a bitfield.
+// The first 15 bits are the y coord to stop at.
+// The last bit is a flag for whether or not to move on the x too
+#define sBitfield  data[7]
+#define MASK_TARGET_Y 0x7FFF
+#define F_MOVE_HORIZ  0x8000
+
+static void SpriteCB_Sparkle(struct Sprite * sprite)
 {
-    s16 *r4 = sprite->data;
+    s16 *data = sprite->data;
 
-    r4[1] += r4[2];
-    sprite->pos2.y += r4[1] >> 8;
-    if (r4[7] & 0x8000)
+    sYSpeed += sYAccel;
+    sprite->pos2.y += Q_8_8_TO_INT(sYSpeed);
+    if (sBitfield & F_MOVE_HORIZ)
     {
-        sprite->data[0] += r4[3];
-        r4[4] += r4[5];
-        sprite->pos2.x = Sin(r4[4] >> 7, r4[6]);
-        if (r4[7] & 0x8000 && r4[4] >> 7 > 126)
+        sprite->sX += sXSpeed;
+        sSinIdx += sSinSpeed;
+        sprite->pos2.x = Sin(Q_N_S_TO_INT(7, sSinIdx), sAmplitude);
+        if ((sBitfield & F_MOVE_HORIZ) && Q_N_S_TO_INT(7, sSinIdx) > 126)
         {
             sprite->pos2.x = 0;
-            r4[7] &= 0x7FFF;
+            sBitfield &= MASK_TARGET_Y;
         }
     }
-    sprite->pos1.x = r4[0] >> 7;
-    if (sprite->pos1.y + sprite->pos2.y > (r4[7] & 0x7FFF))
-        sprite->callback = sub_814EFFC;
-}
-
-static void sub_814F0D8(struct Sprite * sprite)
-{
-    s16 *r7 = sprite->data;
-    s16 r4, r5;
-    s32 r2;
-    u32 r8 = 0;
-
-    r2 = 640;
-    r7[1] = r2;
-    r7[2] = 32;
-    r7[7] = 168;
-    r4 = sprite->pos2.x * 128;
-    r5 = MathUtil_Div16Shift(7, (168 - sprite->pos1.y) << 7, (r2 + 32) >> 1);
-    sprite->data[0] = sprite->pos1.x << 7;
-    r7[3] = MathUtil_Div16Shift(7, r4, r5);
-    r2 = MathUtil_Mul16Shift(7, r5, 85);
-    r7[4] = r8;
-    r7[5] = MathUtil_Div16Shift(7, 0x3F80, r2);
-    r7[6] = sprite->pos2.x / 4;
-    r7[7] |= 0x8000;
-    sprite->pos2.y = r8;
-    sprite->pos2.x = r8;
-    sprite->callback = sub_814F044;
+    sprite->pos1.x = Q_N_S_TO_INT(7, sX);
+    if (sprite->pos1.y + sprite->pos2.y > (sBitfield & MASK_TARGET_Y))
+        sprite->callback = SpriteCB_Sparkle_End;
+}
+
+static void SpriteCB_Sparkle_Init(struct Sprite * sprite)
+{
+    s16 *data = sprite->data;
+    s16 xMult, var;
+    s16 targetY;
+    s32 speed;
+    u32 zero = 0;
+
+    speed = Q_8_8(2.5);
+    sYSpeed = speed;
+    sYAccel = Q_8_8(0.125);
+    targetY = 168;
+    sBitfield = targetY;
+    xMult = Q_N_S(7, sprite->pos2.x);
+    var = Q_N_S_div(7, Q_N_S(7, targetY - (u16) sprite->pos1.y), (speed + Q_8_8(0.125)) >> 1);
+    sprite->sX = Q_N_S(7, (u16)sprite->pos1.x);
+    sXSpeed = Q_N_S_div(7, xMult, var);
+    speed = Q_N_S_mul(7, var, Q_N_S(7, 0.666666667));
+    sSinIdx = zero;
+    sSinSpeed = Q_N_S_div(7, Q_N_S(7, 127), speed);
+    sAmplitude = sprite->pos2.x / 4;
+    sBitfield |= F_MOVE_HORIZ;
+    sprite->pos2.y = zero;
+    sprite->pos2.x = zero;
+    sprite->callback = SpriteCB_Sparkle;
     sprite->animPaused = FALSE;
     sprite->invisible = FALSE;
 }
+
+#undef sX
+#undef sYSpeed
+#undef sYAccel
+#undef sXSpeed
+#undef sSinIdx
+#undef sSinSpeed
+#undef sAmplitude
+#undef sBitfield
+#undef MASK_TARGET_Y
+#undef F_MOVE_HORIZ
diff --git a/src/digit_obj_util.c b/src/digit_obj_util.c
index 852c386ac..3f7128513 100644
--- a/src/digit_obj_util.c
+++ b/src/digit_obj_util.c
@@ -74,7 +74,7 @@ bool32 DigitObjUtil_Init(u32 count)
     u32 i;
 
     if (sOamWork != NULL)
-        DigitObjUtil_Teardown();
+        DigitObjUtil_Free();
 
     sOamWork = Alloc(sizeof(*sOamWork));
     if (sOamWork == NULL)
@@ -97,7 +97,7 @@ bool32 DigitObjUtil_Init(u32 count)
     return TRUE;
 }
 
-void DigitObjUtil_Teardown(void)
+void DigitObjUtil_Free(void)
 {
     if (sOamWork != NULL)
     {
diff --git a/src/dodrio_berry_picking.c b/src/dodrio_berry_picking.c
index 35562bde7..53af1f48c 100644
--- a/src/dodrio_berry_picking.c
+++ b/src/dodrio_berry_picking.c
@@ -299,7 +299,7 @@ static void sub_8150A84(u8 taskId)
     case 2:
         if (!sub_8155E68())
         {
-            LinkRfu_SetRfuFuncToSend6600();
+            Rfu_SetLinkStandbyCallback();
             gUnknown_203F3E0->unk0C++;
         }
         break;
@@ -412,7 +412,7 @@ static void sub_8150CF4(void)
         gUnknown_203F3E0->unk10++;
         break;
     case 1:
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
         gUnknown_203F3E0->unk10++;
         break;
     case 2:
@@ -424,7 +424,7 @@ static void sub_8150CF4(void)
     case 3:
         if (!IsMinigameCountdownRunning())
         {
-            LinkRfu_SetRfuFuncToSend6600();
+            Rfu_SetLinkStandbyCallback();
             gUnknown_203F3E0->unk10++;
         }
         break;
@@ -1023,12 +1023,12 @@ static void sub_815184C(void)
     {
         if (gUnknown_203F3E0->unk128 != 0)
         {
-            sub_80FBA44();
+            ClearRecvCommands();
             gUnknown_203F3E0->unk124 = 0;
         }
         else if (gUnknown_203F3E0->unk124 > 70)
         {
-            sub_80FBA44();
+            ClearRecvCommands();
             gUnknown_203F3E0->unk124 = 0;
         }
     }
@@ -1089,12 +1089,12 @@ static void sub_8151A5C(void)
     {
         if (gUnknown_203F3E0->unk128 != 0)
         {
-            sub_80FBA44();
+            ClearRecvCommands();
             gUnknown_203F3E0->unk124 = 0;
         }
         else if (gUnknown_203F3E0->unk124 > 70)
         {
-            sub_80FBA44();
+            ClearRecvCommands();
             gUnknown_203F3E0->unk124 = 0;
         }
     }
diff --git a/src/dodrio_berry_picking_2.c b/src/dodrio_berry_picking_2.c
index aa9f65042..e5e263647 100644
--- a/src/dodrio_berry_picking_2.c
+++ b/src/dodrio_berry_picking_2.c
@@ -1431,12 +1431,12 @@ static void sub_8155A78(void)
     case 2:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            CreateTask(Task_SaveGame_UpdatedLinkRecords, 0);
+            CreateTask(Task_LinkSave, 0);
             gUnknown_203F440->state++;
         }
         break;
     case 3:
-        if (!FuncIsActiveTask(Task_SaveGame_UpdatedLinkRecords))
+        if (!FuncIsActiveTask(Task_LinkSave))
             gUnknown_203F440->state++;
         break;
     default:
@@ -1577,7 +1577,7 @@ static void sub_8155EA0(void)
     ChangeBgX(3, 0, 0);
     ChangeBgY(3, 0, 0);
     InitStandardTextBoxWindows();
-    ResetBg0();
+    InitTextBoxGfxAndPrinters();
     SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
     SetBgTilemapBuffer(3, gUnknown_203F440->tilemapBuffers[0]);
     SetBgTilemapBuffer(1, gUnknown_203F440->tilemapBuffers[1]);
diff --git a/src/dodrio_berry_picking_3.c b/src/dodrio_berry_picking_3.c
index fec1d62f7..3bd538f94 100644
--- a/src/dodrio_berry_picking_3.c
+++ b/src/dodrio_berry_picking_3.c
@@ -8,7 +8,7 @@ void sub_815A5BC(s32 a0)
     struct Padded_U8 data[2];
     data[0].value = 1;
     data[1].value = a0;
-    RfuPrepareSend0x2f00(data);
+    Rfu_SendPacket(data);
 }
 
 u8 sub_815A5E8(s32 a0)
@@ -114,7 +114,7 @@ void sub_815A61C(struct DodrioSubstruct_31A0 * arg0, struct DodrioSubstruct_31A0
     packet.unkA_3 = arg6;
     packet.unkB_1 = arg7;
     packet.unkB_0 = arg8;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 u32 sub_815A950(u32 unused, struct DodrioSubstruct_31A0 * arg0, struct DodrioSubstruct_31A0_2C * arg1, struct DodrioSubstruct_31A0_2C * arg2, struct DodrioSubstruct_31A0_2C * arg3, struct DodrioSubstruct_31A0_2C * arg4, struct DodrioSubstruct_31A0_2C * arg5, u8 *arg6, u32 *arg7, u32 *arg8)
@@ -192,7 +192,7 @@ void sub_815AAD8(u8 arg0)
     struct UnkPacket3 packet;
     packet.id = 3;
     packet.unk4 = arg0;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 u32 sub_815AB04(u32 arg0, u8 *arg1)
@@ -223,7 +223,7 @@ void sub_815AB3C(u32 arg0)
     struct UnkPacket4 packet;
     packet.id = 4;
     packet.unk4 = arg0;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 u32 sub_815AB60(u32 arg0)
diff --git a/src/graphics.c b/src/graphics.c
index 04a6f6206..03986a03f 100644
--- a/src/graphics.c
+++ b/src/graphics.c
@@ -1414,7 +1414,7 @@ const u32 gTradeGba_Gfx[] = INCBIN_U32("graphics/link/gba.4bpp");
 
 const u16 gUnknown_8EAFE80[] = INCBIN_U16("graphics/interface/blank2.gbapal");
 
-const u16 gUnknown_8EAFEA0[] = INCBIN_U16("graphics/berry_crush/berry_crush.gbapal");
+const u16 gBerryCrush_Crusher_Pal[] = INCBIN_U16("graphics/berry_crush/berry_crush.gbapal");
 const u16 gUnknown_8EAFF60[] = INCBIN_U16("graphics/unknown/unknown_EAFF60.gbapal");
-const u32 gUnknown_8EAFFC0[] = INCBIN_U32("graphics/berry_crush/berry_crush.4bpp.lz");
-const u32 gUnknown_8EB0ADC[] = INCBIN_U32("graphics/berry_crush/data_EB0ADC.bin.lz");
+const u32 gBerryCrush_Crusher_Gfx[] = INCBIN_U32("graphics/berry_crush/berry_crush.4bpp.lz");
+const u32 gBerryCrush_Crusher_Tilemap[] = INCBIN_U32("graphics/berry_crush/data_EB0ADC.bin.lz");
diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c
index e6f8b72ec..d2c7555e2 100644
--- a/src/hall_of_fame.c
+++ b/src/hall_of_fame.c
@@ -1198,7 +1198,7 @@ static bool8 DrawHofBackground(void)
         break;
     case 3:
         InitStandardTextBoxWindows();
-        ResetBg0();
+        InitTextBoxGfxAndPrinters();
         break;
     case 4:
         SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON);
diff --git a/src/item.c b/src/item.c
index 801c7d689..0df45cbd3 100644
--- a/src/item.c
+++ b/src/item.c
@@ -139,7 +139,7 @@ bool8 CheckBagHasItem(u16 itemId, u16 count)
     return FALSE;
 }
 
-bool8 CheckHasAtLeastOneBerry(void)
+bool8 HasAtLeastOneBerry(void)
 {
     u8 itemId;
     bool8 exists;
diff --git a/src/link.c b/src/link.c
index 2a242dde9..d3c0cccec 100644
--- a/src/link.c
+++ b/src/link.c
@@ -1381,7 +1381,7 @@ void SetLinkStandbyCallback(void)
 {
     if (gWirelessCommType == 1)
     {
-        LinkRfu_SetRfuFuncToSend6600();
+        Rfu_SetLinkStandbyCallback();
     }
     else
     {
diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c
index cf23098d7..8c7447264 100644
--- a/src/link_rfu_2.c
+++ b/src/link_rfu_2.c
@@ -894,7 +894,7 @@ static void HandleSendFailure(u8 unused, u32 flags)
     {
         if (!(flags & 1))
         {
-            sResendBlock16[0] = RFU_COMMAND_0x8900 | i;
+            sResendBlock16[0] = RFUCMD_0x8900 | i;
             for (j = 0; j < 7; j++)
             {
                 sResendBlock16[j + 1] = (r10[12 * i + (j << 1) + 1] << 8) | r10[12 * i + (j << 1) + 0];
@@ -949,7 +949,7 @@ static void RfuFunc_SendKeysToRfu(void)
     {
         gUnknown_3001188++;
         gHeldKeyCodeToSend |= (gUnknown_3001188 << 8);
-        RfuPrepareSendBuffer(RFU_COMMAND_0xbe00);
+        RfuPrepareSendBuffer(RFUCMD_SEND_HELD_KEYS);
     }
 }
 
@@ -983,18 +983,18 @@ static void RfuHandleReceiveCommand(u8 unused)
     {
         switch (gRecvCmds[i][0] & 0xff00)
         {
-        case RFU_COMMAND_0x7800:
+        case RFUCMD_0x7800:
             if (Rfu.parent_child == MODE_CHILD && gReceivedRemoteLinkPlayers)
                 return;
             // fallthrough
-        case RFU_COMMAND_0x7700:
+        case RFUCMD_0x7700:
             if (gRfuLinkStatus->parentChild == MODE_CHILD)
             {
                 Rfu.playerCount = gRecvCmds[i][1];
                 Rfu.unk_cce = sub_80F9770((u8 *)(gRecvCmds[i] + 2));
             }
             break;
-        case RFU_COMMAND_0x8800:
+        case RFUCMD_0x8800:
             if (Rfu.cmd_8800_recvbuf[i].receiving == 0)
             {
                 Rfu.cmd_8800_recvbuf[i].next = 0;
@@ -1005,7 +1005,7 @@ static void RfuHandleReceiveCommand(u8 unused)
                 Rfu.unk_5c[i] = 0;
             }
             break;
-        case RFU_COMMAND_0x8900:
+        case RFUCMD_0x8900:
             if (Rfu.cmd_8800_recvbuf[i].receiving == 1)
             {
                 Rfu.cmd_8800_recvbuf[i].next = gRecvCmds[i][0] & 0xff;
@@ -1021,17 +1021,17 @@ static void RfuHandleReceiveCommand(u8 unused)
                 }
             }
             break;
-        case RFU_COMMAND_0xa100:
+        case RFUCMD_SEND_BLOCK_REQ:
             Rfu_InitBlockSend(gUnknown_843EC64[gRecvCmds[i][1]].buffer, (u16)gUnknown_843EC64[gRecvCmds[i][1]].size);
             break;
-        case RFU_COMMAND_0x5f00:
+        case RFUCMD_READY_CLOSE_LINK:
             Rfu.cmd5f00Ack[i] = 1;
             break;
-        case RFU_COMMAND_0x6600:
+        case RFUCMD_READY_EXIT_STANDBY:
             if (Rfu.cmd_6600_count == gRecvCmds[i][1])
                 Rfu.cmd_6600_recvd[i] = 1;
             break;
-        case RFU_COMMAND_0xed00:
+        case RFUCMD_0xED00:
             if (Rfu.parent_child == MODE_CHILD)
             {
                 if (gReceivedRemoteLinkPlayers)
@@ -1048,13 +1048,13 @@ static void RfuHandleReceiveCommand(u8 unused)
             }
             else
             {
-                RfuPrepareSendBuffer(RFU_COMMAND_0xee00);
+                RfuPrepareSendBuffer(RFUCMD_0xEE00);
                 gSendCmd[1] = gRecvCmds[i][1];
                 gSendCmd[2] = gRecvCmds[i][2];
                 gSendCmd[3] = gRecvCmds[i][3];
             }
             break;
-        case RFU_COMMAND_0xee00:
+        case RFUCMD_0xEE00:
             if (Rfu.parent_child == MODE_PARENT)
             {
                 Rfu.bm_DisconnectSlot |= gRecvCmds[i][1];
@@ -1062,7 +1062,7 @@ static void RfuHandleReceiveCommand(u8 unused)
                 sub_80FA9D0(gRecvCmds[i][1]);
             }
             break;
-        case RFU_COMMAND_0xbe00:
+        case RFUCMD_SEND_HELD_KEYS:
             gLinkPartnersHeldKeys[i] = gRecvCmds[i][1];
             break;
         }
@@ -1138,16 +1138,16 @@ static void RfuPrepareSendBuffer(u16 command)
     gSendCmd[0] = command;
     switch (command)
     {
-    case RFU_COMMAND_0x8800:
+    case RFUCMD_0x8800:
         gSendCmd[1] = Rfu.cmd_8800_sendbuf.count;
         gSendCmd[2] = Rfu.cmd_8800_sendbuf.owner + 0x80;
         break;
-    case RFU_COMMAND_0xa100:
+    case RFUCMD_SEND_BLOCK_REQ:
         if (Cmd8000recvIsFinished())
             gSendCmd[1] = Rfu.cmdA100_blockRequestType;
         break;
-    case RFU_COMMAND_0x7700:
-    case RFU_COMMAND_0x7800:
+    case RFUCMD_0x7700:
+    case RFUCMD_0x7800:
         tmp = Rfu.bm_PartnerFlags ^ Rfu.bm_DisconnectSlot;
         Rfu.playerCount = gUnknown_843EC41[tmp] + 1;
         gSendCmd[1] = Rfu.playerCount;
@@ -1155,30 +1155,30 @@ static void RfuPrepareSendBuffer(u16 command)
         for (i = 0; i < RFU_CHILD_MAX; i++)
             buff[i] = Rfu.linkPlayerIdx[i];
         break;
-    case RFU_COMMAND_0x6600:
-    case RFU_COMMAND_0x5f00:
+    case RFUCMD_READY_EXIT_STANDBY:
+    case RFUCMD_READY_CLOSE_LINK:
         gSendCmd[1] = Rfu.cmd_6600_count;
         break;
-    case RFU_COMMAND_0x2f00:
+    case RFUCMD_SEND_PACKET:
         for (i = 0; i < 6; i++)
             gSendCmd[1 + i] = Rfu.unk_f2[i];
         break;
-    case RFU_COMMAND_0xbe00:
+    case RFUCMD_SEND_HELD_KEYS:
         gSendCmd[1] = gHeldKeyCodeToSend;
         break;
-    case RFU_COMMAND_0xee00:
+    case RFUCMD_0xEE00:
         break;
-    case RFU_COMMAND_0xed00:
+    case RFUCMD_0xED00:
         break;
     }
 }
 
-void RfuPrepareSend0x2f00(void * data)
+void Rfu_SendPacket(void * data)
 {
     if (gSendCmd[0] == 0 && !RfuIsErrorStatus1or2())
     {
         memcpy(Rfu.unk_f2, data, sizeof(Rfu.unk_f2));
-        RfuPrepareSendBuffer(RFU_COMMAND_0x2f00);
+        RfuPrepareSendBuffer(RFUCMD_SEND_PACKET);
     }
 }
 
@@ -1208,7 +1208,7 @@ bool32 Rfu_InitBlockSend(const u8 *src, size_t size)
             memcpy(gBlockSendBuffer, src, size);
         Rfu.cmd_8800_sendbuf.payload = gBlockSendBuffer;
     }
-    RfuPrepareSendBuffer(RFU_COMMAND_0x8800);
+    RfuPrepareSendBuffer(RFUCMD_0x8800);
     Rfu.RfuFunc = RfuFunc_HandleBlockSend;
     Rfu.unk_5b = 0;
     return TRUE;
@@ -1218,7 +1218,7 @@ static void RfuFunc_HandleBlockSend(void)
 {
     if (gSendCmd[0] == 0)
     {
-        RfuPrepareSendBuffer(RFU_COMMAND_0x8800);
+        RfuPrepareSendBuffer(RFUCMD_0x8800);
         if (Rfu.parent_child == MODE_PARENT)
         {
             if (++Rfu.unk_5b > 2)
@@ -1226,7 +1226,7 @@ static void RfuFunc_HandleBlockSend(void)
         }
         else
         {
-            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFU_COMMAND_0x8800)
+            if ((gRecvCmds[GetMultiplayerId()][0] & 0xff00) == RFUCMD_0x8800)
                 Rfu.RfuFunc = RfuFunc_SendNextBlock;
         }
     }
@@ -1235,7 +1235,7 @@ static void RfuFunc_SendNextBlock(void)
 {
     s32 i;
     const u8 *src = Rfu.cmd_8800_sendbuf.payload;
-    gSendCmd[0] = RFU_COMMAND_0x8900 | Rfu.cmd_8800_sendbuf.next;
+    gSendCmd[0] = RFUCMD_0x8900 | Rfu.cmd_8800_sendbuf.next;
     for (i = 0; i < 7; i++)
         gSendCmd[i + 1] = (src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 1] << 8) | src[(i << 1) + Rfu.cmd_8800_sendbuf.next * 12 + 0];
     Rfu.cmd_8800_sendbuf.next++;
@@ -1253,7 +1253,7 @@ static void RfuFunc_SendLastBlock(void)
     s32 i;
     if (Rfu.parent_child == MODE_CHILD)
     {
-        gSendCmd[0] = RFU_COMMAND_0x8900 | (Rfu.cmd_8800_sendbuf.count - 1);
+        gSendCmd[0] = RFUCMD_0x8900 | (Rfu.cmd_8800_sendbuf.count - 1);
         for (i = 0; i < 7; i++)
             gSendCmd[i + 1] = (src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 1] << 8) | src[(i << 1) + (Rfu.cmd_8800_sendbuf.count - 1) * 12 + 0];
         if ((u8)gRecvCmds[mpId][0] == Rfu.cmd_8800_sendbuf.count - 1)
@@ -1274,7 +1274,7 @@ static void RfuFunc_SendLastBlock(void)
 bool8 LinkRfu_PrepareCmd0xA100(u8 blockRequestType)
 {
     Rfu.cmdA100_blockRequestType = blockRequestType;
-    RfuPrepareSendBuffer(RFU_COMMAND_0xa100);
+    RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ);
     return TRUE;
 }
 
@@ -1340,7 +1340,7 @@ static void RfuFunc_BuildCommand5F00(void)
 {
     if (gSendCmd[0] == 0 && !Rfu.unk_ce8)
     {
-        RfuPrepareSendBuffer(RFU_COMMAND_0x5f00);
+        RfuPrepareSendBuffer(RFUCMD_READY_CLOSE_LINK);
         Rfu.RfuFunc = RfuFunc_WaitAck5F00;
     }
 }
@@ -1370,7 +1370,7 @@ static void RfuFunc_Send6600_3(void)
     {
         if (Rfu.unk_124.count == 0 && Rfu.cmd_6600_timer > 60)
         {
-            RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+            RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
             Rfu.cmd_6600_timer = 0;
         }
     }
@@ -1394,7 +1394,7 @@ static void RfuFunc_Send6600_2(void)
 {
     if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
     {
-        RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+        RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
         Rfu.RfuFunc = RfuFunc_Send6600_3;
     }
 }
@@ -1408,7 +1408,7 @@ static void RfuFunc_Send6600_1(void)
     {
         if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
         {
-            RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+            RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
             Rfu.RfuFunc = RfuFunc_Send6600_3;
         }
     }
@@ -1424,14 +1424,14 @@ static void RfuFunc_Send6600_1(void)
         {
             if (Rfu.unk_124.count == 0 && gSendCmd[0] == 0)
             {
-                RfuPrepareSendBuffer(RFU_COMMAND_0x6600);
+                RfuPrepareSendBuffer(RFUCMD_READY_EXIT_STANDBY);
                 Rfu.RfuFunc = RfuFunc_Send6600_2;
             }
         }
     }
 }
 
-void LinkRfu_SetRfuFuncToSend6600(void)
+void Rfu_SetLinkStandbyCallback(void)
 {
     if (Rfu.RfuFunc == NULL)
     {
@@ -1638,9 +1638,9 @@ static void sub_80FA834(u8 taskId)
         if (Rfu.parent_child == MODE_PARENT)
         {
             if (gReceivedRemoteLinkPlayers)
-                RfuPrepareSendBuffer(RFU_COMMAND_0x7800);
+                RfuPrepareSendBuffer(RFUCMD_0x7800);
             else
-                RfuPrepareSendBuffer(RFU_COMMAND_0x7700);
+                RfuPrepareSendBuffer(RFUCMD_0x7700);
             gTasks[taskId].data[0] = 101;
         }
         else
@@ -1660,7 +1660,7 @@ static void sub_80FA834(u8 taskId)
             if (Cmd8000recvIsFinished())
             {
                 Rfu.cmdA100_blockRequestType = 0;
-                RfuPrepareSendBuffer(RFU_COMMAND_0xa100);
+                RfuPrepareSendBuffer(RFUCMD_SEND_BLOCK_REQ);
                 gTasks[taskId].data[0]++;
             }
         }
@@ -1750,7 +1750,7 @@ static void Task_ExchangeLinkPlayers(u8 taskId)
         if (gSendCmd[0] == 0)
         {
             ResetBlockReceivedFlag(r4);
-            RfuPrepareSendBuffer(RFU_COMMAND_0x7800);
+            RfuPrepareSendBuffer(RFUCMD_0x7800);
             gTasks[taskId].data[0]++;
         }
         break;
@@ -2393,7 +2393,7 @@ void RFUVSync(void)
     rfu_LMAN_syncVBlank();
 }
 
-void sub_80FBA44(void)
+void ClearRecvCommands(void)
 {
     CpuFill32(0, gRecvCmds, sizeof(gRecvCmds));
 }
@@ -2561,7 +2561,7 @@ static void sub_80FBDB8(u8 taskId)
 {
     if (gSendCmd[0] == 0 && !Rfu.unk_ce8)
     {
-        RfuPrepareSendBuffer(RFU_COMMAND_0xed00);
+        RfuPrepareSendBuffer(RFUCMD_0xED00);
         gSendCmd[1] = gTasks[taskId].data[0];
         gSendCmd[2] = gTasks[taskId].data[1];
         Rfu.playerCount -= gUnknown_843EC41[gTasks[taskId].data[0]];
diff --git a/src/math_util.c b/src/math_util.c
index f77c82608..767e4d93d 100644
--- a/src/math_util.c
+++ b/src/math_util.c
@@ -1,6 +1,7 @@
 #include "global.h"
+#include "math_util.h"
 
-s16 MathUtil_Mul16(s16 x, s16 y)
+s16 Q_8_8_mul(s16 x, s16 y)
 {
     s32 result;
 
@@ -10,7 +11,7 @@ s16 MathUtil_Mul16(s16 x, s16 y)
     return result;
 }
 
-s16 MathUtil_Mul16Shift(u8 s, s16 x, s16 y)
+s16 Q_N_S_mul(u8 s, s16 x, s16 y)
 {
     s32 result;
 
@@ -20,7 +21,7 @@ s16 MathUtil_Mul16Shift(u8 s, s16 x, s16 y)
     return result;
 }
 
-s32 MathUtil_Mul32(s32 x, s32 y)
+s32 Q_24_8_mul(s32 x, s32 y)
 {
     s64 result;
 
@@ -30,7 +31,7 @@ s32 MathUtil_Mul32(s32 x, s32 y)
     return result;
 }
 
-s16 MathUtil_Div16(s16 x, s16 y)
+s16 Q_8_8_div(s16 x, s16 y)
 {
     if (y == 0)
     {
@@ -39,7 +40,7 @@ s16 MathUtil_Div16(s16 x, s16 y)
     return (x << 8) / y;
 }
 
-s16 MathUtil_Div16Shift(u8 s, s16 x, s16 y)
+s16 Q_N_S_div(u8 s, s16 x, s16 y)
 {
     if (y == 0)
     {
@@ -48,7 +49,7 @@ s16 MathUtil_Div16Shift(u8 s, s16 x, s16 y)
     return (x << s) / y;
 }
 
-s32 MathUtil_Div32(s32 x, s32 y)
+s32 Q_24_8_div(s32 x, s32 y)
 {
     s64 _x;
 
@@ -61,7 +62,7 @@ s32 MathUtil_Div32(s32 x, s32 y)
     return _x / y;
 }
 
-s16 MathUtil_Inv16(s16 y)
+s16 Q_8_8_inv(s16 y)
 {
     s32 x;
 
@@ -69,7 +70,7 @@ s16 MathUtil_Inv16(s16 y)
     return x / y;
 }
 
-s16 MathUtil_Inv16Shift(u8 s, s16 y)
+s16 Q_N_S_inv(u8 s, s16 y)
 {
     s32 x;
 
@@ -77,7 +78,7 @@ s16 MathUtil_Inv16Shift(u8 s, s16 y)
     return x / y;
 }
 
-s32 MathUtil_Inv32(s32 y)
+s32 Q_24_8_inv(s32 y)
 {
     s64 x;
 
diff --git a/src/naming_screen.c b/src/naming_screen.c
index 2f40cf2aa..f239620cf 100644
--- a/src/naming_screen.c
+++ b/src/naming_screen.c
@@ -496,7 +496,7 @@ static void NamingScreen_InitBGs(void)
     ChangeBgY(3, 0, 0);
 
     InitStandardTextBoxWindows();
-    ResetBg0();
+    InitTextBoxGfxAndPrinters();
 
     for (i = 0; i < NELEMS(gUnknown_83E22A0) - 1; i++)
         sNamingScreenData->windows[i] = AddWindow(&gUnknown_83E22A0[i]);
diff --git a/src/new_menu_helpers.c b/src/new_menu_helpers.c
index 556d83a69..2d7e8c4b4 100644
--- a/src/new_menu_helpers.c
+++ b/src/new_menu_helpers.c
@@ -388,7 +388,7 @@ void FreeAllOverworldWindowBuffers(void)
     FreeAllWindowBuffers();
 }
 
-void ResetBg0(void)
+void InitTextBoxGfxAndPrinters(void)
 {
     ChangeBgX(0, 0, 0);
     ChangeBgY(0, 0, 0);
diff --git a/src/oak_speech.c b/src/oak_speech.c
index 96ba0adee..3779090a3 100644
--- a/src/oak_speech.c
+++ b/src/oak_speech.c
@@ -534,7 +534,7 @@ static void Task_OaksSpeech1(u8 taskId)
     case 4:
         gPaletteFade.bufferTransferDisabled = TRUE;
         InitStandardTextBoxWindows();
-        ResetBg0();
+        InitTextBoxGfxAndPrinters();
         Menu_LoadStdPalAt(0xD0);
         LoadPalette(sHelpDocsPalette, 0x000, 0x080);
         LoadPalette(stdpal_get(2) + 15, 0x000, 0x002);
@@ -1418,8 +1418,8 @@ static void Task_OakSpeech39(u8 taskId)
             PlaySE(SE_WARP_IN);
         r0 = data[2];
         data[2] -= 32;
-        x = MathUtil_Inv16(r0 - 8);
-        y = MathUtil_Inv16(data[2] - 16);
+        x = Q_8_8_inv(r0 - 8);
+        y = Q_8_8_inv(data[2] - 16);
         SetBgAffine(2, 0x7800, 0x5400, 0x78, 0x54, x, y, 0);
         if (data[2] <= 96)
         {
@@ -1566,7 +1566,7 @@ static void CB2_ReturnFromNamingScreen(void)
     case 3:
         FreeAllWindowBuffers();
         InitStandardTextBoxWindows();
-        ResetBg0();
+        InitTextBoxGfxAndPrinters();
         LoadPalette(sHelpDocsPalette, 0, 0xe0);
         break;
     case 4:
diff --git a/src/overworld.c b/src/overworld.c
index 66ca5e336..a330ace3e 100644
--- a/src/overworld.c
+++ b/src/overworld.c
@@ -1345,7 +1345,7 @@ static void InitOverworldBgs(void)
     SetBgTilemapBuffer(2, gBGTilemapBuffers1);
     SetBgTilemapBuffer(3, gBGTilemapBuffers3);
     InitStandardTextBoxWindows();
-    ResetBg0();
+    InitTextBoxGfxAndPrinters();
     sub_8069348();
 }
 
@@ -1363,7 +1363,7 @@ static void InitOverworldBgs_NoResetHeap(void)
     SetBgTilemapBuffer(2, gBGTilemapBuffers1);
     SetBgTilemapBuffer(3, gBGTilemapBuffers3);
     InitStandardTextBoxWindows();
-    ResetBg0();
+    InitTextBoxGfxAndPrinters();
     sub_8069348();
 }
 
diff --git a/src/pokemon_jump.c b/src/pokemon_jump.c
index 853ec4f26..45634ad9c 100644
--- a/src/pokemon_jump.c
+++ b/src/pokemon_jump.c
@@ -244,7 +244,7 @@ static void sub_8147A34(u8 taskId)
             memset(packet, 0, sizeof(packet));
             packet[0] = 0x7FFF;
             packet[1] = data[12];
-            RfuPrepareSend0x2f00(packet);
+            Rfu_SendPacket(packet);
         }
     }
     else
diff --git a/src/pokemon_jump_2.c b/src/pokemon_jump_2.c
index a219459c1..2fe066da1 100644
--- a/src/pokemon_jump_2.c
+++ b/src/pokemon_jump_2.c
@@ -1002,12 +1002,12 @@ static bool32 sub_814881C(void)
     case 2:
         if (sub_8149804())
         {
-            CreateTask(Task_SaveGame_UpdatedLinkRecords, 6);
+            CreateTask(Task_LinkSave, 6);
             gUnknown_203F3D4->unk8++;
         }
         break;
     case 3:
-        if (!FuncIsActiveTask(Task_SaveGame_UpdatedLinkRecords))
+        if (!FuncIsActiveTask(Task_LinkSave))
         {
             sub_814A6CC();
             gUnknown_203F3D4->unk8++;
diff --git a/src/pokemon_jump_3.c b/src/pokemon_jump_3.c
index 04d9ad439..978c4ab71 100644
--- a/src/pokemon_jump_3.c
+++ b/src/pokemon_jump_3.c
@@ -17,7 +17,7 @@ void sub_8149A6C(struct PokemonJump1_MonInfo *arg0)
     packet.species = arg0->species;
     packet.otId = arg0->otId;
     packet.personality = arg0->personality;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 bool32 sub_8149A90(int multiplayerId, struct PokemonJump1_MonInfo *arg0)
@@ -51,7 +51,7 @@ void sub_8149AE0(u32 arg0)
     struct UnkPacket2 packet;
     packet.id = 2;
     packet.unk4 = arg0;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 struct UnkPacket3
@@ -79,7 +79,7 @@ void sub_8149AF8(struct PokemonJump1_82E4 *arg0, struct PokemonJump1Sub *arg1)
     packet.unk2 = arg0->unk10;
     packet.unk3_1 = arg0->unk14;
     packet.unk4 = arg0->unkE;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 bool32 sub_8149B7C(struct PokemonJump1_82E4 *arg0, struct PokemonJump1Sub *arg1)
@@ -125,7 +125,7 @@ void sub_8149BF4(struct PokemonJump1_82E4 *arg0, u8 arg1, u16 arg2)
     packet.unk4 = arg0->unkE;
     packet.unk6 = arg1;
     packet.unk8 = arg2;
-    RfuPrepareSend0x2f00(&packet);
+    Rfu_SendPacket(&packet);
 }
 
 bool32 sub_8149C24(struct PokemonJump1_82E4 *arg0, int multiplayerId, u8 *arg2, u16 *arg3)
diff --git a/src/pokemon_jump_4.c b/src/pokemon_jump_4.c
index b197ebeef..4725e3fc2 100644
--- a/src/pokemon_jump_4.c
+++ b/src/pokemon_jump_4.c
@@ -55,7 +55,7 @@ void sub_8149CEC(struct PokemonJump2 *arg0)
 void sub_8149D24(void)
 {
     FreeAllWindowBuffers();
-    DigitObjUtil_Teardown();
+    DigitObjUtil_Free();
 }
 
 static void sub_8149D34(struct PokemonJump2 *arg0)
diff --git a/src/save.c b/src/save.c
index 353ad5cb2..3ce4025bf 100644
--- a/src/save.c
+++ b/src/save.c
@@ -844,7 +844,7 @@ u32 TryWriteSpecialSaveSection(u8 sector, u8* src)
     return 1;
 }
 
-void Task_SaveGame_UpdatedLinkRecords(u8 taskId)
+void Task_LinkSave(u8 taskId)
 {
     switch (gTasks[taskId].data[0])
     {
diff --git a/src/start_menu.c b/src/start_menu.c
index 6280ba7b4..4f901c25d 100644
--- a/src/start_menu.c
+++ b/src/start_menu.c
@@ -941,11 +941,11 @@ static void task50_after_link_battle_save(u8 taskId)
             DestroyTask(taskId);
             break;
         case 5:
-            CreateTask(Task_SaveGame_UpdatedLinkRecords, 5);
+            CreateTask(Task_LinkSave, 5);
             data[0] = 6;
             break;
         case 6:
-            if (!FuncIsActiveTask(Task_SaveGame_UpdatedLinkRecords))
+            if (!FuncIsActiveTask(Task_LinkSave))
                 data[0] = 3;
             break;
         }
diff --git a/src/union_room.c b/src/union_room.c
index f19eba38d..876e11e19 100644
--- a/src/union_room.c
+++ b/src/union_room.c
@@ -2898,7 +2898,7 @@ static void Task_RunUnionRoom(u8 taskId)
                 if (var5 == -2 || var5 == IN_UNION_ROOM)
                 {
                     data->playerSendBuffer[0] = IN_UNION_ROOM;
-                    RfuPrepareSend0x2f00(data->playerSendBuffer);
+                    Rfu_SendPacket(data->playerSendBuffer);
                     StringCopy(gStringVar4, gUnknown_845842C[gLinkPlayers[0].gender]);
                     data->state = 32;
                 }
@@ -2913,7 +2913,7 @@ static void Task_RunUnionRoom(u8 taskId)
                     else
                     {
                         data->playerSendBuffer[0] = sPlayerCurrActivity | IN_UNION_ROOM;
-                        RfuPrepareSend0x2f00(data->playerSendBuffer);
+                        Rfu_SendPacket(data->playerSendBuffer);
                         data->state = 27;
                     }
                 }
@@ -2942,7 +2942,7 @@ static void Task_RunUnionRoom(u8 taskId)
         data->playerSendBuffer[0] = ACTIVITY_TRADE | IN_UNION_ROOM;
         data->playerSendBuffer[1] = sUnionRoomTrade.species;
         data->playerSendBuffer[2] = sUnionRoomTrade.level;
-        RfuPrepareSend0x2f00(data->playerSendBuffer);
+        Rfu_SendPacket(data->playerSendBuffer);
         data->state = 29;
         break;
     case 29:
@@ -3130,32 +3130,32 @@ static void Task_RunUnionRoom(u8 taskId)
                 if (!HasAtLeastTwoMonsOfLevel30OrLower())
                 {
                     data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM;
-                    RfuPrepareSend0x2f00(data->playerSendBuffer);
+                    Rfu_SendPacket(data->playerSendBuffer);
                     data->state = 10;
                     StringCopy(gStringVar4, gUnknown_84584C0);
                 }
                 else
                 {
-                    RfuPrepareSend0x2f00(data->playerSendBuffer);
+                    Rfu_SendPacket(data->playerSendBuffer);
                     data->state = 13;
                 }
             }
             else if (sPlayerCurrActivity == (ACTIVITY_CARD | IN_UNION_ROOM))
             {
-                RfuPrepareSend0x2f00(data->playerSendBuffer);
+                Rfu_SendPacket(data->playerSendBuffer);
                 ViewURoomPartnerTrainerCard(gStringVar4, data, MODE_PARENT);
                 data->state = 40;
             }
             else
             {
-                RfuPrepareSend0x2f00(data->playerSendBuffer);
+                Rfu_SendPacket(data->playerSendBuffer);
                 data->state = 13;
             }
             break;
         case 1:
         case -1:
             data->playerSendBuffer[0] = ACTIVITY_DECLINE | IN_UNION_ROOM;
-            RfuPrepareSend0x2f00(data->playerSendBuffer);
+            Rfu_SendPacket(data->playerSendBuffer);
             data->state = 10;
             GetYouDeclinedTheOfferMessage(gStringVar4, sPlayerCurrActivity);
             break;
@@ -3418,7 +3418,7 @@ void var_800D_set_xB(void)
 
 static void ReceiveUnionRoomActivityPacket(struct UnkStruct_URoom * uroom)
 {
-    if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == RFU_COMMAND_0x2f00)
+    if (gRecvCmds[1][1] != 0 && (gRecvCmds[1][0] & 0xFF00) == RFUCMD_SEND_PACKET)
     {
         uroom->recvActivityRequest[0] = gRecvCmds[1][1];
         if (gRecvCmds[1][1] == (ACTIVITY_TRADE | IN_UNION_ROOM))