Document Pokemon storage system

src/berry_pouch.c

@@ -1258,7 +1258,7 @@ static void Task_ContextMenu_FromPartyGiveMenu(u8 taskId)
 
 static void Task_ContextMenu_FromPokemonPC(u8 taskId)
 {
-    sResources->exitCallback = Cb2_ReturnToPSS;
+    sResources->exitCallback = CB2_ReturnToPokeStorage;
     gTasks[taskId].func = BerryPouch_StartFadeToExitCallback;
 }
 

src/box_party_pokemon_dropdown.c

@@ -3,210 +3,236 @@
 #include "box_party_pokemon_dropdown.h"
 #include "malloc.h"
 
-struct BPPD_MapRect
+//  Handles 3 particular tilemaps ("PKMN Data" text, party menu, close box
+//  button) used for Pokémon Storage System in a somewhat unusual way.
+//  For example, while the cursor is on the Close Box button it flashes between
+//  two states alternately. Both these states are their own part of the same
+//  tilemap that's always present. The utility shifts the tilemap up and down
+//  to show/hide the states, and limits the view with a rectangle that only
+//  reveals one at a time.
+
+struct TilemapUtil_RectData
 {
+    s16 x;
+    s16 y;
+    u16 width;
+    u16 height;
     s16 destX;
     s16 destY;
+};
+
+struct TilemapUtil
+{
+    struct TilemapUtil_RectData prev; // Only read in unused function
+    struct TilemapUtil_RectData cur;
+    const void *savedTilemap; // Only written in unused function
+    const void *tilemap;
+    u16 altWidth; // Never read
+    u16 altHeight; // Never read
     u16 width;
     u16 height;
-    s16 destX2;
-    s16 destY2;
+    u16 rowSize; // Never read
+    u8 tileSize;
+    u8 bg;
+    bool8 active; // Only read in unused function
 };
 
-struct BPPD_Struct
-{
-    struct BPPD_MapRect map1Rect;
-    struct BPPD_MapRect map2Rect;
-    const void *src1;
-    const void *src2;
-    u16 src1Height;
-    u16 src1Width;
-    u16 src2Width;
-    u16 src2Height;
-    u16 bytesPerRow;
-    u8 mapSize;
-    u8 bgId;
-    bool8 bgUpdateScheduled;
-};
+static EWRAM_DATA struct TilemapUtil *sTilemapUtil = NULL;
+static EWRAM_DATA u16 sNumTilemapUtilIds = 0;
 
-static EWRAM_DATA struct BPPD_Struct * sBoxPartyPokemonDropdownPtr = NULL;
-static EWRAM_DATA u16 sBoxPartyPokemonDropdownCount = 0;
-
-static void PushMap1(u8 idx);
-static void PushMap2(u8 idx);
+static void TilemapUtil_DrawPrev(u8 tilemapId);
+static void TilemapUtil_Draw(u8 tilemapId);
 
 static const struct {
-    u16 height;
     u16 width;
-} sBGdims[2][4] = {
+    u16 height;
+} sTilemapDimensions[2][4] = {
     {
-        {0x0100, 0x0100},
-        {0x0200, 0x0100},
-        {0x0100, 0x0200},
-        {0x0200, 0x0200}
+        { 256,  256},
+        { 512,  256},
+        { 256,  512},
+        { 512,  512}
     }, {
-        {0x0080, 0x0080},
-        {0x0100, 0x0100},
-        {0x0200, 0x0200},
-        {0x0400, 0x0400}
+        { 128,  128},
+        { 256,  256},
+        { 512,  512},
+        {1024, 1024}
     }
 };
 
-void AllocBoxPartyPokemonDropdowns(u8 num)
+void TilemapUtil_Init(u8 numTilemapIds)
 {
     u16 i;
-    sBoxPartyPokemonDropdownPtr = Alloc(num * sizeof(struct BPPD_Struct));
-    sBoxPartyPokemonDropdownCount = sBoxPartyPokemonDropdownPtr == NULL ? 0 : num;
-    for (i = 0; i < sBoxPartyPokemonDropdownCount; i++)
+    sTilemapUtil = Alloc(numTilemapIds * sizeof(struct TilemapUtil));
+    sNumTilemapUtilIds = sTilemapUtil == NULL ? 0 : numTilemapIds;
+    for (i = 0; i < sNumTilemapUtilIds; i++)
     {
-        sBoxPartyPokemonDropdownPtr[i].src1 = NULL;
-        sBoxPartyPokemonDropdownPtr[i].bgUpdateScheduled = FALSE;
+        sTilemapUtil[i].savedTilemap = NULL;
+        sTilemapUtil[i].active = FALSE;
     }
 }
 
-void FreeBoxPartyPokemonDropdowns(void)
+void TilemapUtil_Free(void)
 {
-    Free(sBoxPartyPokemonDropdownPtr);
+    Free(sTilemapUtil);
 }
 
-void CopyAllBoxPartyPokemonDropdownsToVram(void)
+// Unused
+void TilemapUtil_UpdateAll(void)
 {
     int i;
 
-    for (i = 0; i < sBoxPartyPokemonDropdownCount; i++)
+    for (i = 0; i < sNumTilemapUtilIds; i++)
     {
-        if (sBoxPartyPokemonDropdownPtr[i].bgUpdateScheduled == TRUE)
-            CopyBoxPartyPokemonDropdownToBgTilemapBuffer(i);
+        if (sTilemapUtil[i].active == TRUE)
+            TilemapUtil_Update(i);
     }
 }
 
-void SetBoxPartyPokemonDropdownMap2(u8 idx, u8 bgId, const void *src, u16 width, u16 height)
+void TilemapUtil_SetTilemap(u8 tilemapId, u8 bg, const void *tilemap, u16 width, u16 height)
 {
     u16 screenSize;
     u16 bgType;
 
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        sBoxPartyPokemonDropdownPtr[idx].src1 = NULL;
-        sBoxPartyPokemonDropdownPtr[idx].src2 = src;
-        sBoxPartyPokemonDropdownPtr[idx].bgId = bgId;
-        sBoxPartyPokemonDropdownPtr[idx].src2Width = width;
-        sBoxPartyPokemonDropdownPtr[idx].src2Height = height;
-        screenSize = GetBgAttribute(bgId, BG_ATTR_SCREENSIZE);
-        bgType = GetBgAttribute(bgId, BG_ATTR_BGTYPE);
-        sBoxPartyPokemonDropdownPtr[idx].src1Height = sBGdims[bgType][screenSize].height;
-        sBoxPartyPokemonDropdownPtr[idx].src1Width = sBGdims[bgType][screenSize].width;
+        sTilemapUtil[tilemapId].savedTilemap = NULL;
+        sTilemapUtil[tilemapId].tilemap = tilemap;
+        sTilemapUtil[tilemapId].bg = bg;
+        sTilemapUtil[tilemapId].width = width;
+        sTilemapUtil[tilemapId].height = height;
+
+        screenSize = GetBgAttribute(bg, BG_ATTR_SCREENSIZE);
+        bgType = GetBgAttribute(bg, BG_ATTR_BGTYPE);
+        sTilemapUtil[tilemapId].altWidth = sTilemapDimensions[bgType][screenSize].width;
+        sTilemapUtil[tilemapId].altHeight = sTilemapDimensions[bgType][screenSize].height;
         if (bgType != 0)
-            sBoxPartyPokemonDropdownPtr[idx].mapSize = 1;
+            sTilemapUtil[tilemapId].tileSize = 1;
         else
-            sBoxPartyPokemonDropdownPtr[idx].mapSize = 2;
-        sBoxPartyPokemonDropdownPtr[idx].bytesPerRow = width * sBoxPartyPokemonDropdownPtr[idx].mapSize;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.width = width;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.height = height;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX = 0;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY = 0;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 = 0;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 = 0;
-        sBoxPartyPokemonDropdownPtr[idx].map1Rect = sBoxPartyPokemonDropdownPtr[idx].map2Rect;
-        sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
+            sTilemapUtil[tilemapId].tileSize = 2;
+        sTilemapUtil[tilemapId].rowSize = width * sTilemapUtil[tilemapId].tileSize;
+        sTilemapUtil[tilemapId].cur.width = width;
+        sTilemapUtil[tilemapId].cur.height = height;
+        sTilemapUtil[tilemapId].cur.x = 0;
+        sTilemapUtil[tilemapId].cur.y = 0;
+        sTilemapUtil[tilemapId].cur.destX = 0;
+        sTilemapUtil[tilemapId].cur.destY = 0;
+        sTilemapUtil[tilemapId].prev = sTilemapUtil[tilemapId].cur;
+        sTilemapUtil[tilemapId].active = TRUE;
     }
 }
 
-void SetBoxPartyPokemonDropdownMap1Tiles(u8 idx, const void *src)
+// Unused
+void TilemapUtil_SetSavedMap(u8 tilemapId, const void *tilemap)
 {
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        sBoxPartyPokemonDropdownPtr[idx].src1 = src;
-        sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
+        sTilemapUtil[tilemapId].savedTilemap = tilemap;
+        sTilemapUtil[tilemapId].active = TRUE;
     }
 }
 
-void SetBoxPartyPokemonDropdownMap2Pos(u8 idx, u16 x, u16 y)
+void TilemapUtil_SetPos(u8 tilemapId, u16 destX, u16 destY)
 {
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 = x;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 = y;
-        sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
+        sTilemapUtil[tilemapId].cur.destX = destX;
+        sTilemapUtil[tilemapId].cur.destY = destY;
+        sTilemapUtil[tilemapId].active = TRUE;
     }
 }
 
-void SetBoxPartyPokemonDropdownMap2Rect(u8 idx, u16 x, u16 y, u16 width, u16 height)
+void TilemapUtil_SetRect(u8 tilemapId, u16 x, u16 y, u16 width, u16 height)
 {
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX = x;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY = y;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.width = width;
-        sBoxPartyPokemonDropdownPtr[idx].map2Rect.height = height;
-        sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
+        sTilemapUtil[tilemapId].cur.x = x;
+        sTilemapUtil[tilemapId].cur.y = y;
+        sTilemapUtil[tilemapId].cur.width = width;
+        sTilemapUtil[tilemapId].cur.height = height;
+        sTilemapUtil[tilemapId].active = TRUE;
     }
 }
 
-void AdjustBoxPartyPokemonDropdownPos(u8 idx, u8 op, s8 param)
+void TilemapUtil_Move(u8 tilemapId, u8 mode, s8 param)
 {
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        switch (op)
+        switch (mode)
         {
-        case BPPD_MOVE_INNER_LEFT:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 += param;
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.width -= param;
+        case 0:
+            sTilemapUtil[tilemapId].cur.destX += param;
+            sTilemapUtil[tilemapId].cur.width -= param;
             break;
-        case BPPD_MOVE_OUTER_LEFT:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX += param;
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.width += param;
+        case 1:
+            sTilemapUtil[tilemapId].cur.x += param;
+            sTilemapUtil[tilemapId].cur.width += param;
             break;
-        case BPPD_MOVE_INNER_TOP:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 += param;
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.height -= param;
+        case 2:
+            sTilemapUtil[tilemapId].cur.destY += param;
+            sTilemapUtil[tilemapId].cur.height -= param;
             break;
-        case BPPD_MOVE_OUTER_TOP:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY -= param;
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.height += param;
+        case 3: // this is the only mode ever used
+            sTilemapUtil[tilemapId].cur.y -= param;
+            sTilemapUtil[tilemapId].cur.height += param;
             break;
-        case BPPD_MOVE_INNER_X:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 += param;
+        case 4:
+            sTilemapUtil[tilemapId].cur.destX += param;
             break;
-        case BPPD_MOVE_INNER_Y:
-            sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 += param;
+        case 5:
+            sTilemapUtil[tilemapId].cur.destY += param;
             break;
         }
-        sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
+        sTilemapUtil[tilemapId].active = TRUE;
     }
 }
 
-void CopyBoxPartyPokemonDropdownToBgTilemapBuffer(u8 idx)
+void TilemapUtil_Update(u8 tilemapId)
 {
-    if (idx < sBoxPartyPokemonDropdownCount)
+    if (tilemapId < sNumTilemapUtilIds)
     {
-        if (sBoxPartyPokemonDropdownPtr[idx].src1 != NULL)
-            PushMap1(idx);
-        PushMap2(idx);
-        sBoxPartyPokemonDropdownPtr[idx].map1Rect = sBoxPartyPokemonDropdownPtr[idx].map2Rect;
+        if (sTilemapUtil[tilemapId].savedTilemap != NULL) // Always false
+            TilemapUtil_DrawPrev(tilemapId);
+        TilemapUtil_Draw(tilemapId);
+        sTilemapUtil[tilemapId].prev = sTilemapUtil[tilemapId].cur;
     }
 }
 
-static void PushMap1(u8 idx)
+// Never called, see TilemapUtil_Update
+static void TilemapUtil_DrawPrev(u8 tilemapId)
 {
     int i;
-    int run = sBoxPartyPokemonDropdownPtr[idx].mapSize * sBoxPartyPokemonDropdownPtr[idx].src1Height;
-    const void *addr = sBoxPartyPokemonDropdownPtr[idx].src1 + run * sBoxPartyPokemonDropdownPtr[idx].map1Rect.destY2 + sBoxPartyPokemonDropdownPtr[idx].map1Rect.destX2 * sBoxPartyPokemonDropdownPtr[idx].mapSize;
-    for (i = 0; i < sBoxPartyPokemonDropdownPtr[idx].map1Rect.height; i++)
+    int rowSize = sTilemapUtil[tilemapId].tileSize * sTilemapUtil[tilemapId].altWidth;
+    const void *tiles = sTilemapUtil[tilemapId].savedTilemap
+                        + rowSize * sTilemapUtil[tilemapId].prev.destY
+                        + sTilemapUtil[tilemapId].prev.destX * sTilemapUtil[tilemapId].tileSize;
+    for (i = 0; i < sTilemapUtil[tilemapId].prev.height; i++)
     {
-        CopyToBgTilemapBufferRect(sBoxPartyPokemonDropdownPtr[idx].bgId, addr, sBoxPartyPokemonDropdownPtr[idx].map1Rect.destX2, sBoxPartyPokemonDropdownPtr[idx].map1Rect.destY2 + i, sBoxPartyPokemonDropdownPtr[idx].map1Rect.width, 1);
-        addr += run;
+        CopyToBgTilemapBufferRect(sTilemapUtil[tilemapId].bg,
+                                  tiles,
+                                  sTilemapUtil[tilemapId].prev.destX,
+                                  sTilemapUtil[tilemapId].prev.destY + i,
+                                  sTilemapUtil[tilemapId].prev.width,
+                                  1);
+        tiles += rowSize;
     }
 }
 
-static void PushMap2(u8 idx)
+static void TilemapUtil_Draw(u8 tilemapId)
 {
     int i;
-    int run = sBoxPartyPokemonDropdownPtr[idx].mapSize * sBoxPartyPokemonDropdownPtr[idx].src2Width;
-    const void *addr = sBoxPartyPokemonDropdownPtr[idx].src2 + run * sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY + sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX * sBoxPartyPokemonDropdownPtr[idx].mapSize;
-    for (i = 0; i < sBoxPartyPokemonDropdownPtr[idx].map2Rect.height; i++)
+    int rowSize = sTilemapUtil[tilemapId].tileSize * sTilemapUtil[tilemapId].width;
+    const void *tiles = sTilemapUtil[tilemapId].tilemap
+                        + rowSize * sTilemapUtil[tilemapId].cur.y
+                        + sTilemapUtil[tilemapId].cur.x * sTilemapUtil[tilemapId].tileSize;
+    for (i = 0; i < sTilemapUtil[tilemapId].cur.height; i++)
     {
-        CopyToBgTilemapBufferRect(sBoxPartyPokemonDropdownPtr[idx].bgId, addr, sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2, sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 + i, sBoxPartyPokemonDropdownPtr[idx].map2Rect.width, 1);
-        addr += run;
+        CopyToBgTilemapBufferRect(sTilemapUtil[tilemapId].bg,
+                                  tiles,
+                                  sTilemapUtil[tilemapId].cur.destX,
+                                  sTilemapUtil[tilemapId].cur.destY + i,
+                                  sTilemapUtil[tilemapId].cur.width,
+                                  1);
+        tiles += rowSize;
     }
 }

src/graphics.c

@@ -1251,13 +1251,11 @@ const u32 gPokeSummary_StatusAilmentIconTiles[] = INCBIN_U32("graphics/interface
 const u16 gDexScreen_TopMenuIconPals_AtoZ[] = INCBIN_U16("graphics/pokedex/cat_icon_abc.gbapal");
 const u32 gDexScreen_TopMenuIconTiles_AtoZ[] = INCBIN_U32("graphics/pokedex/cat_icon_abc.4bpp.lz");
 
-const u16 gPSSMenu_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal1.gbapal");
-const u16 gUnknown_8E9C3F8[] = INCBIN_U16("graphics/interface/box_tiles_pal2.gbapal");
-const u16 gUnknown_8E9C418[] = INCBIN_U16("graphics/interface/box_tiles_pal3.gbapal");
-const u32 gPSSMenu_Gfx[] = INCBIN_U32("graphics/interface/box_tiles.4bpp.lz");
-
-const u32 gUnknown_8E9CAEC[] = INCBIN_U32("graphics/unknown/unknown_E9CAEC.bin.lz");
-
+const u16 gPokeStoragePartyMenu_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal1.gbapal");
+const u16 gPokeStorageInterface_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal2.gbapal");
+const u16 gPokeStorageInterface_NoDisplayMon_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal3.gbapal");
+const u32 gPokeStorageMenu_Gfx[] = INCBIN_U32("graphics/interface/box_tiles.4bpp.lz");
+const u32 gPokeStoragePartyMenu_Tilemap[] = INCBIN_U32("graphics/unknown/unknown_E9CAEC.bin.lz");
 const u16 gMonMarkingsMenu_Pal[] = INCBIN_U16("graphics/misc/markings2.gbapal");
 const u16 gMonMarkingsMenu_Gfx[] = INCBIN_U16("graphics/misc/markings2.4bpp");
 

src/item_menu.c

@@ -1784,7 +1784,7 @@ static void GoToBerryPouch_PCBox(void)
 
 static void ReturnToBagMenuFromSubmenu_PCBox(void)
 {
-    GoToBagMenu(ITEMMENULOCATION_PCBOX, OPEN_BAG_LAST, Cb2_ReturnToPSS);
+    GoToBagMenu(ITEMMENULOCATION_PCBOX, OPEN_BAG_LAST, CB2_ReturnToPokeStorage);
 }
 
 static void Task_ItemContext_Sell(u8 taskId)

src/pokemon_storage_system_2.c

@@ -16,22 +16,20 @@
 #include "constants/help_system.h"
 
 static EWRAM_DATA u8 sPreviousBoxOption = 0;
-static EWRAM_DATA struct ChooseBoxMenu *sBoxSelectionPopupSpriteManager = NULL;
+static EWRAM_DATA struct ChooseBoxMenu *sChooseBoxMenu = NULL;
 
-static void PSS_CreatePCMenu(u8 whichMenu, s16 *windowIdPtr);
+static void CreatePCMainMenu(u8 whichMenu, s16 *windowIdPtr);
 static void ChooseBoxMenu_CreateSprites(u8 curBox);
-static void sub_808CBA4(void);
-static void UpdateBoxNameAndCountSprite_WraparoundRight(void);
-static void UpdateBoxNameAndCountSprite_WraparoundLeft(void);
-static void PrintBoxNameAndCountToSprite(void);
-static void PrintToSpriteWithTagUnk0240(const u8 *a0, u16 x, u16 y);
-static void sub_808CD64(struct Sprite *sprite);
+static void ChooseBoxMenu_DestroySprites(void);
+static void ChooseBoxMenu_MoveRight(void);
+static void ChooseBoxMenu_MoveLeft(void);
+static void ChooseBoxMenu_PrintBoxNameAndCount(void);
+static void ChooseBoxMenu_PrintTextToSprite(const u8 *a0, u16 x, u16 y);
+static void SpriteCB_ChooseBoxArrow(struct Sprite *sprite);
 
-// Forward declarations
-
-static const u16 sBoxSelectionPopupPalette[];
-static const u16 sBoxSelectionPopupCenterTiles[];
-static const u16 sBoxSelectionPopupSidesTiles[];
+static const u16 sChooseBoxMenu_Pal[];
+static const u8 sChooseBoxMenuCenter_Gfx[];
+static const u8 sChooseBoxMenuCorners_Gfx[];
 
 struct {
     const u8 *text;
@@ -44,7 +42,7 @@ struct {
     [OPTION_EXIT]       = {gText_SeeYa,           gText_SeeYaDescription}
 };
 
-void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero2, u8 *buffer, s32 bytesToBuffer)
+void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero2, u8 *unused, s32 bytesToBuffer)
 {
     s32 i, tileBytesToBuffer, remainingBytes;
     u16 windowId;
@@ -90,7 +88,7 @@ void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero
     RemoveWindow(windowId);
 }
 
-static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 rise, u8 bgClr, u8 fgClr, u8 shClr, u8 *buffer)
+static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 offset, u8 bgColor, u8 fgColor, u8 shadowColor, u8 *unused)
 {
     u32 var;
     u8 windowId;
@@ -102,15 +100,15 @@ static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 rise, u8
     winTemplate.height = 2;
     var = winTemplate.width * 32;
     windowId = AddWindow(&winTemplate);
-    FillWindowPixelBuffer(windowId, PIXEL_FILL(bgClr));
+    FillWindowPixelBuffer(windowId, PIXEL_FILL(bgColor));
     tileData1 = (u8 *)GetWindowAttribute(windowId, WINDOW_TILE_DATA);
     tileData2 = (winTemplate.width * 32) + tileData1;
-    txtColor[0] = bgClr;
-    txtColor[1] = fgClr;
-    txtColor[2] = shClr;
+    txtColor[0] = bgColor;
+    txtColor[1] = fgColor;
+    txtColor[2] = shadowColor;
     AddTextPrinterParameterized4(windowId, FONT_1, 0, 2, 0, 0, txtColor, -1, string);
     CpuCopy16(tileData1, dst, var);
-    CpuCopy16(tileData2, dst + rise, var);
+    CpuCopy16(tileData2, dst + offset, var);
     RemoveWindow(windowId);
 }
 
@@ -147,10 +145,8 @@ u8 CountPartyNonEggMons(void)
     for (i = 0, count = 0; i < PARTY_SIZE; i++)
     {
         if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
-            && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
-        {
+                && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
             count++;
-        }
     }
 
     return count;
@@ -163,12 +159,10 @@ u8 CountPartyAliveNonEggMonsExcept(u8 slotToIgnore)
     for (i = 0, count = 0; i < PARTY_SIZE; i++)
     {
         if (i != slotToIgnore
-            && GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
-            && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
-            && GetMonData(&gPlayerParty[i], MON_DATA_HP) != 0)
-        {
+                && GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
+                && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
+                && GetMonData(&gPlayerParty[i], MON_DATA_HP) != 0)
             count++;
-        }
     }
 
     return count;
@@ -186,9 +180,7 @@ u8 CountPartyMons(void)
     for (i = 0, count = 0; i < PARTY_SIZE; i++)
     {
         if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE)
-        {
             count++;
-        }
     }
 
     return count;
@@ -205,7 +197,8 @@ static u8 *StringCopyAndFillWithSpaces(u8 *dst, const u8 *src, u16 n)
     return str;
 }
 
-static void sub_808C25C(u16 *dest, u16 dest_left, u16 dest_top, const u16 *src, u16 src_left, u16 src_top, u16 dest_width, u16 dest_height, u16 src_width)
+// Unused
+static void UnusedWriteRectCpu(u16 *dest, u16 dest_left, u16 dest_top, const u16 *src, u16 src_left, u16 src_top, u16 dest_width, u16 dest_height, u16 src_width)
 {
     u16 i;
 
@@ -231,16 +224,6 @@ static void UnusedWriteRectDma(u16 *dest, u16 dest_left, u16 dest_top, u16 width
         Dma3FillLarge16_(0, dest, width);
 }
 
-
-//------------------------------------------------------------------------------
-//  SECTION: Main menu
-//
-//  The below functions generally handle the PC main menu where the main
-//  options can be selected (Withdraw, Deposit, etc.), as well as exiting
-//  Pokémon Storage back to this menu.
-//------------------------------------------------------------------------------
-
-
 enum {
     STATE_LOAD,
     STATE_FADE_IN,
@@ -263,7 +246,7 @@ static void Task_PCMainMenu(u8 taskId)
     {
     case STATE_LOAD:
         SetHelpContext(HELPCONTEXT_BILLS_PC);
-        PSS_CreatePCMenu(task->tSelectedOption, &task->tWindowId);
+        CreatePCMainMenu(task->tSelectedOption, &task->tWindowId);
         LoadStdWindowFrameGfx();
         DrawDialogueFrame(0, FALSE);
         FillWindowPixelBuffer(0, PIXEL_FILL(1));
@@ -274,9 +257,8 @@ static void Task_PCMainMenu(u8 taskId)
         break;
     case STATE_FADE_IN:
         if (IsWeatherNotFadingIn())
-        {
             task->tState++;
-        }
+
         break;
     case STATE_HANDLE_INPUT:
         task->tInput = Menu_ProcessInput();
@@ -305,14 +287,14 @@ static void Task_PCMainMenu(u8 taskId)
             DestroyTask(taskId);
             break;
         default:
-            if (task->tInput == 0 && CountPartyMons() == PARTY_SIZE)
+            if (task->tInput == OPTION_WITHDRAW && CountPartyMons() == PARTY_SIZE)
             {
                 // Can't withdraw
                 FillWindowPixelBuffer(0, PIXEL_FILL(1));
                 AddTextPrinterParameterized2(0, FONT_2, gText_PartyFull, 0, NULL, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
-                task->tState = 3;
+                task->tState = STATE_ERROR_MSG;
             }
-            else if (task->tInput == 1 && CountPartyMons() == 1)
+            else if (task->tInput == OPTION_DEPOSIT && CountPartyMons() == 1)
             {
                 // Can't deposit
                 FillWindowPixelBuffer(0, PIXEL_FILL(1));
@@ -362,7 +344,7 @@ static void Task_PCMainMenu(u8 taskId)
         if (!gPaletteFade.active)
         {
             CleanupOverworldWindowsAndTilemaps();
-            Cb2_EnterPSS(task->tInput);
+            EnterPokeStorage(task->tInput);
             DestroyTask(taskId);
         }
         break;
@@ -372,7 +354,7 @@ static void Task_PCMainMenu(u8 taskId)
 void ShowPokemonStorageSystemPC(void)
 {
     u8 taskId = CreateTask(Task_PCMainMenu, 80);
-    gTasks[taskId].tState = 0;
+    gTasks[taskId].tState = STATE_LOAD;
     gTasks[taskId].tSelectedOption = 0;
     LockPlayerFieldControls();
 }
@@ -384,14 +366,14 @@ static void FieldTask_ReturnToPcMenu(void)
 
     SetVBlankCallback(NULL);
     taskId = CreateTask(Task_PCMainMenu, 80);
-    gTasks[taskId].tState = 0;
+    gTasks[taskId].tState = STATE_LOAD;
     gTasks[taskId].tSelectedOption = sPreviousBoxOption;
     Task_PCMainMenu(taskId);
     SetVBlankCallback(vblankCb);
     FadeInFromBlack();
 }
 
-static const struct WindowTemplate sUnknown_83CDA48 = {
+static const struct WindowTemplate sWindowTemplate_MainMenu = {
     .bg = 0,
     .tilemapLeft = 1,
     .tilemapTop = 1,
@@ -401,14 +383,13 @@ static const struct WindowTemplate sUnknown_83CDA48 = {
     .baseBlock = 0x001
 };
 
-static void PSS_CreatePCMenu(u8 whichMenu, s16 *windowIdPtr)
+static void CreatePCMainMenu(u8 whichMenu, s16 *windowIdPtr)
 {
-    s16 windowId;
-    windowId = AddWindow(&sUnknown_83CDA48);
+    s16 windowId = AddWindow(&sWindowTemplate_MainMenu);
 
     DrawStdWindowFrame(windowId, FALSE);
-    PrintTextArray(windowId, FONT_2, GetMenuCursorDimensionByFont(FONT_2, 0), 2, 16, NELEMS(sMainMenuTexts), (void *)sMainMenuTexts);
-    Menu_InitCursor(windowId, FONT_2, 0, 2, 16, NELEMS(sMainMenuTexts), whichMenu);
+    PrintTextArray(windowId, FONT_2, GetMenuCursorDimensionByFont(FONT_2, 0), 2, 16, ARRAY_COUNT(sMainMenuTexts), (void *)sMainMenuTexts);
+    Menu_InitCursor(windowId, FONT_2, 0, 2, 16, ARRAY_COUNT(sMainMenuTexts), whichMenu);
     *windowIdPtr = windowId;
 }
 
@@ -439,54 +420,44 @@ void ResetPokemonStorageSystem(void)
         SetBoxWallpaper(boxId, boxId % (MAX_DEFAULT_WALLPAPER + 1));
 }
 
-
-//------------------------------------------------------------------------------
-//  SECTION: Choose Box menu
-//
-//  The below functions handle the popup menu that allows the player to cycle
-//  through the boxes and select one. Used when storing Pokémon in Deposit mode
-//  and for the Jump feature.
-//------------------------------------------------------------------------------
-
-
-void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *a0, u16 tileTag, u16 palTag, u8 a3, bool32 loadPal)
+void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *menu, u16 tileTag, u16 palTag, u8 subpriority, bool32 loadPal)
 {
     struct SpritePalette palette = {
-        sBoxSelectionPopupPalette, palTag
+        sChooseBoxMenu_Pal, palTag
     };
     struct SpriteSheet sheets[] = {
-        {sBoxSelectionPopupCenterTiles, 0x800, tileTag},
-        {sBoxSelectionPopupSidesTiles,  0x180, tileTag + 1},
+        {sChooseBoxMenuCenter_Gfx, 0x800, tileTag},
+        {sChooseBoxMenuCorners_Gfx,  0x180, tileTag + 1},
         {}
     };
 
-    if (loadPal)
+    if (loadPal) // Always false
         LoadSpritePalette(&palette);
 
     LoadSpriteSheets(sheets);
-    sBoxSelectionPopupSpriteManager = a0;
-    a0->tileTag = tileTag;
-    a0->paletteTag = palTag;
-    a0->subpriority = a3;
-    a0->loadedPalette = loadPal;
+    sChooseBoxMenu = menu;
+    menu->tileTag = tileTag;
+    menu->paletteTag = palTag;
+    menu->subpriority = subpriority;
+    menu->loadedPalette = loadPal;
 }
 
 void FreeBoxSelectionPopupSpriteGfx(void)
 {
-    if (sBoxSelectionPopupSpriteManager->loadedPalette)
-        FreeSpritePaletteByTag(sBoxSelectionPopupSpriteManager->paletteTag);
-    FreeSpriteTilesByTag(sBoxSelectionPopupSpriteManager->tileTag);
-    FreeSpriteTilesByTag(sBoxSelectionPopupSpriteManager->tileTag + 1);
+    if (sChooseBoxMenu->loadedPalette)
+        FreeSpritePaletteByTag(sChooseBoxMenu->paletteTag);
+    FreeSpriteTilesByTag(sChooseBoxMenu->tileTag);
+    FreeSpriteTilesByTag(sChooseBoxMenu->tileTag + 1);
 }
 
-void sub_808C940(u8 curBox)
+void CreateChooseBoxMenuSprites(u8 curBox)
 {
     ChooseBoxMenu_CreateSprites(curBox);
 }
 
-void sub_808C950(void)
+void DestroyChooseBoxMenuSprites(void)
 {
-    sub_808CBA4();
+    ChooseBoxMenu_DestroySprites();
 }
 
 u8 HandleBoxChooseSelectionInput(void)
@@ -494,60 +465,61 @@ u8 HandleBoxChooseSelectionInput(void)
     if (JOY_NEW(B_BUTTON))
     {
         PlaySE(SE_SELECT);
-        return 201;
+        return BOXID_CANCELED;
     }
     if (JOY_NEW(A_BUTTON))
     {
         PlaySE(SE_SELECT);
-        return sBoxSelectionPopupSpriteManager->curBox;
+        return sChooseBoxMenu->curBox;
     }
     if (JOY_NEW(DPAD_LEFT))
     {
         PlaySE(SE_SELECT);
-        UpdateBoxNameAndCountSprite_WraparoundLeft();
+        ChooseBoxMenu_MoveLeft();
     }
     else if (JOY_NEW(DPAD_RIGHT))
     {
         PlaySE(SE_SELECT);
-        UpdateBoxNameAndCountSprite_WraparoundRight();
+        ChooseBoxMenu_MoveRight();
     }
-    return 200;
+    return BOXID_NONE_CHOSEN;
 }
 
-static const union AnimCmd gUnknown_83CDA50[] = {
+static const union AnimCmd sAnim_ChooseBoxMenu_TopLeft[] = {
     ANIMCMD_FRAME( 0, 5),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_83CDA58[] = {
+static const union AnimCmd sAnim_ChooseBoxMenu_BottomLeft[] = {
     ANIMCMD_FRAME( 4, 5),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_83CDA60[] = {
+static const union AnimCmd sAnim_ChooseBoxMenu_TopRight[] = {
     ANIMCMD_FRAME( 6, 5),
     ANIMCMD_END
 };
 
-static const union AnimCmd gUnknown_83CDA68[] = {
+static const union AnimCmd sAnim_ChooseBoxMenu_BottomRight[] = {
     ANIMCMD_FRAME(10, 5),
     ANIMCMD_END
 };
 
-static const union AnimCmd *const gUnknown_83CDA70[] = {
-    gUnknown_83CDA50,
-    gUnknown_83CDA58,
-    gUnknown_83CDA60,
-    gUnknown_83CDA68
+static const union AnimCmd *const sAnims_ChooseBoxMenu[] = {
+    sAnim_ChooseBoxMenu_TopLeft,
+    sAnim_ChooseBoxMenu_BottomLeft,
+    sAnim_ChooseBoxMenu_TopRight,
+    sAnim_ChooseBoxMenu_BottomRight,
 };
 
-static const union AffineAnimCmd gUnknown_83CDA80[] = {
+static const union AffineAnimCmd sAffineAnim_ChooseBoxMenu[] = {
     AFFINEANIMCMD_FRAME(224, 224, 0, 0),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd *const gUnknown_83CDA90[] = {
-    gUnknown_83CDA80
+// Unused
+static const union AffineAnimCmd *const sAffineAnims_ChooseBoxMenu[] = {
+    sAffineAnim_ChooseBoxMenu
 };
 
 static void ChooseBoxMenu_CreateSprites(u8 curBox)
@@ -562,112 +534,112 @@ static void ChooseBoxMenu_CreateSprites(u8 curBox)
         0, 0, &oamData, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy
     };
     {
-    const u8 gUnknown_83CDA94[] = _("/30");
+    const u8 sText_OutOf30[] = _("/30");
 
-    sBoxSelectionPopupSpriteManager->curBox = curBox;
-    template.tileTag = sBoxSelectionPopupSpriteManager->tileTag;
-    template.paletteTag = sBoxSelectionPopupSpriteManager->paletteTag;
+    sChooseBoxMenu->curBox = curBox;
+    template.tileTag = sChooseBoxMenu->tileTag;
+    template.paletteTag = sChooseBoxMenu->paletteTag;
 
     spriteId = CreateSprite(&template, 160, 96, 0);
-    sBoxSelectionPopupSpriteManager->menuSprite = gSprites + spriteId;
+    sChooseBoxMenu->menuSprite = gSprites + spriteId;
 
-    // Manual subsprites
     oamData.shape = SPRITE_SHAPE(8x32);
     oamData.size = SPRITE_SIZE(8x32);
-    template.tileTag = sBoxSelectionPopupSpriteManager->tileTag + 1;
-    template.anims = gUnknown_83CDA70;
-    for (i = 0; i < 4; i++)
+    template.tileTag = sChooseBoxMenu->tileTag + 1;
+    template.anims = sAnims_ChooseBoxMenu;
+    for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->menuCornerSprites); i++)
     {
-        u16 r5;
-        spriteId = CreateSprite(&template, 124, 80, sBoxSelectionPopupSpriteManager->subpriority);
-        sBoxSelectionPopupSpriteManager->menuSideSprites[i] = gSprites + spriteId;
-        r5 = 0;
+        // corner sprites are created in order of top left, bottom left, top right, bottom right
+        u16 animNum;
+        spriteId = CreateSprite(&template, 124, 80, sChooseBoxMenu->subpriority); // place at top left
+        sChooseBoxMenu->menuCornerSprites[i] = &gSprites[spriteId];
+        animNum = 0;
         if (i & 2)
         {
-            sBoxSelectionPopupSpriteManager->menuSideSprites[i]->x = 196;
-            r5 = 2;
+            sChooseBoxMenu->menuCornerSprites[i]->x = 196; // move to bottom
+            animNum = 2;
         }
         if (i & 1)
         {
-            sBoxSelectionPopupSpriteManager->menuSideSprites[i]->y = 112;
-            sBoxSelectionPopupSpriteManager->menuSideSprites[i]->oam.size = SPRITE_SIZE(8x16);
-            r5++;
+            sChooseBoxMenu->menuCornerSprites[i]->y = 112; // move to right
+            sChooseBoxMenu->menuCornerSprites[i]->oam.size = SPRITE_SIZE(8x16);
+            animNum++;
         }
-        StartSpriteAnim(sBoxSelectionPopupSpriteManager->menuSideSprites[i], r5);
+        StartSpriteAnim(sChooseBoxMenu->menuCornerSprites[i], animNum);
     }
-    for (i = 0; i < 2; i++)
+    for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->arrowSprites); i++)
     {
-        sBoxSelectionPopupSpriteManager->arrowSprites[i] = CreateChooseBoxArrows(72 * i + 0x7c, 0x58, i, 0, sBoxSelectionPopupSpriteManager->subpriority);
-        if (sBoxSelectionPopupSpriteManager->arrowSprites[i])
+        sChooseBoxMenu->arrowSprites[i] = CreateChooseBoxArrows(72 * i + 124, 88, i, 0, sChooseBoxMenu->subpriority);
+        if (sChooseBoxMenu->arrowSprites[i])
         {
-            sBoxSelectionPopupSpriteManager->arrowSprites[i]->data[0] = (i == 0 ? -1 : 1);
-            sBoxSelectionPopupSpriteManager->arrowSprites[i]->callback = sub_808CD64;
+            sChooseBoxMenu->arrowSprites[i]->data[0] = (i == 0 ? -1 : 1);
+            sChooseBoxMenu->arrowSprites[i]->callback = SpriteCB_ChooseBoxArrow;
         }
     }
-    PrintBoxNameAndCountToSprite();
-    PrintToSpriteWithTagUnk0240(gUnknown_83CDA94, 5, 3);
+    ChooseBoxMenu_PrintBoxNameAndCount();
+    ChooseBoxMenu_PrintTextToSprite(sText_OutOf30, 5, 3);
     }
 }
 
-static void sub_808CBA4(void)
+static void ChooseBoxMenu_DestroySprites(void)
 {
     u16 i;
-    if (sBoxSelectionPopupSpriteManager->menuSprite)
+    if (sChooseBoxMenu->menuSprite)
     {
-        DestroySprite(sBoxSelectionPopupSpriteManager->menuSprite);
-        sBoxSelectionPopupSpriteManager->menuSprite = NULL;
+        DestroySprite(sChooseBoxMenu->menuSprite);
+        sChooseBoxMenu->menuSprite = NULL;
     }
-    for (i = 0; i < 4; i++)
+    for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->menuCornerSprites); i++)
     {
-        if (sBoxSelectionPopupSpriteManager->menuSideSprites[i])
+        if (sChooseBoxMenu->menuCornerSprites[i])
         {
-            DestroySprite(sBoxSelectionPopupSpriteManager->menuSideSprites[i]);
-            sBoxSelectionPopupSpriteManager->menuSideSprites[i] = NULL;
+            DestroySprite(sChooseBoxMenu->menuCornerSprites[i]);
+            sChooseBoxMenu->menuCornerSprites[i] = NULL;
         }
     }
-    for (i = 0; i < 2; i++)
+    for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->arrowSprites); i++)
     {
-        if (sBoxSelectionPopupSpriteManager->arrowSprites[i])
-            DestroySprite(sBoxSelectionPopupSpriteManager->arrowSprites[i]);
+        if (sChooseBoxMenu->arrowSprites[i])
+            DestroySprite(sChooseBoxMenu->arrowSprites[i]);
     }
 }
 
-static void UpdateBoxNameAndCountSprite_WraparoundRight(void)
+static void ChooseBoxMenu_MoveRight(void)
 {
-    if (++sBoxSelectionPopupSpriteManager->curBox >= TOTAL_BOXES_COUNT)
-        sBoxSelectionPopupSpriteManager->curBox = 0;
-    PrintBoxNameAndCountToSprite();
+    if (++sChooseBoxMenu->curBox >= TOTAL_BOXES_COUNT)
+        sChooseBoxMenu->curBox = 0;
+    ChooseBoxMenu_PrintBoxNameAndCount();
 }
 
-static void UpdateBoxNameAndCountSprite_WraparoundLeft(void)
+static void ChooseBoxMenu_MoveLeft(void)
 {
-    sBoxSelectionPopupSpriteManager->curBox = (sBoxSelectionPopupSpriteManager->curBox == 0 ? TOTAL_BOXES_COUNT - 1 : sBoxSelectionPopupSpriteManager->curBox - 1);
-    PrintBoxNameAndCountToSprite();
+    sChooseBoxMenu->curBox = (sChooseBoxMenu->curBox == 0 ? TOTAL_BOXES_COUNT - 1 : sChooseBoxMenu->curBox - 1);
+    ChooseBoxMenu_PrintBoxNameAndCount();
 }
 
-static void PrintBoxNameAndCountToSprite(void)
+static void ChooseBoxMenu_PrintBoxNameAndCount(void)
 {
-    u8 nPokemonInBox = CountMonsInBox(sBoxSelectionPopupSpriteManager->curBox);
-    u8 *boxName = StringCopy(sBoxSelectionPopupSpriteManager->strbuf, GetBoxNamePtr(sBoxSelectionPopupSpriteManager->curBox));
+    u8 numMonInBox = CountMonsInBox(sChooseBoxMenu->curBox);
+    u8 *boxName = StringCopy(sChooseBoxMenu->strbuf, GetBoxNamePtr(sChooseBoxMenu->curBox));
 
-    while (boxName < sBoxSelectionPopupSpriteManager->strbuf + BOX_NAME_LENGTH)
+    while (boxName < sChooseBoxMenu->strbuf + BOX_NAME_LENGTH)
         *boxName++ = CHAR_SPACE;
     *boxName = EOS;
 
-    PrintToSpriteWithTagUnk0240(sBoxSelectionPopupSpriteManager->strbuf, 0, 1);
+    ChooseBoxMenu_PrintTextToSprite(sChooseBoxMenu->strbuf, 0, 1);
 
-    ConvertIntToDecimalStringN(sBoxSelectionPopupSpriteManager->strbuf, nPokemonInBox, STR_CONV_MODE_RIGHT_ALIGN, 2);
+    ConvertIntToDecimalStringN(sChooseBoxMenu->strbuf, numMonInBox, STR_CONV_MODE_RIGHT_ALIGN, 2);
 
-    PrintToSpriteWithTagUnk0240(sBoxSelectionPopupSpriteManager->strbuf, 3, 3);
+    ChooseBoxMenu_PrintTextToSprite(sChooseBoxMenu->strbuf, 3, 3);
 }
 
-static void PrintToSpriteWithTagUnk0240(const u8 *str, u16 x, u16 y)
+static void ChooseBoxMenu_PrintTextToSprite(const u8 *str, u16 x, u16 y)
 {
-    u16 tileStart = GetSpriteTileStartByTag(sBoxSelectionPopupSpriteManager->tileTag);
-    PrintStringToBufferCopyNow(str, (void *)(OBJ_VRAM0 + tileStart * 32 + 256 * y + 32 * x), 0x100, TEXT_COLOR_RED, TEXT_DYNAMIC_COLOR_6, TEXT_DYNAMIC_COLOR_5, sBoxSelectionPopupSpriteManager->buffer);
+    void *dst = (void *)(OBJ_VRAM0 + GetSpriteTileStartByTag(sChooseBoxMenu->tileTag) * 32 + 256 * y + 32 * x);
+    PrintStringToBufferCopyNow(str, dst, 0x100, TEXT_COLOR_RED, TEXT_DYNAMIC_COLOR_6, TEXT_DYNAMIC_COLOR_5, sChooseBoxMenu->buffer);
 }
 
-static void sub_808CD64(struct Sprite *sprite)
+static void SpriteCB_ChooseBoxArrow(struct Sprite *sprite)
 {
     if (++sprite->data[1] > 3)
     {
@@ -681,8 +653,8 @@ static void sub_808CD64(struct Sprite *sprite)
     }
 }
 
-// Forward-declared rodata
+// Unused, since LoadChooseBoxMenuGfx is always called with `loadPal` as false
+static const u16 sChooseBoxMenu_Pal[] = INCBIN_U16("graphics/interface/pss_unk_83CDA98.gbapal");
 
-static const u16 sBoxSelectionPopupPalette[] = INCBIN_U16("graphics/interface/pss_unk_83CDA98.gbapal");
-static const u16 sBoxSelectionPopupCenterTiles[] = INCBIN_U16("graphics/interface/pss_unk_83CDAB8.4bpp");
-static const u16 sBoxSelectionPopupSidesTiles[] = INCBIN_U16("graphics/interface/pss_unk_83CE2B8.4bpp");
+static const u8 sChooseBoxMenuCenter_Gfx[] = INCBIN_U8("graphics/interface/pss_unk_83CDAB8.4bpp");
+static const u8 sChooseBoxMenuCorners_Gfx[] = INCBIN_U8("graphics/interface/pss_unk_83CE2B8.4bpp");

src/pokemon_storage_system_6.c

@@ -8,115 +8,115 @@
 
 void InitMenu(void)
 {
-    gPSSData->menuItemsCount = 0;
-    gPSSData->menuWidth = 0;
-    gPSSData->menuWindow.bg = 0;
-    gPSSData->menuWindow.paletteNum = 15;
-    gPSSData->menuWindow.baseBlock = 92;
+    gStorage->menuItemsCount = 0;
+    gStorage->menuWidth = 0;
+    gStorage->menuWindow.bg = 0;
+    gStorage->menuWindow.paletteNum = 15;
+    gStorage->menuWindow.baseBlock = 92;
 }
 
 static const u8 *const sMenuTexts[] = {
-    [PC_TEXT_CANCEL]     = gPCText_Cancel,
-    [PC_TEXT_STORE]      = gPCText_Store,
-    [PC_TEXT_WITHDRAW]   = gPCText_Withdraw,
-    [PC_TEXT_MOVE]       = gPCText_Move,
-    [PC_TEXT_SHIFT]      = gPCText_Shift,
-    [PC_TEXT_PLACE]      = gPCText_Place,
-    [PC_TEXT_SUMMARY]    = gPCText_Summary,
-    [PC_TEXT_RELEASE]    = gPCText_Release,
-    [PC_TEXT_MARK]       = gPCText_Mark,
-    [PC_TEXT_JUMP]       = gPCText_Jump,
-    [PC_TEXT_WALLPAPER]  = gPCText_Wallpaper,
-    [PC_TEXT_NAME]       = gPCText_Name,
-    [PC_TEXT_TAKE]       = gPCText_Take,
-    [PC_TEXT_GIVE]       = gPCText_Give,
-    [PC_TEXT_GIVE2]      = gPCText_Give,
-    [PC_TEXT_SWITCH]     = gPCText_Switch,
-    [PC_TEXT_BAG]        = gPCText_Bag,
-    [PC_TEXT_INFO]       = gPCText_Info,
-    [PC_TEXT_SCENERY1]   = gPCText_Scenery1,
-    [PC_TEXT_SCENERY2]   = gPCText_Scenery2,
-    [PC_TEXT_SCENERY3]   = gPCText_Scenery3,
-    [PC_TEXT_ETCETERA]   = gPCText_Etcetera,
-    [PC_TEXT_FOREST]     = gPCText_Forest,
-    [PC_TEXT_CITY]       = gPCText_City,
-    [PC_TEXT_DESERT]     = gPCText_Desert,
-    [PC_TEXT_SAVANNA]    = gPCText_Savanna,
-    [PC_TEXT_CRAG]       = gPCText_Crag,
-    [PC_TEXT_VOLCANO]    = gPCText_Volcano,
-    [PC_TEXT_SNOW]       = gPCText_Snow,
-    [PC_TEXT_CAVE]       = gPCText_Cave,
-    [PC_TEXT_BEACH]      = gPCText_Beach,
-    [PC_TEXT_SEAFLOOR]   = gPCText_Seafloor,
-    [PC_TEXT_RIVER]      = gPCText_River,
-    [PC_TEXT_SKY]        = gPCText_Sky,
-    [PC_TEXT_POLKADOT]   = gPCText_PolkaDot,
-    [PC_TEXT_POKECENTER] = gPCText_Pokecenter,
-    [PC_TEXT_MACHINE]    = gPCText_Machine,
-    [PC_TEXT_SIMPLE]     = gPCText_Simple,
+    [MENU_TEXT_CANCEL]     = gPCText_Cancel,
+    [MENU_TEXT_STORE]      = gPCText_Store,
+    [MENU_TEXT_WITHDRAW]   = gPCText_Withdraw,
+    [MENU_TEXT_MOVE]       = gPCText_Move,
+    [MENU_TEXT_SHIFT]      = gPCText_Shift,
+    [MENU_TEXT_PLACE]      = gPCText_Place,
+    [MENU_TEXT_SUMMARY]    = gPCText_Summary,
+    [MENU_TEXT_RELEASE]    = gPCText_Release,
+    [MENU_TEXT_MARK]       = gPCText_Mark,
+    [MENU_TEXT_JUMP]       = gPCText_Jump,
+    [MENU_TEXT_WALLPAPER]  = gPCText_Wallpaper,
+    [MENU_TEXT_NAME]       = gPCText_Name,
+    [MENU_TEXT_TAKE]       = gPCText_Take,
+    [MENU_TEXT_GIVE]       = gPCText_Give,
+    [MENU_TEXT_GIVE2]      = gPCText_Give,
+    [MENU_TEXT_SWITCH]     = gPCText_Switch,
+    [MENU_TEXT_BAG]        = gPCText_Bag,
+    [MENU_TEXT_INFO]       = gPCText_Info,
+    [MENU_TEXT_SCENERY_1]  = gPCText_Scenery1,
+    [MENU_TEXT_SCENERY_2]  = gPCText_Scenery2,
+    [MENU_TEXT_SCENERY_3]  = gPCText_Scenery3,
+    [MENU_TEXT_ETCETERA]   = gPCText_Etcetera,
+    [MENU_TEXT_FOREST]     = gPCText_Forest,
+    [MENU_TEXT_CITY]       = gPCText_City,
+    [MENU_TEXT_DESERT]     = gPCText_Desert,
+    [MENU_TEXT_SAVANNA]    = gPCText_Savanna,
+    [MENU_TEXT_CRAG]       = gPCText_Crag,
+    [MENU_TEXT_VOLCANO]    = gPCText_Volcano,
+    [MENU_TEXT_SNOW]       = gPCText_Snow,
+    [MENU_TEXT_CAVE]       = gPCText_Cave,
+    [MENU_TEXT_BEACH]      = gPCText_Beach,
+    [MENU_TEXT_SEAFLOOR]   = gPCText_Seafloor,
+    [MENU_TEXT_RIVER]      = gPCText_River,
+    [MENU_TEXT_SKY]        = gPCText_Sky,
+    [MENU_TEXT_POLKADOT]   = gPCText_PolkaDot,
+    [MENU_TEXT_POKECENTER] = gPCText_Pokecenter,
+    [MENU_TEXT_MACHINE]    = gPCText_Machine,
+    [MENU_TEXT_SIMPLE]     = gPCText_Simple,
 };
 
 void SetMenuText(u8 textId)
 {
-    if (gPSSData->menuItemsCount < ARRAY_COUNT(gPSSData->menuItems))
+    if (gStorage->menuItemsCount < ARRAY_COUNT(gStorage->menuItems))
     {
         u8 len;
-        struct StorageMenu *menu = &gPSSData->menuItems[gPSSData->menuItemsCount];
+        struct StorageMenu *menu = &gStorage->menuItems[gStorage->menuItemsCount];
 
         menu->text = sMenuTexts[textId];
         menu->textId = textId;
         len = StringLength(menu->text);
-        if (len > gPSSData->menuWidth)
-            gPSSData->menuWidth = len;
+        if (len > gStorage->menuWidth)
+            gStorage->menuWidth = len;
 
-        gPSSData->menuItemsCount++;
+        gStorage->menuItemsCount++;
     }
 }
 
-s8 sub_8094E50(u8 arg0)
+s8 GetMenuItemTextId(u8 menuIndex)
 {
-    if (arg0 >= gPSSData->menuItemsCount)
-        return -1;
+    if (menuIndex >= gStorage->menuItemsCount)
+        return MENU_B_PRESSED;
     else
-        return gPSSData->menuItems[arg0].textId;
+        return gStorage->menuItems[menuIndex].textId;
 }
 
 void AddMenu(void)
 {
-    gPSSData->menuWindow.width = gPSSData->menuWidth + 2;
-    gPSSData->menuWindow.height = 2 * gPSSData->menuItemsCount;
-    gPSSData->menuWindow.tilemapLeft = 29 - gPSSData->menuWindow.width;
-    gPSSData->menuWindow.tilemapTop = 15 - gPSSData->menuWindow.height;
-    gPSSData->menuWindowId = AddWindow(&gPSSData->menuWindow);
-    ClearWindowTilemap(gPSSData->menuWindowId);
-    DrawStdFrameWithCustomTileAndPalette(gPSSData->menuWindowId, FALSE, 0x00b, 14);
-    PrintTextArray(gPSSData->menuWindowId, FONT_1, 8, 2, 16, gPSSData->menuItemsCount, (void *)gPSSData->menuItems);
-    Menu_InitCursor(gPSSData->menuWindowId, FONT_1, 0, 2, 16, gPSSData->menuItemsCount, 0);
+    gStorage->menuWindow.width = gStorage->menuWidth + 2;
+    gStorage->menuWindow.height = 2 * gStorage->menuItemsCount;
+    gStorage->menuWindow.tilemapLeft = 29 - gStorage->menuWindow.width;
+    gStorage->menuWindow.tilemapTop = 15 - gStorage->menuWindow.height;
+    gStorage->menuWindowId = AddWindow(&gStorage->menuWindow);
+    ClearWindowTilemap(gStorage->menuWindowId);
+    DrawStdFrameWithCustomTileAndPalette(gStorage->menuWindowId, FALSE, 11, 14);
+    PrintTextArray(gStorage->menuWindowId, FONT_1, 8, 2, 16, gStorage->menuItemsCount, (void *)gStorage->menuItems);
+    Menu_InitCursor(gStorage->menuWindowId, FONT_1, 0, 2, 16, gStorage->menuItemsCount, 0);
     ScheduleBgCopyTilemapToVram(0);
-    gPSSData->menuUnusedField = 0;
+    gStorage->menuUnusedField = 0;
 }
 
-bool8 sub_8094F90(void)
+bool8 IsMenuLoading(void)
 {
-    // Some debug flag?
+    // Possibly stubbed out debug code?
     return FALSE;
 }
 
-s16 sub_8094F94(void)
+s16 HandleMenuInput(void)
 {
-    s32 textId = -2;
+    s32 input = MENU_NOTHING_CHOSEN;
 
     do
     {
         if (JOY_NEW(A_BUTTON))
         {
-            textId = Menu_GetCursorPos();
+            input = Menu_GetCursorPos();
             break;
         }
         else if (JOY_NEW(B_BUTTON))
         {
             PlaySE(SE_SELECT);
-            textId = -1;
+            input = MENU_B_PRESSED;
         }
 
         if (JOY_NEW(DPAD_UP))
@@ -129,19 +129,19 @@ s16 sub_8094F94(void)
             PlaySE(SE_SELECT);
             Menu_MoveCursor(1);
         }
-    } while (0);
+    } while (FALSE);
 
-    if (textId != -2)
-        sub_8095024();
+    if (input != MENU_NOTHING_CHOSEN)
+        RemoveMenu();
 
-    if (textId >= 0)
-        textId = gPSSData->menuItems[textId].textId;
+    if (input >= 0)
+        input = gStorage->menuItems[input].textId;
 
-    return textId;
+    return input;
 }
 
-void sub_8095024(void)
+void RemoveMenu(void)
 {
-    ClearStdWindowAndFrameToTransparent(gPSSData->menuWindowId, TRUE);
-    RemoveWindow(gPSSData->menuWindowId);
+    ClearStdWindowAndFrameToTransparent(gStorage->menuWindowId, TRUE);
+    RemoveWindow(gStorage->menuWindowId);
 }

src/pokemon_storage_system_7.c

@@ -5,50 +5,48 @@
 #include "pokemon_storage_system_internal.h"
 #include "text_window.h"
 
-struct MoveMons
+static EWRAM_DATA struct
 {
-    u8 field_0;
+    u8 funcId;
     u8 state;
-    u8 fromRow;
     u8 fromColumn;
-    u8 toRow;
+    u8 fromRow;
     u8 toColumn;
-    u8 field_6;
-    u8 field_7;
-    u8 minRow;
+    u8 toRow;
+    u8 cursorColumn;
+    u8 cursorRow;
     u8 minColumn;
+    u8 minRow;
+    u8 columnsTotal;
     u8 rowsTotal;
-    u8 columsTotal;
     u16 bgX;
     u16 bgY;
-    u16 field_10;
+    u16 bgMoveSteps;
     struct BoxPokemon boxMons[IN_BOX_COUNT];
-};
+} *sMultiMove = NULL;
 
-static EWRAM_DATA struct MoveMons *sMoveMonsPtr = NULL;
+static bool8 MultiMove_Function_Start(void);
+static bool8 MultiMove_Function_Single(void);
+static bool8 MultiMove_Function_ChangeSelection(void);
+static bool8 MultiMove_Function_GrabSelection(void);
+static bool8 MultiMove_Function_MoveMons(void);
+static bool8 MultiMove_Function_PlaceMons(void);
+static void MultiMove_UpdateSelectedIcons(void);
+static void MultiMove_SelectColumn(u8 column, u8 minRow, u8 maxRow);
+static void MultiMove_SelectRow(u8 row, u8 minColumn, u8 maxColumn);
+static void MultiMove_DeselectColumn(u8 arg0, u8 minRow, u8 maxRow);
+static void MultiMove_DeselectRow(u8 row, u8 minColumn, u8 maxColumn);
+static void MultiMove_SetIconToBg(u8 x, u8 y);
+static void MultiMove_ClearIconFromBg(u8 x, u8 y);
+static void MultiMove_InitBg(u16 bgX, u16 bgY, u16 duration);
+static u8 MultiMove_UpdateBg(void);
+static void MultiMove_GetMonsFromSelection(void);
+static void MultiMove_RemoveMonsFromBox(void);
+static void MultiMove_CreatePlacedMonIcons(void);
+static void MultiMove_SetPlacedMonData(void);
+static void MultiMove_ResetBg(void);
 
-static bool8 sub_8095138(void);
-static bool8 sub_8095234(void);
-static bool8 sub_80952A0(void);
-static bool8 sub_8095314(void);
-static bool8 sub_8095394(void);
-static bool8 sub_80953BC(void);
-static void sub_8095520(void);
-static void sub_80955C4(u8 arg0, u8 arg1, u8 arg2);
-static void sub_80955FC(u8 arg0, u8 arg1, u8 arg2);
-static void sub_8095634(u8 arg0, u8 arg1, u8 arg2);
-static void sub_809566C(u8 arg0, u8 arg1, u8 arg2);
-static void sub_80956A4(u8 x, u8 y);
-static void sub_809572C(u8 x, u8 y);
-static void sub_8095780(u16 bgX, u16 bgY, u16 duration);
-static u8 sub_8095790(void);
-static void sub_80957C8(void);
-static void sub_80958A0(void);
-static void sub_8095918(void);
-static void sub_80959A8(void);
-static void sub_8095A58(void);
-
-static const struct WindowTemplate gUnknown_83D35D4 = {
+static const struct WindowTemplate sWindowTemplate_MultiMove = {
     .bg = 0,
     .tilemapLeft = 10,
     .tilemapTop = 3,
@@ -58,15 +56,15 @@ static const struct WindowTemplate gUnknown_83D35D4 = {
     .baseBlock = 0x00a
 };
 
-bool8 sub_8095050(void)
+bool8 MultiMove_Init(void)
 {
-    sMoveMonsPtr = Alloc(sizeof(*sMoveMonsPtr));
-    if (sMoveMonsPtr != NULL)
+    sMultiMove = Alloc(sizeof(*sMultiMove));
+    if (sMultiMove != NULL)
     {
-        gPSSData->field_2200 = AddWindow8Bit(&gUnknown_83D35D4);
-        if (gPSSData->field_2200 != 0xFF)
+        gStorage->multiMoveWindowId = AddWindow8Bit(&sWindowTemplate_MultiMove);
+        if (gStorage->multiMoveWindowId != WINDOW_NONE)
         {
-            FillWindowPixelBuffer(gPSSData->field_2200, PIXEL_FILL(0));
+            FillWindowPixelBuffer(gStorage->multiMoveWindowId, PIXEL_FILL(0));
             return TRUE;
         }
     }
@@ -74,64 +72,64 @@ bool8 sub_8095050(void)
     return FALSE;
 }
 
-void sub_80950A4(void)
+void MultiMove_Free(void)
 {
-    if (sMoveMonsPtr != NULL)
-        Free(sMoveMonsPtr);
+    if (sMultiMove != NULL)
+        Free(sMultiMove);
 }
 
-void sub_80950BC(u8 arg0)
+void MultiMove_SetFunction(u8 funcId)
 {
-    sMoveMonsPtr->field_0 = arg0;
-    sMoveMonsPtr->state = 0;
+    sMultiMove->funcId = funcId;
+    sMultiMove->state = 0;
 }
 
-bool8 sub_80950D0(void)
+bool8 MultiMove_RunFunction(void)
 {
-    switch (sMoveMonsPtr->field_0)
+    switch (sMultiMove->funcId)
     {
-    case 0:
-        return sub_8095138();
-    case 1:
-        return sub_8095234();
-    case 2:
-        return sub_80952A0();
-    case 3:
-        return sub_8095314();
-    case 4:
-        return sub_8095394();
-    case 5:
-        return sub_80953BC();
+    case MULTIMOVE_START:
+        return MultiMove_Function_Start();
+    case MULTIMOVE_SINGLE:
+        return MultiMove_Function_Single();
+    case MULTIMOVE_CHANGE_SELECTION:
+        return MultiMove_Function_ChangeSelection();
+    case MULTIMOVE_GRAB_SELECTION:
+        return MultiMove_Function_GrabSelection();
+    case MULTIMOVE_MOVE_MONS:
+        return MultiMove_Function_MoveMons();
+    case MULTIMOVE_PLACE_MONS:
+        return MultiMove_Function_PlaceMons();
     }
 
     return FALSE;
 }
 
-static bool8 sub_8095138(void)
+static bool8 MultiMove_Function_Start(void)
 {
-    switch (sMoveMonsPtr->state)
+    switch (sMultiMove->state)
     {
     case 0:
         HideBg(0);
         LoadMonIconPalettesAt(0x80);
-        sMoveMonsPtr->state++;
+        sMultiMove->state++;
         break;
     case 1:
-        sub_8094CD4(&sMoveMonsPtr->fromRow, &sMoveMonsPtr->fromColumn);
-        sMoveMonsPtr->toRow = sMoveMonsPtr->fromRow;
-        sMoveMonsPtr->toColumn = sMoveMonsPtr->fromColumn;
-        ChangeBgX(0, -1024, 0);
-        ChangeBgY(0, -1024, 0);
-        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
-        FillWindowPixelBuffer8Bit(gPSSData->field_2200, PIXEL_FILL(0));
-        sub_80956A4(sMoveMonsPtr->fromRow, sMoveMonsPtr->fromColumn);
+        GetCursorBoxColumnAndRow(&sMultiMove->fromColumn, &sMultiMove->fromRow);
+        sMultiMove->toColumn = sMultiMove->fromColumn;
+        sMultiMove->toRow = sMultiMove->fromRow;
+        ChangeBgX(0, -1024, BG_COORD_SET);
+        ChangeBgY(0, -1024, BG_COORD_SET);
+        FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
+        FillWindowPixelBuffer8Bit(gStorage->multiMoveWindowId, PIXEL_FILL(0));
+        MultiMove_SetIconToBg(sMultiMove->fromColumn, sMultiMove->fromRow);
         SetBgAttribute(0, BG_ATTR_PALETTEMODE, 1);
-        PutWindowTilemap(gPSSData->field_2200);
-        CopyWindowToVram8Bit(gPSSData->field_2200, COPYWIN_FULL);
+        PutWindowTilemap(gStorage->multiMoveWindowId);
+        CopyWindowToVram8Bit(gStorage->multiMoveWindowId, COPYWIN_FULL);
         BlendPalettes(0x3F00, 8, RGB_WHITE);
-        sub_8094D14(2);
+        StartCursorAnim(CURSOR_ANIM_OPEN);
         SetGpuRegBits(REG_OFFSET_BG0CNT, BGCNT_256COLOR);
-        sMoveMonsPtr->state++;
+        sMultiMove->state++;
         break;
     case 2:
         if (!IsDma3ManagerBusyWithBgCopy())
@@ -145,23 +143,23 @@ static bool8 sub_8095138(void)
     return TRUE;
 }
 
-static bool8 sub_8095234(void)
+static bool8 MultiMove_Function_Single(void)
 {
-    switch (sMoveMonsPtr->state)
+    switch (sMultiMove->state)
     {
     case 0:
         HideBg(0);
-        sMoveMonsPtr->state++;
+        sMultiMove->state++;
         break;
     case 1:
-        sub_8095A58();
-        sub_8094D14(0);
-        sMoveMonsPtr->state++;
+        MultiMove_ResetBg();
+        StartCursorAnim(CURSOR_ANIM_BOUNCE);
+        sMultiMove->state++;
         break;
     case 2:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
-            sub_8094D40();
+            SetCursorPriorityTo1();
             LoadPalette(stdpal_get(3), 0xD0, 0x20);
             ShowBg(0);
             return FALSE;
@@ -172,19 +170,19 @@ static bool8 sub_8095234(void)
     return TRUE;
 }
 
-static bool8 sub_80952A0(void)
+static bool8 MultiMove_Function_ChangeSelection(void)
 {
-    switch (sMoveMonsPtr->state)
+    switch (sMultiMove->state)
     {
     case 0:
-        if (!sub_80924A8())
+        if (!UpdateCursorPos())
         {
-            sub_8094CD4(&sMoveMonsPtr->field_6, &sMoveMonsPtr->field_7);
-            sub_8095520();
-            sMoveMonsPtr->toRow = sMoveMonsPtr->field_6;
-            sMoveMonsPtr->toColumn = sMoveMonsPtr->field_7;
-            CopyWindowToVram8Bit(gPSSData->field_2200, COPYWIN_GFX);
-            sMoveMonsPtr->state++;
+            GetCursorBoxColumnAndRow(&sMultiMove->cursorColumn, &sMultiMove->cursorRow);
+            MultiMove_UpdateSelectedIcons();
+            sMultiMove->toColumn = sMultiMove->cursorColumn;
+            sMultiMove->toRow = sMultiMove->cursorRow;
+            CopyWindowToVram8Bit(gStorage->multiMoveWindowId, COPYWIN_GFX);
+            sMultiMove->state++;
         }
         break;
     case 1:
@@ -194,31 +192,31 @@ static bool8 sub_80952A0(void)
     return TRUE;
 }
 
-static bool8 sub_8095314(void)
+static bool8 MultiMove_Function_GrabSelection(void)
 {
-    u8 var1, var2;
+    u8 movingBg, movingMon;
 
-    switch (sMoveMonsPtr->state)
+    switch (sMultiMove->state)
     {
     case 0:
-        sub_80957C8();
-        sub_80958A0();
-        sub_8092BAC(FALSE);
-        sMoveMonsPtr->state++;
+        MultiMove_GetMonsFromSelection();
+        MultiMove_RemoveMonsFromBox();
+        InitMultiMonPlaceChange(FALSE);
+        sMultiMove->state++;
         break;
     case 1:
         if (!DoMonPlaceChange())
         {
-            sub_8094D14(3);
-            sub_8095780(0, 256, 8);
-            sub_8092BAC(TRUE);
-            sMoveMonsPtr->state++;
+            StartCursorAnim(CURSOR_ANIM_FIST);
+            MultiMove_InitBg(0, 256, 8);
+            InitMultiMonPlaceChange(TRUE);
+            sMultiMove->state++;
         }
         break;
     case 2:
-        var1 = sub_8095790();
-        var2 = DoMonPlaceChange();
-        if (!var1 && !var2)
+        movingBg = MultiMove_UpdateBg();
+        movingMon = DoMonPlaceChange();
+        if (!movingBg && !movingMon)
             return FALSE;
         break;
     }
@@ -226,50 +224,50 @@ static bool8 sub_8095314(void)
     return TRUE;
 }
 
-static bool8 sub_8095394(void)
+static bool8 MultiMove_Function_MoveMons(void)
 {
-    u8 var1 = sub_80924A8();
-    u8 var2 = sub_8095790();
+    u8 movingCursor = UpdateCursorPos();
+    u8 movingBg = MultiMove_UpdateBg();
 
-    if (!var1 && !var2)
+    if (!movingCursor && !movingBg)
         return FALSE;
     else
         return TRUE;
 }
 
-static bool8 sub_80953BC(void)
+static bool8 MultiMove_Function_PlaceMons(void)
 {
-    switch (sMoveMonsPtr->state)
+    switch (sMultiMove->state)
     {
     case 0:
-        sub_80959A8();
-        sub_8095780(0, -256, 8);
-        sub_8092BAC(FALSE);
-        sMoveMonsPtr->state++;
+        MultiMove_SetPlacedMonData();
+        MultiMove_InitBg(0, -256, 8);
+        InitMultiMonPlaceChange(FALSE);
+        sMultiMove->state++;
         break;
     case 1:
-        if (!DoMonPlaceChange() && !sub_8095790())
+        if (!DoMonPlaceChange() && !MultiMove_UpdateBg())
         {
-            sub_8095918();
-            sub_8094D14(2);
-            sub_8092BAC(TRUE);
+            MultiMove_CreatePlacedMonIcons();
+            StartCursorAnim(CURSOR_ANIM_OPEN);
+            InitMultiMonPlaceChange(TRUE);
             HideBg(0);
-            sMoveMonsPtr->state++;
+            sMultiMove->state++;
         }
         break;
     case 2:
         if (!DoMonPlaceChange())
         {
-            sub_8094D14(0);
-            sub_8095A58();
-            sMoveMonsPtr->state++;
+            StartCursorAnim(CURSOR_ANIM_BOUNCE);
+            MultiMove_ResetBg();
+            sMultiMove->state++;
         }
         break;
     case 3:
         if (!IsDma3ManagerBusyWithBgCopy())
         {
             LoadPalette(stdpal_get(3), 0xD0, 0x20);
-            sub_8094D40();
+            SetCursorPriorityTo1();
             ShowBg(0);
             return FALSE;
         }
@@ -279,206 +277,188 @@ static bool8 sub_80953BC(void)
     return TRUE;
 }
 
-bool8 sub_8095474(u8 arg0)
+bool8 MultiMove_TryMoveGroup(u8 dir)
 {
-    switch (arg0)
+    switch (dir)
     {
     case 0: // up
-        if (sMoveMonsPtr->minColumn == 0)
+        if (sMultiMove->minRow == 0)
             return FALSE;
-        sMoveMonsPtr->minColumn--;
-        sub_8095780(0, 1024, 6);
+        sMultiMove->minRow--;
+        MultiMove_InitBg(0, 1024, 6);
         break;
     case 1: // down
-        if (sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal >= 5)
+        if (sMultiMove->minRow + sMultiMove->rowsTotal >= 5)
             return FALSE;
-        sMoveMonsPtr->minColumn++;
-        sub_8095780(0, -1024, 6);
+        sMultiMove->minRow++;
+        MultiMove_InitBg(0, -1024, 6);
         break;
     case 2: // left
-        if (sMoveMonsPtr->minRow == 0)
+        if (sMultiMove->minColumn == 0)
             return FALSE;
-        sMoveMonsPtr->minRow--;
-        sub_8095780(1024, 0, 6);
+        sMultiMove->minColumn--;
+        MultiMove_InitBg(1024, 0, 6);
         break;
     case 3: // right
-        if (sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal > 5)
+        if (sMultiMove->minColumn + sMultiMove->columnsTotal > 5)
             return FALSE;
-        sMoveMonsPtr->minRow++;
-        sub_8095780(-1024, 0, 6);
+        sMultiMove->minColumn++;
+        MultiMove_InitBg(-1024, 0, 6);
         break;
     }
 
     return TRUE;
 }
 
-static void sub_8095520(void)
+static void MultiMove_UpdateSelectedIcons(void)
 {
-    s16 var = (abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->field_6)) - (abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->toRow));
-    s16 var2 = (abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->field_7)) - (abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->toColumn));
+    s16 columnChange = (abs(sMultiMove->fromColumn - sMultiMove->cursorColumn)) - (abs(sMultiMove->fromColumn - sMultiMove->toColumn));
+    s16 rowChange = (abs(sMultiMove->fromRow - sMultiMove->cursorRow)) - (abs(sMultiMove->fromRow - sMultiMove->toRow));
 
-    if (var > 0)
-        sub_80955C4(sMoveMonsPtr->field_6, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
+    if (columnChange > 0)
+        MultiMove_SelectColumn(sMultiMove->cursorColumn, sMultiMove->fromRow, sMultiMove->toRow);
 
-    if (var < 0)
+    if (columnChange < 0)
     {
-        sub_8095634(sMoveMonsPtr->toRow, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
-        sub_80955C4(sMoveMonsPtr->field_6, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
+        MultiMove_DeselectColumn(sMultiMove->toColumn, sMultiMove->fromRow, sMultiMove->toRow);
+        MultiMove_SelectColumn(sMultiMove->cursorColumn, sMultiMove->fromRow, sMultiMove->toRow);
     }
 
-    if (var2 > 0)
-        sub_80955FC(sMoveMonsPtr->field_7, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
+    if (rowChange > 0)
+        MultiMove_SelectRow(sMultiMove->cursorRow, sMultiMove->fromColumn, sMultiMove->toColumn);
 
-    if (var2 < 0)
+    if (rowChange < 0)
     {
-        sub_809566C(sMoveMonsPtr->toColumn, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
-        sub_80955FC(sMoveMonsPtr->field_7, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
+        MultiMove_DeselectRow(sMultiMove->toRow, sMultiMove->fromColumn, sMultiMove->toColumn);
+        MultiMove_SelectRow(sMultiMove->cursorRow, sMultiMove->fromColumn, sMultiMove->toColumn);
     }
 }
 
-static void sub_80955C4(u8 arg0, u8 arg1, u8 arg2)
+static void MultiMove_SelectColumn(u8 column, u8 minRow, u8 maxRow)
 {
-    u8 var1 = arg1;
+    u8 tmp = minRow;
 
-    if (arg1 > arg2)
+    if (minRow > maxRow)
     {
-        arg1 = arg2;
-        arg2 = var1;
+        minRow = maxRow;
+        maxRow = tmp;
     }
 
-    while (arg1 <= arg2)
-        sub_80956A4(arg0, arg1++);
+    while (minRow <= maxRow)
+        MultiMove_SetIconToBg(column, minRow++);
 }
 
-static void sub_80955FC(u8 arg0, u8 arg1, u8 arg2)
+static void MultiMove_SelectRow(u8 row, u8 minColumn, u8 maxColumn)
 {
-    u8 var1 = arg1;
+    u8 tmp = minColumn;
 
-    if (arg1 > arg2)
+    if (minColumn > maxColumn)
     {
-        arg1 = arg2;
-        arg2 = var1;
+        minColumn = maxColumn;
+        maxColumn = tmp;
     }
 
-    while (arg1 <= arg2)
-        sub_80956A4(arg1++, arg0);
+    while (minColumn <= maxColumn)
+        MultiMove_SetIconToBg(minColumn++, row);
 }
 
-static void sub_8095634(u8 arg0, u8 arg1, u8 arg2)
+static void MultiMove_DeselectColumn(u8 column, u8 minRow, u8 maxRow)
 {
-    u8 var1 = arg1;
+    u8 tmp = minRow;
 
-    if (arg1 > arg2)
+    if (minRow > maxRow)
     {
-        arg1 = arg2;
-        arg2 = var1;
+        minRow = maxRow;
+        maxRow = tmp;
     }
 
-    while (arg1 <= arg2)
-        sub_809572C(arg0, arg1++);
+    while (minRow <= maxRow)
+        MultiMove_ClearIconFromBg(column, minRow++);
 }
 
-static void sub_809566C(u8 arg0, u8 arg1, u8 arg2)
+static void MultiMove_DeselectRow(u8 row, u8 minColumn, u8 maxColumn)
 {
-    u8 var1 = arg1;
+    u8 tmp = minColumn;
 
-    if (arg1 > arg2)
+    if (minColumn > maxColumn)
     {
-        arg1 = arg2;
-        arg2 = var1;
+        minColumn = maxColumn;
+        maxColumn = tmp;
     }
 
-    while (arg1 <= arg2)
-        sub_809572C(arg1++, arg0);
+    while (minColumn <= maxColumn)
+        MultiMove_ClearIconFromBg(minColumn++, row);
 }
 
-static void sub_80956A4(u8 x, u8 y)
+static void MultiMove_SetIconToBg(u8 x, u8 y)
 {
-    u8 position = x + (IN_BOX_ROWS * y);
+    u8 position = x + (IN_BOX_COLUMNS * y);
     u16 species = GetCurrentBoxMonData(position, MON_DATA_SPECIES2);
     u32 personality = GetCurrentBoxMonData(position, MON_DATA_PERSONALITY);
 
     if (species != SPECIES_NONE)
     {
         const u8 *iconGfx = GetMonIconPtr(species, personality, 1);
-        u8 index = GetValidMonIconPalIndex(species) + 8;
-
-        BlitBitmapRectToWindow4BitTo8Bit(gPSSData->field_2200,
-                                         iconGfx,
-                                         0,
-                                         0,
-                                         32,
-                                         32,
-                                         24 * x,
-                                         24 * y,
-                                         32,
-                                         32,
-                                         index);
+        u8 palNum = GetValidMonIconPalIndex(species) + 8;
+        BlitBitmapRectToWindow4BitTo8Bit(gStorage->multiMoveWindowId, iconGfx, 0, 0, 32, 32, 24 * x, 24 * y, 32, 32, palNum);
     }
 }
 
-static void sub_809572C(u8 x, u8 y)
+static void MultiMove_ClearIconFromBg(u8 x, u8 y)
 {
-    u8 position = x + (IN_BOX_ROWS * y);
+    u8 position = x + (IN_BOX_COLUMNS * y);
     u16 species = GetCurrentBoxMonData(position, MON_DATA_SPECIES2);
 
     if (species != SPECIES_NONE)
-    {
-        FillWindowPixelRect8Bit(gPSSData->field_2200,
-                                PIXEL_FILL(0),
-                                24 * x,
-                                24 * y,
-                                32,
-                                32);
-    }
+        FillWindowPixelRect8Bit(gStorage->multiMoveWindowId, PIXEL_FILL(0), 24 * x, 24 * y, 32, 32);
 }
 
-static void sub_8095780(u16 bgX, u16 bgY, u16 duration)
+static void MultiMove_InitBg(u16 bgX, u16 bgY, u16 duration)
 {
-    sMoveMonsPtr->bgX = bgX;
-    sMoveMonsPtr->bgY = bgY;
-    sMoveMonsPtr->field_10 = duration;
+    sMultiMove->bgX = bgX;
+    sMultiMove->bgY = bgY;
+    sMultiMove->bgMoveSteps = duration;
 }
 
-static u8 sub_8095790(void)
+static u8 MultiMove_UpdateBg(void)
 {
-    if (sMoveMonsPtr->field_10 != 0)
+    if (sMultiMove->bgMoveSteps != 0)
     {
-        ChangeBgX(0, sMoveMonsPtr->bgX, 1);
-        ChangeBgY(0, sMoveMonsPtr->bgY, 1);
-        sMoveMonsPtr->field_10--;
+        ChangeBgX(0, sMultiMove->bgX, BG_COORD_ADD);
+        ChangeBgY(0, sMultiMove->bgY, BG_COORD_ADD);
+        sMultiMove->bgMoveSteps--;
     }
 
-    return sMoveMonsPtr->field_10;
+    return sMultiMove->bgMoveSteps;
 }
 
-static void sub_80957C8(void)
+static void MultiMove_GetMonsFromSelection(void)
 {
     s32 i, j;
-    s32 rowCount, columnCount;
+    s32 columnCount, rowCount;
     u8 boxId;
     u8 monArrayId;
 
-    sMoveMonsPtr->minRow = min(sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
-    sMoveMonsPtr->minColumn = min(sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
-    sMoveMonsPtr->rowsTotal = abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->toRow) + 1;
-    sMoveMonsPtr->columsTotal = abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->toColumn) + 1;
+    sMultiMove->minColumn = min(sMultiMove->fromColumn, sMultiMove->toColumn);
+    sMultiMove->minRow = min(sMultiMove->fromRow, sMultiMove->toRow);
+    sMultiMove->columnsTotal = abs(sMultiMove->fromColumn - sMultiMove->toColumn) + 1;
+    sMultiMove->rowsTotal = abs(sMultiMove->fromRow - sMultiMove->toRow) + 1;
     boxId = StorageGetCurrentBox();
     monArrayId = 0;
-    rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
-    columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
-    for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
+    columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
+    rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
+    for (i = sMultiMove->minRow; i < rowCount; i++)
     {
-        u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
-        for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
+        u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
+        for (j = sMultiMove->minColumn; j < columnCount; j++)
         {
             struct BoxPokemon *boxMon = GetBoxedMonPtr(boxId, boxPosition);
             // UB: possible null dereference
 #ifdef UBFIX
             if (boxMon != NULL)
-                sMoveMonsPtr->boxMons[monArrayId] = *boxMon;
+                sMultiMove->boxMons[monArrayId] = *boxMon;
 #else
-            sMoveMonsPtr->boxMons[monArrayId] = *boxMon;
+            sMultiMove->boxMons[monArrayId] = *boxMon;
 #endif
             monArrayId++;
             boxPosition++;
@@ -486,17 +466,17 @@ static void sub_80957C8(void)
     }
 }
 
-static void sub_80958A0(void)
+static void MultiMove_RemoveMonsFromBox(void)
 {
     s32 i, j;
-    s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
-    s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
+    s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
+    s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
     u8 boxId = StorageGetCurrentBox();
 
-    for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
+    for (i = sMultiMove->minRow; i < rowCount; i++)
     {
-        u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
-        for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
+        u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
+        for (j = sMultiMove->minColumn; j < columnCount; j++)
         {
             DestroyBoxMonIconAtPosition(boxPosition);
             ZeroBoxMonAt(boxId, boxPosition);
@@ -505,75 +485,75 @@ static void sub_80958A0(void)
     }
 }
 
-static void sub_8095918(void)
+static void MultiMove_CreatePlacedMonIcons(void)
 {
     s32 i, j;
-    s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
-    s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
+    s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
+    s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
     u8 monArrayId = 0;
 
-    for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
+    for (i = sMultiMove->minRow; i < rowCount; i++)
     {
-        u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
-        for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
+        u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
+        for (j = sMultiMove->minColumn; j < columnCount; j++)
         {
-            if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
-                sub_80901EC(boxPosition);
+            if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
+                CreateBoxMonIconAtPos(boxPosition);
             monArrayId++;
             boxPosition++;
         }
     }
 }
 
-static void sub_80959A8(void)
+static void MultiMove_SetPlacedMonData(void)
 {
     s32 i, j;
-    s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
-    s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
+    s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
+    s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
     u8 boxId = StorageGetCurrentBox();
     u8 monArrayId = 0;
 
-    for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
+    for (i = sMultiMove->minRow; i < rowCount; i++)
     {
-        u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
-        for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
+        u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
+        for (j = sMultiMove->minColumn; j < columnCount; j++)
         {
-            if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
-                SetBoxMonAt(boxId, boxPosition, &sMoveMonsPtr->boxMons[monArrayId]);
+            if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
+                SetBoxMonAt(boxId, boxPosition, &sMultiMove->boxMons[monArrayId]);
             boxPosition++;
             monArrayId++;
         }
     }
 }
 
-static void sub_8095A58(void)
+static void MultiMove_ResetBg(void)
 {
-    ChangeBgX(0, 0, 0);
-    ChangeBgY(0, 0, 0);
+    ChangeBgX(0, 0, BG_COORD_SET);
+    ChangeBgY(0, 0, BG_COORD_SET);
     SetBgAttribute(0, BG_ATTR_PALETTEMODE, 0);
     ClearGpuRegBits(REG_OFFSET_BG0CNT, BGCNT_256COLOR);
     FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
     CopyBgTilemapBufferToVram(0);
 }
 
-u8 sub_8095AA0(void)
+u8 MultiMove_GetOriginPosition(void)
 {
-    return (IN_BOX_ROWS * sMoveMonsPtr->fromColumn) + sMoveMonsPtr->fromRow;
+    return (IN_BOX_COLUMNS * sMultiMove->fromRow) + sMultiMove->fromColumn;
 }
 
-bool8 sub_8095ABC(void)
+bool8 MultiMove_CanPlaceSelection(void)
 {
     s32 i, j;
-    s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
-    s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
+    s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
+    s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
     u8 monArrayId = 0;
 
-    for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
+    for (i = sMultiMove->minRow; i < rowCount; i++)
     {
-        u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
-        for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
+        u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
+        for (j = sMultiMove->minColumn; j < columnCount; j++)
         {
-            if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES)
+            if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES)
                 && GetCurrentBoxMonData(boxPosition, MON_DATA_SANITY_HAS_SPECIES))
                 return FALSE;
 

src/pokemon_storage_system_8.c

@@ -42,7 +42,7 @@ static void SpriteCB_ItemIcon_HideParty(struct Sprite *sprite);
 
 static const u32 sItemInfoFrame_Gfx[] = INCBIN_U32("graphics/interface/pss_unk_83D35DC.4bpp");
 
-static const struct OamData gUnknown_83D365C = {
+static const struct OamData sOamData_ItemIcon = {
     .y = 0,
     .affineMode = ST_OAM_AFFINE_NORMAL,
     .objMode = ST_OAM_OBJ_NORMAL,
@@ -58,65 +58,65 @@ static const struct OamData gUnknown_83D365C = {
     .affineParam = 0
 };
 
-static const union AffineAnimCmd gUnknown_83D3664[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_Small[] = {
     AFFINEANIMCMD_FRAME(128, 128, 0, 0),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D3674[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_Appear[] = {
     AFFINEANIMCMD_FRAME(88, 88, 0, 0),
     AFFINEANIMCMD_FRAME(5, 5, 0, 8),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D368C[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_Disappear[] = {
     AFFINEANIMCMD_FRAME(128, 128, 0, 0),
     AFFINEANIMCMD_FRAME(-5, -5, 0, 8),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D36A4[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_PickUp[] = {
     AFFINEANIMCMD_FRAME(128, 128, 0, 0),
     AFFINEANIMCMD_FRAME(10, 10, 0, 12),
     AFFINEANIMCMD_FRAME(256, 256, 0, 0),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D36C4[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_PutDown[] = {
     AFFINEANIMCMD_FRAME(256, 256, 0, 0),
     AFFINEANIMCMD_FRAME(-10, -10, 0, 12),
     AFFINEANIMCMD_FRAME(128, 128, 0, 0),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D36E4[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_PutAway[] = {
     AFFINEANIMCMD_FRAME(256, 256, 0, 0),
     AFFINEANIMCMD_FRAME(-5, -5, 0, 16),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd gUnknown_83D36FC[] = {
+static const union AffineAnimCmd sAffineAnim_ItemIcon_Large[] = {
     AFFINEANIMCMD_FRAME(256, 256, 0, 0),
     AFFINEANIMCMD_END
 };
 
-static const union AffineAnimCmd *const gUnknown_83D370C[] = {
-    gUnknown_83D3664,
-    gUnknown_83D3674,
-    gUnknown_83D368C,
-    gUnknown_83D36A4,
-    gUnknown_83D36C4,
-    gUnknown_83D36E4,
-    gUnknown_83D36FC
+static const union AffineAnimCmd *const sAffineAnims_ItemIcon[] = {
+    [ITEM_ANIM_NONE]      = sAffineAnim_ItemIcon_Small,
+    [ITEM_ANIM_APPEAR]    = sAffineAnim_ItemIcon_Appear,
+    [ITEM_ANIM_DISAPPEAR] = sAffineAnim_ItemIcon_Disappear,
+    [ITEM_ANIM_PICK_UP]   = sAffineAnim_ItemIcon_PickUp,
+    [ITEM_ANIM_PUT_DOWN]  = sAffineAnim_ItemIcon_PutDown,
+    [ITEM_ANIM_PUT_AWAY]  = sAffineAnim_ItemIcon_PutAway,
+    [ITEM_ANIM_LARGE]     = sAffineAnim_ItemIcon_Large,
 };
 
 static const struct SpriteTemplate sSpriteTemplate_ItemIcon = {
-    .tileTag = TAG_TILE_7,
-    .paletteTag = TAG_PAL_DACB,
-    .oam = &gUnknown_83D365C,
+    .tileTag = GFXTAG_ITEM_ICON_0,
+    .paletteTag = PALTAG_ITEM_ICON_0,
+    .oam = &sOamData_ItemIcon,
     .anims = gDummySpriteAnimTable,
     .images = NULL,
-    .affineAnims = gUnknown_83D370C,
+    .affineAnims = sAffineAnims_ItemIcon,
     .callback = SpriteCallbackDummy,
 };
 
@@ -128,7 +128,7 @@ void CreateItemIconSprites(void)
     struct SpriteTemplate spriteTemplate;
     static u32 sItemIconGfxBuffer[0x61];
 
-    if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption == OPTION_MOVE_ITEMS)
     {
         spriteSheet.data = sItemIconGfxBuffer;
         spriteSheet.size = 0x200;
@@ -136,30 +136,28 @@ void CreateItemIconSprites(void)
 
         for (i = 0; i < MAX_ITEM_ICONS; i++)
         {
-            spriteSheet.tag = TAG_TILE_7 + i;
+            spriteSheet.tag = GFXTAG_ITEM_ICON_0 + i;
             LoadCompressedSpriteSheet(&spriteSheet);
-            gPSSData->itemIcons[i].tiles = GetSpriteTileStartByTag(spriteSheet.tag) * TILE_SIZE_4BPP + (void *)(OBJ_VRAM0);
-            gPSSData->itemIcons[i].palIndex = AllocSpritePalette(TAG_PAL_DACB + i);
-            gPSSData->itemIcons[i].palIndex *= 16;
-            gPSSData->itemIcons[i].palIndex += 0x100;
-            spriteTemplate.tileTag = TAG_TILE_7 + i;
-            spriteTemplate.paletteTag = TAG_PAL_DACB + i;
+            gStorage->itemIcons[i].tiles = GetSpriteTileStartByTag(spriteSheet.tag) * TILE_SIZE_4BPP + (void *)(OBJ_VRAM0);
+            gStorage->itemIcons[i].palIndex = AllocSpritePalette(PALTAG_ITEM_ICON_0 + i);
+            gStorage->itemIcons[i].palIndex *= 16;
+            gStorage->itemIcons[i].palIndex += 0x100;
+            spriteTemplate.tileTag = GFXTAG_ITEM_ICON_0 + i;
+            spriteTemplate.paletteTag = PALTAG_ITEM_ICON_0 + i;
             spriteId = CreateSprite(&spriteTemplate, 0, 0, 11);
-            gPSSData->itemIcons[i].sprite = &gSprites[spriteId];
-            gPSSData->itemIcons[i].sprite->invisible = TRUE;
-            gPSSData->itemIcons[i].active = FALSE;
+            gStorage->itemIcons[i].sprite = &gSprites[spriteId];
+            gStorage->itemIcons[i].sprite->invisible = TRUE;
+            gStorage->itemIcons[i].active = FALSE;
         }
     }
-    gPSSData->movingItemId = ITEM_NONE;
+    gStorage->movingItemId = ITEM_NONE;
 }
 
-void sub_8095C84(u8 cursorArea, u8 cursorPos)
+void TryLoadItemIconAtPos(u8 cursorArea, u8 cursorPos)
 {
     u16 heldItem;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
-        return;
-    if (IsItemIconAtPosition(cursorArea, cursorPos))
+    if ((gStorage->boxOption != OPTION_MOVE_ITEMS) || IsItemIconAtPosition(cursorArea, cursorPos))
         return;
 
     switch (cursorArea)
@@ -186,21 +184,21 @@ void sub_8095C84(u8 cursorArea, u8 cursorPos)
 
         SetItemIconPosition(id, cursorArea, cursorPos);
         LoadItemIconGfx(id, tiles, pal);
-        SetItemIconAffineAnim(id, 1);
+        SetItemIconAffineAnim(id, ITEM_ANIM_APPEAR);
         SetItemIconActive(id, TRUE);
     }
 }
 
-void sub_8095D44(u8 cursorArea, u8 cursorPos)
+void TryHideItemIconAtPos(u8 cursorArea, u8 cursorPos)
 {
     u8 id;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
     id = GetItemIconIdxByPosition(cursorArea, cursorPos);
-    SetItemIconAffineAnim(id, 2);
-    SetItemIconCallback(id, 0, cursorArea, cursorPos);
+    SetItemIconAffineAnim(id, ITEM_ANIM_DISAPPEAR);
+    SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, cursorArea, cursorPos);
 }
 
 void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
@@ -208,14 +206,14 @@ void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
     u8 id;
     u16 item;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
     id = GetItemIconIdxByPosition(cursorArea, cursorPos);
     item = 0;
-    SetItemIconAffineAnim(id, 3);
-    SetItemIconCallback(id, 1, cursorArea, cursorPos);
-    SetItemIconPosition(id, 2, 0);
+    SetItemIconAffineAnim(id, ITEM_ANIM_PICK_UP);
+    SetItemIconCallback(id, ITEM_CB_TO_HAND, cursorArea, cursorPos);
+    SetItemIconPosition(id, CURSOR_AREA_IN_HAND, 0);
     if (cursorArea  == CURSOR_AREA_IN_BOX)
     {
         SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &item);
@@ -227,21 +225,21 @@ void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
         SetPartyMonIconObjMode(cursorPos, ST_OAM_OBJ_BLEND);
     }
 
-    gPSSData->movingItemId = gPSSData->displayMonItemId;
+    gStorage->movingItemId = gStorage->displayMonItemId;
 }
 
-void sub_8095E2C(u16 item)
+void InitItemIconInCursor(u16 item)
 {
     const u32 *tiles = GetItemIconPic(item);
     const u32 *pal = GetItemIconPalette(item);
     u8 id = GetNewItemIconIdx();
 
     LoadItemIconGfx(id, tiles, pal);
-    SetItemIconAffineAnim(id, 6);
-    SetItemIconCallback(id, 1, CURSOR_AREA_IN_BOX, 0);
-    SetItemIconPosition(id, CURSOR_AREA_BOX, 0);
+    SetItemIconAffineAnim(id, ITEM_ANIM_LARGE);
+    SetItemIconCallback(id, ITEM_CB_TO_HAND, 0, 0);
+    SetItemIconPosition(id, CURSOR_AREA_IN_HAND, 0);
     SetItemIconActive(id, TRUE);
-    gPSSData->movingItemId = item;
+    gStorage->movingItemId = item;
 }
 
 void Item_SwitchMonsWithMoving(u8 cursorArea, u8 cursorPos)
@@ -249,48 +247,48 @@ void Item_SwitchMonsWithMoving(u8 cursorArea, u8 cursorPos)
     u8 id;
     u16 item;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
     id = GetItemIconIdxByPosition(cursorArea, cursorPos);
-    SetItemIconAffineAnim(id, 3);
-    SetItemIconCallback(id, 3, CURSOR_AREA_BOX, 0);
+    SetItemIconAffineAnim(id, ITEM_ANIM_PICK_UP);
+    SetItemIconCallback(id, ITEM_CB_SWAP_TO_HAND, CURSOR_AREA_IN_HAND, 0);
     if (cursorArea == CURSOR_AREA_IN_BOX)
     {
         item = GetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM);
-        SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
-        gPSSData->movingItemId = item;
+        SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gStorage->movingItemId);
+        gStorage->movingItemId = item;
     }
     else
     {
         item = GetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM);
-        SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
-        gPSSData->movingItemId = item;
+        SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gStorage->movingItemId);
+        gStorage->movingItemId = item;
     }
 
     id = GetItemIconIdxByPosition(2, 0);
-    SetItemIconAffineAnim(id, 4);
-    SetItemIconCallback(id, 4, cursorArea, cursorPos);
+    SetItemIconAffineAnim(id, ITEM_ANIM_PUT_DOWN);
+    SetItemIconCallback(id, ITEM_CB_SWAP_TO_MON, cursorArea, cursorPos);
 }
 
 void Item_GiveMovingToMon(u8 cursorArea, u8 cursorPos)
 {
     u8 id;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
     id = GetItemIconIdxByPosition(2, 0);
-    SetItemIconAffineAnim(id, 4);
-    SetItemIconCallback(id, 2, cursorArea, cursorPos);
+    SetItemIconAffineAnim(id, ITEM_ANIM_PUT_DOWN);
+    SetItemIconCallback(id, ITEM_CB_TO_MON, cursorArea, cursorPos);
     if (cursorArea == CURSOR_AREA_IN_BOX)
     {
-        SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
+        SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gStorage->movingItemId);
         SetBoxMonIconObjMode(cursorPos, ST_OAM_OBJ_NORMAL);
     }
     else
     {
-        SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
+        SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gStorage->movingItemId);
         SetPartyMonIconObjMode(cursorPos, ST_OAM_OBJ_NORMAL);
     }
 }
@@ -300,13 +298,13 @@ void Item_TakeMons(u8 cursorArea, u8 cursorPos)
     u8 id;
     u16 item;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
-    item = 0;
+    item = ITEM_NONE;
     id = GetItemIconIdxByPosition(cursorArea, cursorPos);
-    SetItemIconAffineAnim(id, 2);
-    SetItemIconCallback(id, 0, cursorArea, cursorPos);
+    SetItemIconAffineAnim(id, ITEM_ANIM_DISAPPEAR);
+    SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, cursorArea, cursorPos);
     if (cursorArea  == CURSOR_AREA_IN_BOX)
     {
         SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &item);
@@ -319,41 +317,44 @@ void Item_TakeMons(u8 cursorArea, u8 cursorPos)
     }
 }
 
-void sub_8096088(void)
+void MoveItemFromCursorToBag(void)
 {
-    if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption == OPTION_MOVE_ITEMS)
     {
-        u8 id = GetItemIconIdxByPosition(2, 0);
-        SetItemIconAffineAnim(id, 5);
-        SetItemIconCallback(id, 0, CURSOR_AREA_BOX, 0);
+        u8 id = GetItemIconIdxByPosition(CURSOR_AREA_IN_HAND, 0);
+        SetItemIconAffineAnim(id, ITEM_ANIM_PUT_AWAY);
+        SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, 2, 0);
     }
 }
 
-void sub_80960C0(void)
+// The party menu is being closed, if the cursor is on
+// a Pokémon that has a held item make sure it slides
+// up along with the closing menu.
+void MoveHeldItemWithPartyMenu(void)
 {
     s32 i;
 
-    if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption != OPTION_MOVE_ITEMS)
         return;
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (gPSSData->itemIcons[i].active && gPSSData->itemIcons[i].cursorArea == CURSOR_AREA_IN_PARTY)
-            SetItemIconCallback(i, 7, CURSOR_AREA_BOX, 0);
+        if (gStorage->itemIcons[i].active && gStorage->itemIcons[i].cursorArea == CURSOR_AREA_IN_PARTY)
+            SetItemIconCallback(i, ITEM_CB_HIDE_PARTY, 2, 0);
     }
 }
 
-bool8 sub_809610C(void)
+bool8 IsItemIconAnimActive(void)
 {
     s32 i;
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (gPSSData->itemIcons[i].active)
+        if (gStorage->itemIcons[i].active)
         {
-            if (!gPSSData->itemIcons[i].sprite->affineAnimEnded && gPSSData->itemIcons[i].sprite->affineAnimBeginning)
+            if (!gStorage->itemIcons[i].sprite->affineAnimEnded && gStorage->itemIcons[i].sprite->affineAnimBeginning)
                 return TRUE;
-            if (gPSSData->itemIcons[i].sprite->callback != SpriteCallbackDummy && gPSSData->itemIcons[i].sprite->callback != SpriteCB_ItemIcon_SetPosToCursor)
+            if (gStorage->itemIcons[i].sprite->callback != SpriteCallbackDummy && gStorage->itemIcons[i].sprite->callback != SpriteCB_ItemIcon_SetPosToCursor)
                 return TRUE;
         }
     }
@@ -365,11 +366,11 @@ bool8 IsActiveItemMoving(void)
 {
     s32 i;
 
-    if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
+    if (gStorage->boxOption == OPTION_MOVE_ITEMS)
     {
         for (i = 0; i < MAX_ITEM_ICONS; i++)
         {
-            if (gPSSData->itemIcons[i].active && gPSSData->itemIcons[i].cursorArea == CURSOR_AREA_BOX)
+            if (gStorage->itemIcons[i].active && gStorage->itemIcons[i].cursorArea == CURSOR_AREA_BOX_TITLE)
                 return TRUE;
         }
     }
@@ -379,12 +380,12 @@ bool8 IsActiveItemMoving(void)
 
 const u8 *GetMovingItemName(void)
 {
-    return ItemId_GetName(gPSSData->movingItemId);
+    return ItemId_GetName(gStorage->movingItemId);
 }
 
 u16 GetMovingItem(void)
 {
-    return gPSSData->movingItemId;
+    return gStorage->movingItemId;
 }
 
 static u8 GetNewItemIconIdx(void)
@@ -393,9 +394,9 @@ static u8 GetNewItemIconIdx(void)
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (!gPSSData->itemIcons[i].active)
+        if (!gStorage->itemIcons[i].active)
         {
-            gPSSData->itemIcons[i].active = TRUE;
+            gStorage->itemIcons[i].active = TRUE;
             return i;
         }
     }
@@ -409,9 +410,9 @@ static bool32 IsItemIconAtPosition(u8 cursorArea, u8 cursorPos)
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (gPSSData->itemIcons[i].active
-            && gPSSData->itemIcons[i].cursorArea == cursorArea
-            && gPSSData->itemIcons[i].cursorPos == cursorPos)
+        if (gStorage->itemIcons[i].active
+            && gStorage->itemIcons[i].cursorArea == cursorArea
+            && gStorage->itemIcons[i].cursorPos == cursorPos)
             return TRUE;
     }
 
@@ -424,9 +425,9 @@ static u8 GetItemIconIdxByPosition(u8 cursorArea, u8 cursorPos)
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (gPSSData->itemIcons[i].active
-            && gPSSData->itemIcons[i].cursorArea == cursorArea
-            && gPSSData->itemIcons[i].cursorPos == cursorPos)
+        if (gStorage->itemIcons[i].active
+            && gStorage->itemIcons[i].cursorArea == cursorArea
+            && gStorage->itemIcons[i].cursorPos == cursorPos)
             return i;
     }
 
@@ -439,8 +440,8 @@ static u8 GetItemIconIdxBySprite(struct Sprite *sprite)
 
     for (i = 0; i < MAX_ITEM_ICONS; i++)
     {
-        if (gPSSData->itemIcons[i].active
-            && gPSSData->itemIcons[i].sprite == sprite)
+        if (gStorage->itemIcons[i].active
+            && gStorage->itemIcons[i].sprite == sprite)
             return i;
     }
 
@@ -457,29 +458,29 @@ static void SetItemIconPosition(u8 id, u8 cursorArea, u8 cursorPos)
     switch (cursorArea)
     {
     case CURSOR_AREA_IN_BOX:
-        row = cursorPos % IN_BOX_ROWS;
-        column = cursorPos / IN_BOX_ROWS;
-        gPSSData->itemIcons[id].sprite->x = (24 * row) + 112;
-        gPSSData->itemIcons[id].sprite->y = (24 * column) + 56;
-        gPSSData->itemIcons[id].sprite->oam.priority = 2;
+        row = cursorPos % IN_BOX_COLUMNS;
+        column = cursorPos / IN_BOX_COLUMNS;
+        gStorage->itemIcons[id].sprite->x = (24 * row) + 112;
+        gStorage->itemIcons[id].sprite->y = (24 * column) + 56;
+        gStorage->itemIcons[id].sprite->oam.priority = 2;
         break;
     case CURSOR_AREA_IN_PARTY:
         if (cursorPos == 0)
         {
-            gPSSData->itemIcons[id].sprite->x = 116;
-            gPSSData->itemIcons[id].sprite->y = 76;
+            gStorage->itemIcons[id].sprite->x = 116;
+            gStorage->itemIcons[id].sprite->y = 76;
         }
         else
         {
-            gPSSData->itemIcons[id].sprite->x = 164;
-            gPSSData->itemIcons[id].sprite->y = 24 * (cursorPos - 1) + 28;
+            gStorage->itemIcons[id].sprite->x = 164;
+            gStorage->itemIcons[id].sprite->y = 24 * (cursorPos - 1) + 28;
         }
-        gPSSData->itemIcons[id].sprite->oam.priority = 1;
+        gStorage->itemIcons[id].sprite->oam.priority = 1;
         break;
     }
 
-    gPSSData->itemIcons[id].cursorArea = cursorArea;
-    gPSSData->itemIcons[id].cursorPos = cursorPos;
+    gStorage->itemIcons[id].cursorArea = cursorArea;
+    gStorage->itemIcons[id].cursorPos = cursorPos;
 }
 
 static void LoadItemIconGfx(u8 id, const u32 *itemTiles, const u32 *itemPal)
@@ -489,14 +490,14 @@ static void LoadItemIconGfx(u8 id, const u32 *itemTiles, const u32 *itemPal)
     if (id >= MAX_ITEM_ICONS)
         return;
 
-    CpuFastFill(0, gPSSData->itemIconBuffer, 0x200);
-    LZ77UnCompWram(itemTiles, gPSSData->field_22C4);
+    CpuFastFill(0, gStorage->itemIconBuffer, 0x200);
+    LZ77UnCompWram(itemTiles, gStorage->tileBuffer);
     for (i = 0; i < 3; i++)
-        CpuFastCopy(gPSSData->field_22C4 + (i * 0x60), gPSSData->itemIconBuffer + (i * 0x80), 0x60);
+        CpuFastCopy(gStorage->tileBuffer + (i * 0x60), gStorage->itemIconBuffer + (i * 0x80), 0x60);
 
-    CpuFastCopy(gPSSData->itemIconBuffer, gPSSData->itemIcons[id].tiles, 0x200);
-    LZ77UnCompWram(itemPal, gPSSData->itemIconBuffer);
-    LoadPalette(gPSSData->itemIconBuffer, gPSSData->itemIcons[id].palIndex, 0x20);
+    CpuFastCopy(gStorage->itemIconBuffer, gStorage->itemIcons[id].tiles, 0x200);
+    LZ77UnCompWram(itemPal, gStorage->itemIconBuffer);
+    LoadPalette(gStorage->itemIconBuffer, gStorage->itemIcons[id].palIndex, 0x20);
 }
 
 static void SetItemIconAffineAnim(u8 id, u8 animNum)
@@ -504,7 +505,7 @@ static void SetItemIconAffineAnim(u8 id, u8 animNum)
     if (id >= MAX_ITEM_ICONS)
         return;
 
-    StartSpriteAffineAnim(gPSSData->itemIcons[id].sprite, animNum);
+    StartSpriteAffineAnim(gStorage->itemIcons[id].sprite, animNum);
 }
 
 #define sItemIconId data[0]
@@ -520,36 +521,36 @@ static void SetItemIconCallback(u8 id, u8 callbackId, u8 cursorArea, u8 cursorPo
     switch (callbackId)
     {
     case ITEM_CB_WAIT_ANIM:
-        gPSSData->itemIcons[id].sprite->sItemIconId = id;
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_WaitAnim;
+        gStorage->itemIcons[id].sprite->sItemIconId = id;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_WaitAnim;
         break;
     case ITEM_CB_TO_HAND:
-        gPSSData->itemIcons[id].sprite->sState = 0;
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToHand;
+        gStorage->itemIcons[id].sprite->sState = 0;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToHand;
         break;
     case ITEM_CB_TO_MON:
-        gPSSData->itemIcons[id].sprite->sState = 0;
-        gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
-        gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToMon;
+        gStorage->itemIcons[id].sprite->sState = 0;
+        gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
+        gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToMon;
         break;
     case ITEM_CB_SWAP_TO_HAND:
-        gPSSData->itemIcons[id].sprite->sState = 0;
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToHand;
-        gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
-        gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
+        gStorage->itemIcons[id].sprite->sState = 0;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToHand;
+        gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
+        gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
         break;
     case ITEM_CB_SWAP_TO_MON:
-        gPSSData->itemIcons[id].sprite->sState = 0;
-        gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
-        gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToMon;
+        gStorage->itemIcons[id].sprite->sState = 0;
+        gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
+        gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToMon;
         break;
     case ITEM_CB_HIDE_PARTY:
         // If cursor is on a Pokémon with a held item and
         // the player closes the party menu, have the held
         // item follow the Pokémon as the menu slides out
-        gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_HideParty;
+        gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_HideParty;
         break;
     }
 }
@@ -559,8 +560,8 @@ static void SetItemIconActive(u8 id, bool8 show)
     if (id >= MAX_ITEM_ICONS)
         return;
 
-    gPSSData->itemIcons[id].active = show;
-    gPSSData->itemIcons[id].sprite->invisible = (show == FALSE);
+    gStorage->itemIcons[id].active = show;
+    gStorage->itemIcons[id].sprite->invisible = (show == FALSE);
 }
 
 static const u32 *GetItemIconPic(u16 itemId)
@@ -578,9 +579,9 @@ void PrintItemDescription(void)
     const u8 *description;
 
     if (IsActiveItemMoving())
-        description = ItemId_GetDescription(gPSSData->movingItemId);
+        description = ItemId_GetDescription(gStorage->movingItemId);
     else
-        description = ItemId_GetDescription(gPSSData->displayMonItemId);
+        description = ItemId_GetDescription(gStorage->displayMonItemId);
 
     FillWindowPixelBuffer(2, PIXEL_FILL(1));
     AddTextPrinterParameterized5(2, FONT_2, description, 2, 0, 0, NULL, 0, 0);
@@ -588,7 +589,7 @@ void PrintItemDescription(void)
 
 void InitItemInfoWindow(void)
 {
-    gPSSData->itemInfoWindowOffset = 25;
+    gStorage->itemInfoWindowOffset = 25;
     LoadBgTiles(0, sItemInfoFrame_Gfx, 0x80, 0x1A4);
     DrawItemInfoWindow(0);
 }
@@ -597,53 +598,49 @@ bool8 UpdateItemInfoWindowSlideIn(void)
 {
     s32 i, pos;
 
-    if (gPSSData->itemInfoWindowOffset == 0)
+    if (gStorage->itemInfoWindowOffset == 0)
         return FALSE;
 
-    gPSSData->itemInfoWindowOffset--;
-    pos = 25 - gPSSData->itemInfoWindowOffset;
+    gStorage->itemInfoWindowOffset--;
+    pos = 25 - gStorage->itemInfoWindowOffset;
     for (i = 0; i < pos; i++)
-    {
-        WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gPSSData->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
-    }
+        WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gStorage->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
 
     DrawItemInfoWindow(pos);
-    return (gPSSData->itemInfoWindowOffset != 0);
+    return (gStorage->itemInfoWindowOffset != 0);
 }
 
 bool8 UpdateItemInfoWindowSlideOut(void)
 {
     s32 i, pos;
 
-    if (gPSSData->itemInfoWindowOffset == 25)
+    if (gStorage->itemInfoWindowOffset == 25)
         return FALSE;
 
-    if (gPSSData->itemInfoWindowOffset == 0)
+    if (gStorage->itemInfoWindowOffset == 0)
         FillBgTilemapBufferRect(0, 0, 25, 11, 1, 10, 17);
 
-    gPSSData->itemInfoWindowOffset++;
-    pos = 25 - gPSSData->itemInfoWindowOffset;
+    gStorage->itemInfoWindowOffset++;
+    pos = 25 - gStorage->itemInfoWindowOffset;
     for (i = 0; i < pos; i++)
-    {
-        WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gPSSData->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
-    }
+        WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gStorage->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
 
     DrawItemInfoWindow(pos);
 
-    FillBgTilemapBufferRect(0, 0, pos, 11, 1, 10, 0x11);
-    return (gPSSData->itemInfoWindowOffset != 25);
+    FillBgTilemapBufferRect(0, 0, pos, 11, 1, 10, 17);
+    return (gStorage->itemInfoWindowOffset != 25);
 }
 
 static void DrawItemInfoWindow(u32 x)
 {
     if (x != 0)
     {
-        FillBgTilemapBufferRect(0, 0x1A4, 0, 0xB, x, 1, 0xFu);
-        FillBgTilemapBufferRect(0, 0x9A4, 0, 0x14, x, 1, 0xFu);
+        FillBgTilemapBufferRect(0, 0x1A4, 0, 0xB, x, 1, 15);
+        FillBgTilemapBufferRect(0, 0x9A4, 0, 0x14, x, 1, 15);
     }
-    FillBgTilemapBufferRect(0, 0x1A5, x, 0xC, 1, 8, 0xFu);
-    FillBgTilemapBufferRect(0, 0x1A6, x, 0xB, 1, 1, 0xFu);
-    FillBgTilemapBufferRect(0, 0x1A7, x, 0x14, 1, 1, 0xFu);
+    FillBgTilemapBufferRect(0, 0x1A5, x, 0xC, 1, 8, 15);
+    FillBgTilemapBufferRect(0, 0x1A6, x, 0xB, 1, 1, 15);
+    FillBgTilemapBufferRect(0, 0x1A7, x, 0x14, 1, 1, 15);
     ScheduleBgCopyTilemapToVram(0);
 }
 
@@ -651,14 +648,14 @@ static void SpriteCB_ItemIcon_WaitAnim(struct Sprite *sprite)
 {
     if (sprite->affineAnimEnded)
     {
-        SetItemIconActive(sprite->data[0], FALSE);
+        SetItemIconActive(sprite->sItemIconId, FALSE);
         sprite->callback = SpriteCallbackDummy;
     }
 }
 
 static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
 {
-    switch (sprite->data[0])
+    switch (sprite->sState)
     {
     case 0:
         sprite->data[1] = sprite->x << 4;
@@ -666,7 +663,7 @@ static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
         sprite->data[3] = 10;
         sprite->data[4] = 21;
         sprite->data[5] = 0;
-        sprite->data[0]++;
+        sprite->sState++;
     case 1:
         sprite->data[1] -= sprite->data[3];
         sprite->data[2] -= sprite->data[4];
@@ -680,14 +677,14 @@ static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
 
 static void SpriteCB_ItemIcon_SetPosToCursor(struct Sprite *sprite)
 {
-    sprite->x = gPSSData->cursorSprite->x + 4;
-    sprite->y = gPSSData->cursorSprite->y + gPSSData->cursorSprite->y2 + 8;
-    sprite->oam.priority = gPSSData->cursorSprite->oam.priority;
+    sprite->x = gStorage->cursorSprite->x + 4;
+    sprite->y = gStorage->cursorSprite->y + gStorage->cursorSprite->y2 + 8;
+    sprite->oam.priority = gStorage->cursorSprite->oam.priority;
 }
 
 static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
 {
-    switch (sprite->data[0])
+    switch (sprite->sState)
     {
     case 0:
         sprite->data[1] = sprite->x << 4;
@@ -695,7 +692,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
         sprite->data[3] = 10;
         sprite->data[4] = 21;
         sprite->data[5] = 0;
-        sprite->data[0]++;
+        sprite->sState++;
     case 1:
         sprite->data[1] += sprite->data[3];
         sprite->data[2] += sprite->data[4];
@@ -703,7 +700,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
         sprite->y = sprite->data[2] >> 4;
         if (++sprite->data[5] > 11)
         {
-            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
+            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
             sprite->callback = SpriteCallbackDummy;
         }
         break;
@@ -712,7 +709,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
 
 static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
 {
-    switch (sprite->data[0])
+    switch (sprite->sState)
     {
     case 0:
         sprite->data[1] = sprite->x << 4;
@@ -720,7 +717,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
         sprite->data[3] = 10;
         sprite->data[4] = 21;
         sprite->data[5] = 0;
-        sprite->data[0]++;
+        sprite->sState++;
     case 1:
         sprite->data[1] -= sprite->data[3];
         sprite->data[2] -= sprite->data[4];
@@ -729,7 +726,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
         sprite->x2 = gSineTable[sprite->data[5] * 8] >> 4;
         if (++sprite->data[5] > 11)
         {
-            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
+            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
             sprite->x2 = 0;
             sprite->callback = SpriteCB_ItemIcon_SetPosToCursor;
         }
@@ -739,7 +736,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
 
 static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
 {
-    switch (sprite->data[0])
+    switch (sprite->sState)
     {
     case 0:
         sprite->data[1] = sprite->x << 4;
@@ -747,7 +744,7 @@ static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
         sprite->data[3] = 10;
         sprite->data[4] = 21;
         sprite->data[5] = 0;
-        sprite->data[0]++;
+        sprite->sState++;
     case 1:
         sprite->data[1] += sprite->data[3];
         sprite->data[2] += sprite->data[4];
@@ -756,7 +753,7 @@ static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
         sprite->x2 = -(gSineTable[sprite->data[5] * 8] >> 4);
         if (++sprite->data[5] > 11)
         {
-            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
+            SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
             sprite->callback = SpriteCallbackDummy;
             sprite->x2 = 0;
         }
@@ -779,16 +776,10 @@ static void SpriteCB_ItemIcon_HideParty(struct Sprite *sprite)
 #undef sCursorArea
 #undef sCursorPos
 
-
-//------------------------------------------------------------------------------
-//  SECTION: UnkUtil
-//
 //  Some data transfer utility that goes functionally unused.
 //  It gets initialized with UnkUtil_Init, and run every vblank in Pokémon
 //  Storage with UnkUtil_Run, but neither of the Add functions are ever used,
 //  so UnkUtil_Run performs no actions.
-//------------------------------------------------------------------------------
-
 
 static EWRAM_DATA struct UnkUtil *sUnkUtil = NULL;
 

src/tm_case.c

@@ -953,7 +953,7 @@ static void Task_SelectTMAction_Type3(u8 taskId)
 
     if (!itemid_is_unique(BagGetItemIdByPocketPosition(POCKET_TM_CASE, data[1])))
     {
-        sTMCaseDynamicResources->savedCallback = Cb2_ReturnToPSS;
+        sTMCaseDynamicResources->savedCallback = CB2_ReturnToPokeStorage;
         Task_BeginFadeOutFromTMCase(taskId);
     }
     else