import from github

src/use_pokeblock.c

@@ -0,0 +1,1667 @@
+#include "global.h"
+#include "main.h"
+#include "dma3.h"
+#include "pokeblock.h"
+#include "malloc.h"
+#include "decompress.h"
+#include "graphics.h"
+#include "palette.h"
+#include "pokenav.h"
+#include "menu_specialized.h"
+#include "scanline_effect.h"
+#include "text.h"
+#include "bg.h"
+#include "window.h"
+#include "text_window.h"
+#include "constants/rgb.h"
+#include "sound.h"
+#include "constants/songs.h"
+#include "sprite.h"
+#include "string_util.h"
+#include "strings.h"
+#include "menu.h"
+#include "gpu_regs.h"
+#include "graphics.h"
+#include "pokemon_summary_screen.h"
+#include "item_menu.h"
+
+/*
+    This file handles the screen where the player chooses
+    which pokemon to give a pokeblock to. The subsequent scene
+    of feeding the pokeblock to the pokemon is handled by
+    pokeblock_feed.c, and the rest of the pokeblock menu (and
+    other pokeblock-related functions) are in pokeblock.c
+*/
+
+enum {
+    WIN_NAME,
+    WIN_NATURE,
+    WIN_TEXT,
+    WIN_COUNT
+};
+
+#define TAG_UP_DOWN     0
+#define TAG_CONDITION   1
+
+// At any one time, the currently selected mon and its two adjacent neighbors can be loaded
+// IDs to refer to one of these 3 are called "load id" in this file
+#define NUM_SELECTIONS_LOADED 3
+
+struct UsePokeblockSession
+{
+    void (*callback)(void);
+    void (*exitCallback)(void);
+    struct Pokeblock *pokeblock;
+    struct Pokemon *mon;
+    u8 stringBuffer[64];
+    u8 mainState;
+    u8 unused1;
+    u8 timer;
+    u8 condition;
+    u8 numEnhancements;
+    u8 unused2;
+    bool8 monInTopHalf;
+    u8 conditionsBeforeBlock[CONDITION_COUNT];
+    u8 conditionsAfterBlock[CONDITION_COUNT];
+    u8 enhancements[CONDITION_COUNT];
+    s16 pokeblockStatBoosts[CONDITION_COUNT];
+    u8 numSelections; // num in party + 1 (for Cancel)
+    u8 curSelection;
+    bool8 (*loadNewSelection)(void);
+    u8 helperState;
+    u8 unused3;
+    u8 natureText[34];
+};
+
+// This struct is identical to PokenavMonListItem, the struct used for managing lists of pokemon in the pokenav
+// Given that this screen is essentially duplicated in the poknav, this struct was probably the same one with
+// a more general name/purpose
+// TODO: Once the pokenav conditions screens are documented, resolve the above
+struct UsePokeblockMenuPokemon
+{
+    u8 boxId; // Because this screen is never used for the PC this is always set to TOTAL_BOXES_COUNT to refer to party
+    u8 monId;
+    u16 data; // never read
+};
+
+struct UsePokeblockMenu
+{
+    u32 unused;
+    u16 partyPalettes[PARTY_SIZE][0x40];
+    u8 partySheets[NUM_SELECTIONS_LOADED][0x2000];
+    u8 unusedBuffer[0x1000];
+    u8 tilemapBuffer[BG_SCREEN_SIZE + 2];
+    u8 selectionIconSpriteIds[PARTY_SIZE + 1];
+    s16 curMonXOffset;
+    u8 curMonSpriteId;
+    u16 curMonPalette;
+    u16 curMonSheet;
+    u8 *curMonTileStart;
+    struct Sprite *sparkles[MAX_CONDITION_SPARKLES];
+    struct Sprite *condition[2];
+    u8 toLoadSelection;
+    u8 locationStrings[NUM_SELECTIONS_LOADED][24]; // Gets an "in party" or "in box #" string that never gets printed
+    u8 monNameStrings[NUM_SELECTIONS_LOADED][64];
+    struct ConditionGraph graph;
+    u8 numSparkles[NUM_SELECTIONS_LOADED];
+    s8 curLoadId;
+    s8 nextLoadId;
+    s8 prevLoadId;
+    s8 toLoadId;
+    struct UsePokeblockMenuPokemon party[PARTY_SIZE];
+    struct UsePokeblockSession info;
+};
+
+static void SetUsePokeblockCallback(void (*func)(void));
+static void LoadUsePokeblockMenu(void);
+static void CB2_UsePokeblockMenu(void);
+static void CB2_ReturnToUsePokeblockMenu(void);
+static void ShowUsePokeblockMenu(void);
+static void CB2_ShowUsePokeblockMenuForResults(void);
+static void ShowUsePokeblockMenuForResults(void);
+static void LoadPartyInfo(void);
+static void LoadAndCreateSelectionIcons(void);
+static u8 GetSelectionIdFromPartyId(u8);
+static bool8 LoadConditionTitle(void);
+static bool8 LoadUsePokeblockMenuGfx(void);
+static void UpdateMonPic(u8);
+static void UpdateMonInfoText(u16, bool8);
+static void UsePokeblockMenu(void);
+static void UpdateSelection(bool8);
+static void CloseUsePokeblockMenu(void);
+static void AskUsePokeblock(void);
+static s8 HandleAskUsePokeblockInput(void);
+static bool8 IsSheenMaxed(void);
+static void PrintWontEatAnymore(void);
+static void FeedPokeblockToMon(void);
+static void EraseMenuWindow(void);
+static u8 GetPartyIdFromSelectionId(u8);
+static void ShowPokeblockResults(void);
+static void CalculateConditionEnhancements(void);
+static void LoadAndCreateUpDownSprites(void);
+static void CalculateNumAdditionalSparkles(u8);
+static void PrintFirstEnhancement(void);
+static bool8 TryPrintNextEnhancement(void);
+static void BufferEnhancedText(u8 *, u8, s16);
+static void PrintMenuWindowText(const u8 *);
+static void CalculatePokeblockEffectiveness(struct Pokeblock *, struct Pokemon *);
+static void SpriteCB_UpDown(struct Sprite *);
+static void LoadInitialMonInfo(void);
+static void LoadMonInfo(s16, u8);
+static bool8 LoadNewSelection_CancelToMon(void);
+static bool8 LoadNewSelection_MonToCancel(void);
+static bool8 LoadNewSelection_MonToMon(void);
+static void SpriteCB_SelectionIconPokeball(struct Sprite *);
+static void SpriteCB_SelectionIconCancel(struct Sprite *);
+static void SpriteCB_MonPic(struct Sprite *);
+static void SpriteCB_Condition(struct Sprite *);
+
+extern const u16 gConditionGraphData_Pal[];
+extern const u16 gConditionText_Pal[];
+
+// The below 3 are saved for returning to the screen after feeding a pokeblock to a mon
+// so that the rest of the data can be freed
+static EWRAM_DATA struct UsePokeblockSession *sInfo = NULL;
+static EWRAM_DATA void (*sExitCallback)(void) = NULL;
+static EWRAM_DATA struct Pokeblock *sPokeblock = NULL;
+EWRAM_DATA u8 gPokeblockMonId = 0;
+EWRAM_DATA s16 gPokeblockGain = 0;
+static EWRAM_DATA u8 *sGraph_Tilemap = NULL;
+static EWRAM_DATA u8 *sGraph_Gfx = NULL;
+static EWRAM_DATA u8 *sMonFrame_TilemapPtr = NULL;
+static EWRAM_DATA struct UsePokeblockMenu *sMenu = NULL;
+
+static const u32 sMonFrame_Pal[] = INCBIN_U32("graphics/pokeblock/use_screen/mon_frame_pal.bin");
+static const u32 sMonFrame_Gfx[] = INCBIN_U32("graphics/pokeblock/use_screen/mon_frame.4bpp");
+static const u32 sMonFrame_Tilemap[] = INCBIN_U32("graphics/pokeblock/use_screen/mon_frame.bin");
+static const u32 sGraphData_Tilemap[] = INCBIN_U32("graphics/pokeblock/use_screen/graph_data.bin");
+
+// The condition/flavors aren't listed in their normal order in this file, they're listed as shown on the graph going counter-clockwise
+// Normally they would go Cool/Spicy, Beauty/Dry, Cute/Sweet, Smart/Bitter, Tough/Sour (also graph order, but clockwise)
+static const u32 sConditionToMonData[CONDITION_COUNT] =
+{
+    [CONDITION_COOL]   = MON_DATA_COOL,
+    [CONDITION_TOUGH]  = MON_DATA_TOUGH,
+    [CONDITION_SMART]  = MON_DATA_SMART,
+    [CONDITION_CUTE]   = MON_DATA_CUTE,
+    [CONDITION_BEAUTY] = MON_DATA_BEAUTY
+};
+
+static const u8 sConditionToFlavor[CONDITION_COUNT] =
+{
+    [CONDITION_COOL]   = FLAVOR_SPICY,
+    [CONDITION_TOUGH]  = FLAVOR_SOUR,
+    [CONDITION_SMART]  = FLAVOR_BITTER,
+    [CONDITION_CUTE]   = FLAVOR_SWEET,
+    [CONDITION_BEAUTY] = FLAVOR_DRY
+};
+
+static const u8 sNatureTextColors[] =
+{
+    TEXT_COLOR_TRANSPARENT,
+    TEXT_COLOR_BLUE,
+    TEXT_COLOR_WHITE
+};
+
+static const struct BgTemplate sBgTemplates[4] =
+{
+    {
+        .bg = 0,
+        .charBaseIndex = 2,
+        .mapBaseIndex = 0x1F,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 0,
+        .baseTile = 0
+    },
+    {
+        .bg = 1,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 0x1E,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 3,
+        .baseTile = 0
+    },
+    {
+        .bg = 3,
+        .charBaseIndex = 3,
+        .mapBaseIndex = 0x1D,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 2,
+        .baseTile = 0x100
+    },
+    {
+        .bg = 2,
+        .charBaseIndex = 0,
+        .mapBaseIndex = 0x17,
+        .screenSize = 0,
+        .paletteMode = 0,
+        .priority = 1,
+        .baseTile = 0
+    }
+};
+
+static const struct WindowTemplate sWindowTemplates[WIN_COUNT + 1] =
+{
+    [WIN_NAME] = {
+        .bg = 0,
+        .tilemapLeft = 13,
+        .tilemapTop = 1,
+        .width = 13,
+        .height = 4,
+        .paletteNum = 15,
+        .baseBlock = 1
+    },
+    [WIN_NATURE] = {
+        .bg = 0,
+        .tilemapLeft = 0,
+        .tilemapTop = 14,
+        .width = 11,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 0x35
+    },
+    [WIN_TEXT] = {
+        .bg = 0,
+        .tilemapLeft = 1,
+        .tilemapTop = 17,
+        .width = 28,
+        .height = 2,
+        .paletteNum = 15,
+        .baseBlock = 0x4B
+    },
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct WindowTemplate sUsePokeblockYesNoWinTemplate =
+{
+    .bg = 0,
+    .tilemapLeft = 24,
+    .tilemapTop = 11,
+    .width = 5,
+    .height = 4,
+    .paletteNum = 15,
+    .baseBlock = 0x83
+};
+
+static const u8 *const sConditionNames[CONDITION_COUNT] =
+{
+    [CONDITION_COOL]   = gText_Coolness,
+    [CONDITION_TOUGH]  = gText_Toughness,
+    [CONDITION_SMART]  = gText_Smartness,
+    [CONDITION_CUTE]   = gText_Cuteness,
+    [CONDITION_BEAUTY] = gText_Beauty3
+};
+
+static const struct SpriteSheet sSpriteSheet_UpDown =
+{
+    gUsePokeblockUpDown_Gfx, 0x200, TAG_UP_DOWN
+};
+
+static const struct SpritePalette sSpritePalette_UpDown =
+{
+    gUsePokeblockUpDown_Pal, TAG_UP_DOWN
+};
+
+static const s16 sUpDownCoordsOnGraph[CONDITION_COUNT][2] =
+{
+    [CONDITION_COOL]   = {156,  36},
+    [CONDITION_TOUGH]  = {117,  59},
+    [CONDITION_SMART]  = {117, 118},
+    [CONDITION_CUTE]   = {197, 118},
+    [CONDITION_BEAUTY] = {197,  59}
+};
+
+static const struct OamData sOam_UpDown =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(32x16),
+    .x = 0,
+    .size = SPRITE_SIZE(32x16),
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+};
+
+static const union AnimCmd sAnim_Up[] =
+{
+    ANIMCMD_FRAME(0, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_Down[] =
+{
+    ANIMCMD_FRAME(8, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sAnims_UpDown[] =
+{
+    sAnim_Up,
+    sAnim_Down
+};
+
+static const struct SpriteTemplate sSpriteTemplate_UpDown =
+{
+    .tileTag = TAG_UP_DOWN,
+    .paletteTag = TAG_UP_DOWN,
+    .oam = &sOam_UpDown,
+    .anims = sAnims_UpDown,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const struct OamData sOam_Condition =
+{
+    .y = 0,
+    .affineMode = ST_OAM_AFFINE_OFF,
+    .objMode = ST_OAM_OBJ_NORMAL,
+    .bpp = ST_OAM_4BPP,
+    .shape = SPRITE_SHAPE(64x32),
+    .x = 0,
+    .size = SPRITE_SIZE(64x32),
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+};
+
+static const union AnimCmd sAnim_Condition_0[] =
+{
+    ANIMCMD_FRAME(0, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_Condition_1[] =
+{
+    ANIMCMD_FRAME(32, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sAnim_Condition_2[] =
+{
+    ANIMCMD_FRAME(64, 5),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sAnims_Condition[] =
+{
+    sAnim_Condition_0,
+    sAnim_Condition_1,
+    sAnim_Condition_2
+};
+
+static const struct SpriteTemplate sSpriteTemplate_Condition =
+{
+    .tileTag = TAG_CONDITION,
+    .paletteTag = TAG_CONDITION,
+    .oam = &sOam_Condition,
+    .anims = sAnims_Condition,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCB_Condition,
+};
+
+static const struct SpritePalette sSpritePalette_Condition =
+{
+    gUsePokeblockCondition_Pal, TAG_CONDITION
+};
+
+// When first opening the selection screen
+void ChooseMonToGivePokeblock(struct Pokeblock *pokeblock, void (*callback)(void))
+{
+    sMenu = AllocZeroed(sizeof(*sMenu));
+    sInfo = &sMenu->info;
+    sInfo->pokeblock = pokeblock;
+    sInfo->exitCallback = callback;
+    SetUsePokeblockCallback(LoadUsePokeblockMenu);
+    SetMainCallback2(CB2_UsePokeblockMenu);
+}
+
+// When returning to the selection screen after feeding a pokeblock to a mon
+static void CB2_ReturnAndChooseMonToGivePokeblock(void)
+{
+    sMenu = AllocZeroed(sizeof(*sMenu));
+    sInfo = &sMenu->info;
+    sInfo->pokeblock = sPokeblock;
+    sInfo->exitCallback = sExitCallback;
+    gPokeblockMonId = GetSelectionIdFromPartyId(gPokeblockMonId);
+    sInfo->monInTopHalf = (gPokeblockMonId <= PARTY_SIZE / 2) ? FALSE : TRUE;
+    SetUsePokeblockCallback(LoadUsePokeblockMenu);
+    SetMainCallback2(CB2_ReturnToUsePokeblockMenu);
+}
+
+static void CB2_ReturnToUsePokeblockMenu(void)
+{
+    sInfo->callback();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+    if (sInfo->callback == ShowUsePokeblockMenu)
+    {
+        sInfo->mainState = 0;
+        SetMainCallback2(CB2_ShowUsePokeblockMenuForResults);
+    }
+}
+
+static void CB2_ShowUsePokeblockMenuForResults(void)
+{
+    ShowUsePokeblockMenuForResults();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void CB2_UsePokeblockMenu(void)
+{
+    sInfo->callback();
+    AnimateSprites();
+    BuildOamBuffer();
+    RunTextPrinters();
+    UpdatePaletteFade();
+}
+
+static void VBlankCB_UsePokeblockMenu(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+    ConditionGraph_Draw(&sMenu->graph);
+    ScanlineEffect_InitHBlankDmaTransfer();
+}
+
+static void SetUsePokeblockCallback(void (*func)(void))
+{
+    sInfo->callback = func;
+    sInfo->mainState = 0;
+}
+
+static void LoadUsePokeblockMenu(void)
+{
+    switch (sInfo->mainState)
+    {
+    case 0:
+        sMenu->curMonSpriteId = SPRITE_NONE;
+        ConditionGraph_Init(&sMenu->graph);
+        sInfo->mainState++;
+        break;
+    case 1:
+        ResetSpriteData();
+        FreeAllSpritePalettes();
+        sInfo->mainState++;
+        break;
+    case 2:
+        SetVBlankCallback(NULL);
+        CpuFill32(0, (void*)(VRAM), VRAM_SIZE);
+        sInfo->mainState++;
+        break;
+    case 3:
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, sBgTemplates, ARRAY_COUNT(sBgTemplates));
+        InitWindows(sWindowTemplates);
+        DeactivateAllTextPrinters();
+        LoadUserWindowBorderGfx(0, 0x97, 0xE0);
+        sInfo->mainState++;
+        break;
+    case 4:
+        sInfo->mainState++;
+        break;
+    case 5:
+        if (!LoadConditionTitle())
+            sInfo->mainState++;
+        break;
+    case 6:
+        gKeyRepeatStartDelay = 20;
+        LoadPartyInfo();
+        sInfo->mainState++;
+        break;
+    case 7:
+        if (!LoadUsePokeblockMenuGfx())
+            sInfo->mainState++;
+        break;
+    case 8:
+        UpdateMonPic(0);
+        LoadAndCreateSelectionIcons();
+        sInfo->mainState++;
+        break;
+    case 9:
+        if (!MoveConditionMonOnscreen(&sMenu->curMonXOffset))
+            sInfo->mainState++;
+        break;
+    case 10:
+        sInfo->mainState++;
+        break;
+    case 11:
+        ConditionGraph_CalcPositions(sMenu->graph.conditions[0], sMenu->graph.savedPositions[0]);
+        ConditionGraph_InitResetScanline(&sMenu->graph);
+        sInfo->mainState++;
+        break;
+    case 12:
+        if (!ConditionGraph_ResetScanline(&sMenu->graph))
+        {
+            ConditionGraph_SetNewPositions(&sMenu->graph, sMenu->graph.savedPositions[0], sMenu->graph.savedPositions[0]);
+            sInfo->mainState++;
+        }
+        break;
+    case 13:
+        ConditionGraph_Update(&sMenu->graph);
+        sInfo->mainState++;
+        break;
+    case 14:
+        PutWindowTilemap(WIN_NAME);
+        PutWindowTilemap(WIN_NATURE);
+        UpdateMonInfoText(0, TRUE);
+        sInfo->mainState++;
+        break;
+    case 15:
+        SetUsePokeblockCallback(ShowUsePokeblockMenu);
+        break;
+    }
+}
+
+static void ShowUsePokeblockMenu(void)
+{
+    switch (sInfo->mainState)
+    {
+    case 0:
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB_BLACK);
+        SetVBlankCallback(VBlankCB_UsePokeblockMenu);
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(3);
+        ShowBg(2);
+        sInfo->mainState++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            ResetConditionSparkleSprites(sMenu->sparkles);
+            if (sMenu->info.curSelection != sMenu->info.numSelections - 1)
+            {
+                u8 numSparkles = sMenu->numSparkles[sMenu->curLoadId];
+                CreateConditionSparkleSprites(sMenu->sparkles, sMenu->curMonSpriteId, numSparkles);
+            }
+
+            SetUsePokeblockCallback(UsePokeblockMenu);
+        }
+        break;
+    }
+}
+
+enum {
+    STATE_HANDLE_INPUT,
+    STATE_UPDATE_SELECTION,
+    STATE_2, // unused state
+    STATE_CLOSE,
+    STATE_4, // unused state
+    STATE_CONFIRM_SELECTION,
+    STATE_HANDLE_CONFIRMATION,
+    STATE_WAIT_MSG,
+};
+
+static void UsePokeblockMenu(void)
+{
+    bool8 loading;
+
+    switch (sInfo->mainState)
+    {
+    case STATE_HANDLE_INPUT:
+        if (JOY_HELD(DPAD_UP))
+        {
+            PlaySE(SE_SELECT);
+            UpdateSelection(TRUE);
+            DestroyConditionSparkleSprites(sMenu->sparkles);
+            sInfo->mainState = STATE_UPDATE_SELECTION;
+        }
+        else if (JOY_HELD(DPAD_DOWN))
+        {
+            PlaySE(SE_SELECT);
+            UpdateSelection(FALSE);
+            DestroyConditionSparkleSprites(sMenu->sparkles);
+            sInfo->mainState = STATE_UPDATE_SELECTION;
+        }
+        else if (JOY_NEW(B_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+            sInfo->mainState = STATE_CLOSE;
+        }
+        else if (JOY_NEW(A_BUTTON))
+        {
+            PlaySE(SE_SELECT);
+
+            // If last item, selected Cancel. Otherwise selected mon
+            if (sMenu->info.curSelection == sMenu->info.numSelections - 1)
+                sInfo->mainState = STATE_CLOSE;
+            else
+                sInfo->mainState = STATE_CONFIRM_SELECTION;
+        }
+        break;
+    case STATE_UPDATE_SELECTION:
+        loading = sMenu->info.loadNewSelection();
+        if (!loading)
+            sInfo->mainState = STATE_HANDLE_INPUT;
+        break;
+    case STATE_2:
+        break;
+    case STATE_CLOSE:
+        SetUsePokeblockCallback(CloseUsePokeblockMenu);
+        break;
+    case STATE_4:
+        break;
+    case STATE_CONFIRM_SELECTION:
+        AskUsePokeblock();
+        sInfo->mainState++;
+        break;
+    case STATE_HANDLE_CONFIRMATION:
+        switch (HandleAskUsePokeblockInput())
+        {
+        case 1: // NO
+        case MENU_B_PRESSED:
+            sInfo->mainState = STATE_HANDLE_INPUT;
+            break;
+        case 0: // YES
+            if (IsSheenMaxed())
+            {
+                PrintWontEatAnymore();
+                sInfo->mainState = STATE_WAIT_MSG;
+            }
+            else
+            {
+                SetUsePokeblockCallback(FeedPokeblockToMon);
+            }
+            break;
+        }
+        break;
+    case STATE_WAIT_MSG:
+        if (JOY_NEW(A_BUTTON | B_BUTTON))
+        {
+            EraseMenuWindow();
+            sInfo->mainState = STATE_HANDLE_INPUT;
+        }
+        break;
+    }
+}
+
+static void FeedPokeblockToMon(void)
+{
+    switch (sInfo->mainState)
+    {
+    case 0:
+        gPokeblockMonId = GetPartyIdFromSelectionId(sMenu->info.curSelection);
+        sExitCallback = sInfo->exitCallback;
+        sPokeblock = sInfo->pokeblock;
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB_BLACK);
+        sInfo->mainState++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+        {
+            SetVBlankCallback(NULL);
+            FREE_AND_SET_NULL(sGraph_Tilemap);
+            FREE_AND_SET_NULL(sGraph_Gfx);
+            FREE_AND_SET_NULL(sMonFrame_TilemapPtr);
+            FREE_AND_SET_NULL(sMenu);
+            FreeAllWindowBuffers();
+            gMain.savedCallback = CB2_ReturnAndChooseMonToGivePokeblock;
+            PreparePokeblockFeedScene();
+        }
+        break;
+    }
+}
+
+static void ShowUsePokeblockMenuForResults(void)
+{
+    bool8 loading;
+
+    switch (sInfo->mainState)
+    {
+    case 0:
+        if (sMenu->info.curSelection != gPokeblockMonId)
+        {
+            UpdateSelection(sInfo->monInTopHalf);
+            sInfo->mainState++;
+        }
+        else
+        {
+            sInfo->mainState = 3;
+        }
+        break;
+    case 1:
+        loading = sMenu->info.loadNewSelection();
+        if (!loading)
+            sInfo->mainState = 0;
+        break;
+    case 2:
+        break;
+    case 3:
+        BlendPalettes(PALETTES_ALL, 16, RGB_BLACK);
+        sInfo->mainState++;
+        break;
+    case 4:
+        ShowBg(0);
+        ShowBg(1);
+        ShowBg(3);
+        ShowBg(2);
+        sInfo->mainState++;
+        break;
+    case 5:
+        SetVBlankCallback(VBlankCB_UsePokeblockMenu);
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB_BLACK);
+        sInfo->mainState++;
+        break;
+    case 6:
+        if (!gPaletteFade.active)
+        {
+            ResetConditionSparkleSprites(sMenu->sparkles);
+            SetUsePokeblockCallback(ShowPokeblockResults);
+            SetMainCallback2(CB2_UsePokeblockMenu);
+        }
+        break;
+    }
+}
+
+static void ShowPokeblockResults(void)
+{
+    switch (sInfo->mainState)
+    {
+    case 0:
+        sInfo->mon = gPlayerParty;
+        sInfo->mon += sMenu->party[sMenu->info.curSelection].monId;
+        DestroyConditionSparkleSprites(sMenu->sparkles);
+        sInfo->mainState++;
+        break;
+    case 1:
+        if (JOY_NEW(A_BUTTON | B_BUTTON))
+            sInfo->mainState++;
+        break;
+    case 2:
+        CalculateConditionEnhancements();
+        ConditionGraph_CalcPositions(sInfo->conditionsAfterBlock, sMenu->graph.savedPositions[CONDITION_GRAPH_LOAD_MAX - 1]);
+        ConditionGraph_SetNewPositions(&sMenu->graph, sMenu->graph.savedPositions[sMenu->curLoadId], sMenu->graph.savedPositions[CONDITION_GRAPH_LOAD_MAX - 1]);
+        LoadAndCreateUpDownSprites();
+        sInfo->mainState++;
+        break;
+    case 3:
+        if (!ConditionGraph_TryUpdate(&sMenu->graph))
+        {
+            CalculateNumAdditionalSparkles(GetPartyIdFromSelectionId(sMenu->info.curSelection));
+            if (sMenu->info.curSelection != sMenu->info.numSelections - 1)
+            {
+                u8 numSparkles = sMenu->numSparkles[sMenu->curLoadId];
+                CreateConditionSparkleSprites(sMenu->sparkles, sMenu->curMonSpriteId, numSparkles);
+            }
+
+            sInfo->timer = 0;
+            sInfo->mainState++;
+        }
+        break;
+    case 4:
+        if (++sInfo->timer > 16)
+        {
+            PrintFirstEnhancement();
+            sInfo->mainState++;
+        }
+        break;
+    case 5:
+        if (JOY_NEW(A_BUTTON | B_BUTTON) && !TryPrintNextEnhancement())
+        {
+            TryClearPokeblock((u8)gSpecialVar_ItemId);
+            SetUsePokeblockCallback(CloseUsePokeblockMenu);
+        }
+        break;
+    }
+}
+
+static void CloseUsePokeblockMenu(void)
+{
+    u8 i;
+
+    switch (sInfo->mainState)
+    {
+    case 0:
+        BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB_BLACK);
+        sInfo->mainState++;
+        break;
+    case 1:
+        if (!gPaletteFade.active)
+            sInfo->mainState = 2;
+        break;
+    case 2:
+        gScanlineEffect.state = 3;
+        ScanlineEffect_InitHBlankDmaTransfer();
+        sInfo->mainState++;
+        break;
+    case 3:
+        SetMainCallback2(sInfo->exitCallback);
+        FreeConditionSparkles(sMenu->sparkles);
+        for (i = 0; i < ARRAY_COUNT(sMenu->selectionIconSpriteIds); i++)
+            DestroySprite(&gSprites[sMenu->selectionIconSpriteIds[i]]);
+
+        FreeSpriteTilesByTag(TAG_UP_DOWN);
+        FreeSpriteTilesByTag(TAG_CONDITION);
+        FreeSpritePaletteByTag(TAG_UP_DOWN);
+        FreeSpritePaletteByTag(TAG_CONDITION);
+
+        for (i = 0; i < ARRAY_COUNT(sMenu->condition); i++)
+            DestroySprite(sMenu->condition[i]);
+
+        if (sMenu->curMonSpriteId != SPRITE_NONE)
+            DestroySprite(&gSprites[sMenu->curMonSpriteId]);
+
+        SetVBlankCallback(NULL);
+        FREE_AND_SET_NULL(sGraph_Tilemap);
+        FREE_AND_SET_NULL(sGraph_Gfx);
+        FREE_AND_SET_NULL(sMonFrame_TilemapPtr);
+        FREE_AND_SET_NULL(sMenu);
+        FreeAllWindowBuffers();
+        break;
+    }
+}
+
+static void AskUsePokeblock(void)
+{
+    u8 stringBuffer[0x40];
+
+    GetMonData(&gPlayerParty[GetPartyIdFromSelectionId(sMenu->info.curSelection)], MON_DATA_NICKNAME, stringBuffer);
+    StringGet_Nickname(stringBuffer);
+    StringAppend(stringBuffer, gText_GetsAPokeBlockQuestion);
+    StringCopy(gStringVar4, stringBuffer);
+    FillWindowPixelBuffer(WIN_TEXT, 17);
+    DrawTextBorderOuter(WIN_TEXT, 151, 14);
+    AddTextPrinterParameterized(WIN_TEXT, FONT_NORMAL, gStringVar4, 0, 1, 0, NULL);
+    PutWindowTilemap(WIN_TEXT);
+    CopyWindowToVram(WIN_TEXT, COPYWIN_FULL);
+    CreateYesNoMenu(&sUsePokeblockYesNoWinTemplate, 151, 14, 0);
+}
+
+static s8 HandleAskUsePokeblockInput(void)
+{
+    s8 menuItem = Menu_ProcessInputNoWrapClearOnChoose();
+
+    switch (menuItem)
+    {
+    case 0: // YES
+        break;
+    case MENU_B_PRESSED:
+    case 1: // NO
+        PlaySE(SE_SELECT);
+        rbox_fill_rectangle(2);
+        ClearWindowTilemap(2);
+        break;
+    }
+
+    return menuItem;
+}
+
+static void PrintFirstEnhancement(void)
+{
+    DrawTextBorderOuter(WIN_TEXT, 151, 14);
+    FillWindowPixelBuffer(WIN_TEXT, 17);
+
+    for (sInfo->condition = 0; sInfo->condition < CONDITION_COUNT; sInfo->condition++)
+    {
+        if (sInfo->enhancements[sInfo->condition] != 0)
+            break;
+    }
+
+    if (sInfo->condition < CONDITION_COUNT)
+        BufferEnhancedText(gStringVar4, sInfo->condition, sInfo->enhancements[sInfo->condition]);
+    else
+        BufferEnhancedText(gStringVar4, sInfo->condition, 0);
+
+    PrintMenuWindowText(gStringVar4);
+    PutWindowTilemap(WIN_TEXT);
+    CopyWindowToVram(WIN_TEXT, COPYWIN_FULL);
+}
+
+static bool8 TryPrintNextEnhancement(void)
+{
+    FillWindowPixelBuffer(WIN_TEXT, 17);
+
+    while (1)
+    {
+        sInfo->condition++;
+        if (sInfo->condition < CONDITION_COUNT)
+        {
+            if (sInfo->enhancements[sInfo->condition] != 0)
+                break;
+        }
+        else
+        {
+            sInfo->condition = CONDITION_COUNT;
+            return FALSE;
+        }
+    }
+
+    BufferEnhancedText(gStringVar4, sInfo->condition, sInfo->enhancements[sInfo->condition]);
+    PrintMenuWindowText(gStringVar4);
+    CopyWindowToVram(WIN_TEXT, COPYWIN_GFX);
+
+    return TRUE;
+}
+
+static void PrintWontEatAnymore(void)
+{
+    FillWindowPixelBuffer(WIN_TEXT, 17);
+    DrawTextBorderOuter(WIN_TEXT, 151, 14);
+    AddTextPrinterParameterized(WIN_TEXT, FONT_NORMAL, gText_WontEatAnymore, 0, 1, 0, NULL);
+    PutWindowTilemap(WIN_TEXT);
+    CopyWindowToVram(WIN_TEXT, COPYWIN_FULL);
+}
+
+static void EraseMenuWindow(void)
+{
+    rbox_fill_rectangle(WIN_TEXT);
+    ClearWindowTilemap(WIN_TEXT);
+    CopyWindowToVram(WIN_TEXT, COPYWIN_FULL);
+}
+
+static void PrintMenuWindowText(const u8 *message)
+{
+    AddTextPrinterParameterized(WIN_TEXT, FONT_NORMAL, gStringVar4, 0, 1, 0, NULL);
+}
+
+static void BufferEnhancedText(u8 *dest, u8 condition, s16 enhancement)
+{
+    switch (enhancement)
+    {
+    case 1 ... 32767: // if > 0
+        enhancement = 0;
+        // fallthrough
+    case -32768 ... -1: // if < 0
+        if (enhancement)
+            dest[(u16)enhancement] += 0; // something you can't imagine
+        StringCopy(dest, sConditionNames[condition]);
+        StringAppend(dest, gText_WasEnhanced);
+        break;
+    case 0:
+        StringCopy(dest, gText_NothingChanged);
+        break;
+    }
+}
+
+static void GetMonConditions(struct Pokemon *mon, u8 *data)
+{
+    u16 i;
+
+    for (i = 0; i < CONDITION_COUNT; i++)
+        data[i] = GetMonData(mon, sConditionToMonData[i]);
+}
+
+static void AddPokeblockToConditions(struct Pokeblock *pokeblock, struct Pokemon *mon)
+{
+    u16 i;
+    s16 stat;
+    u8 data;
+
+    if (GetMonData(mon, MON_DATA_SHEEN) != MAX_SHEEN)
+    {
+        CalculatePokeblockEffectiveness(pokeblock, mon);
+        for (i = 0; i < CONDITION_COUNT; i++)
+        {
+            data = GetMonData(mon, sConditionToMonData[i]);
+            stat = data +  sInfo->pokeblockStatBoosts[i];
+            if (stat < 0)
+                stat = 0;
+            if (stat > MAX_CONDITION)
+                stat = MAX_CONDITION;
+            data = stat;
+            SetMonData(mon, sConditionToMonData[i], &data);
+        }
+
+        stat = (u8)(GetMonData(mon, MON_DATA_SHEEN)) + pokeblock->feel;
+        if (stat > MAX_SHEEN)
+            stat = MAX_SHEEN;
+
+        data = stat;
+        SetMonData(mon, MON_DATA_SHEEN, &data);
+    }
+}
+
+static void CalculateConditionEnhancements(void)
+{
+    u16 i;
+    struct Pokemon *mon = gPlayerParty;
+    mon += sMenu->party[sMenu->info.curSelection].monId;
+
+    GetMonConditions(mon, sInfo->conditionsBeforeBlock);
+    AddPokeblockToConditions(sInfo->pokeblock, mon);
+    GetMonConditions(mon, sInfo->conditionsAfterBlock);
+    for (i = 0; i < CONDITION_COUNT; i++)
+        sInfo->enhancements[i] = sInfo->conditionsAfterBlock[i] - sInfo->conditionsBeforeBlock[i];
+}
+
+static void CalculatePokeblockEffectiveness(struct Pokeblock *pokeblock, struct Pokemon *mon)
+{
+    s8 i, direction, flavor;
+
+    sInfo->pokeblockStatBoosts[CONDITION_COOL] = pokeblock->spicy;
+    sInfo->pokeblockStatBoosts[CONDITION_TOUGH] = pokeblock->sour;
+    sInfo->pokeblockStatBoosts[CONDITION_SMART] = pokeblock->bitter;
+    sInfo->pokeblockStatBoosts[CONDITION_CUTE] = pokeblock->sweet;
+    sInfo->pokeblockStatBoosts[CONDITION_BEAUTY] = pokeblock->dry;
+
+    if (gPokeblockGain > 0)
+        direction = 1;
+    else if (gPokeblockGain < 0)
+        direction = -1;
+    else
+        return;
+
+    for (i = 0; i < CONDITION_COUNT; i++)
+    {
+        s16 amount = sInfo->pokeblockStatBoosts[i];
+        s8 boost = amount / 10;
+
+        if (amount % 10 >= 5) // round to the nearest
+            boost++;
+
+        flavor = GetMonFlavorRelation(mon, sConditionToFlavor[i]);
+        if (flavor == direction)
+            sInfo->pokeblockStatBoosts[i] += boost * flavor;
+    }
+}
+
+static bool8 IsSheenMaxed(void)
+{
+    if (GetBoxOrPartyMonData(sMenu->party[sMenu->info.curSelection].boxId,
+                             sMenu->party[sMenu->info.curSelection].monId,
+                             MON_DATA_SHEEN,
+                             NULL) == MAX_SHEEN)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static u8 GetPartyIdFromSelectionId(u8 selectionId)
+{
+    u8 i;
+
+    for (i = 0; i < PARTY_SIZE; i++)
+    {
+        if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+        {
+            if (selectionId == 0)
+                return i;
+            selectionId--;
+        }
+    }
+
+    return 0;
+}
+
+// Eggs are not viewable on the condition screen, so count how many are skipped over to reach the party id
+static u8 GetSelectionIdFromPartyId(u8 partyId)
+{
+    u8 i, numEggs;
+    for (i = 0, numEggs = 0; i < partyId; i++)
+    {
+        if (GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+            numEggs++;
+    }
+
+    return partyId - numEggs;
+}
+
+// Unused
+static u8 GetPartyIdFromSelectionId_(u8 selectionId)
+{
+    return GetPartyIdFromSelectionId(selectionId);
+}
+
+static void LoadAndCreateUpDownSprites(void)
+{
+    u16 i, spriteId;
+
+    LoadSpriteSheet(&sSpriteSheet_UpDown);
+    LoadSpritePalette(&sSpritePalette_UpDown);
+    sInfo->numEnhancements = 0;
+
+    for (i = 0; i < CONDITION_COUNT; i++)
+    {
+        if (sInfo->enhancements[i] != 0)
+        {
+            spriteId = CreateSprite(&sSpriteTemplate_UpDown, sUpDownCoordsOnGraph[i][0], sUpDownCoordsOnGraph[i][1], 0);
+            if (spriteId != MAX_SPRITES)
+            {
+                if (sInfo->enhancements[i] != 0) // Always true here
+                    gSprites[spriteId].callback = SpriteCB_UpDown;
+                sInfo->numEnhancements++;
+            }
+        }
+    }
+}
+
+static void SpriteCB_UpDown(struct Sprite *sprite)
+{
+    if (sprite->data[0] < 6)
+        sprite->y2 -= 2;
+    else if (sprite->data[0] < 12)
+        sprite->y2 += 2;
+
+    if (++sprite->data[0] > 60)
+    {
+        DestroySprite(sprite);
+        sInfo->numEnhancements--;
+    }
+}
+
+static void LoadPartyInfo(void)
+{
+    u16 i;
+    u16 numMons;
+
+    for (i = 0, numMons = 0; i < CalculatePlayerPartyCount(); i++)
+    {
+        if (!GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
+        {
+            sMenu->party[numMons].boxId = TOTAL_BOXES_COUNT;
+            sMenu->party[numMons].monId = i;
+            sMenu->party[numMons].data = 0;
+            numMons++;
+        }
+    }
+
+    sMenu->info.curSelection = 0;
+    sMenu->info.numSelections = numMons + 1;
+    LoadInitialMonInfo();
+}
+
+static void LoadInitialMonInfo(void)
+{
+    s16 nextSelection, prevSelection;
+
+    LoadMonInfo(sMenu->info.curSelection, 0);
+    sMenu->curLoadId = 0;
+    sMenu->nextLoadId = 1;
+    sMenu->prevLoadId = 2;
+
+    nextSelection = sMenu->info.curSelection + 1;
+    if (nextSelection >= sMenu->info.numSelections)
+        nextSelection = 0;
+
+    prevSelection = sMenu->info.curSelection - 1;
+    if (prevSelection < 0)
+        prevSelection = sMenu->info.numSelections - 1;
+
+    LoadMonInfo(nextSelection, 1);
+    LoadMonInfo(prevSelection, 2);
+}
+
+static void LoadMonInfo(s16 partyId, u8 loadId)
+{
+    u8 boxId = sMenu->party[partyId].boxId;
+    u8 monId = sMenu->party[partyId].monId;
+    u8 numSelections = sMenu->info.numSelections;
+    bool8 excludesCancel = FALSE; // whether or not numSelections excludes Cancel from the count
+
+    GetConditionMenuMonNameAndLocString(sMenu->locationStrings[loadId], sMenu->monNameStrings[loadId], boxId, monId, partyId, numSelections, excludesCancel);
+    GetConditionMenuMonConditions(&sMenu->graph, sMenu->numSparkles, boxId, monId, partyId, loadId, numSelections, excludesCancel);
+    GetConditionMenuMonGfx(sMenu->partySheets[loadId], sMenu->partyPalettes[loadId], boxId, monId, partyId, numSelections, excludesCancel);
+}
+
+static void UpdateMonPic(u8 loadId)
+{
+    u8 spriteId;
+    struct SpriteTemplate spriteTemplate;
+    struct SpriteSheet spriteSheet;
+    struct SpritePalette spritePal;
+
+    if (sMenu->curMonSpriteId == SPRITE_NONE)
+    {
+        LoadConditionMonPicTemplate(&spriteSheet, &spriteTemplate, &spritePal);
+        spriteSheet.data = sMenu->partySheets[loadId];
+        spritePal.data = sMenu->partyPalettes[loadId];
+        sMenu->curMonPalette = LoadSpritePalette(&spritePal);
+        sMenu->curMonSheet = LoadSpriteSheet(&spriteSheet);
+        spriteId = CreateSprite(&spriteTemplate, 38, 104, 0);
+        sMenu->curMonSpriteId = spriteId;
+        if (spriteId == MAX_SPRITES)
+        {
+            FreeSpriteTilesByTag(TAG_CONDITION_MON);
+            FreeSpritePaletteByTag(TAG_CONDITION_MON);
+            sMenu->curMonSpriteId = SPRITE_NONE;
+        }
+        else
+        {
+            sMenu->curMonSpriteId = spriteId;
+            gSprites[sMenu->curMonSpriteId].callback = SpriteCB_MonPic;
+            gSprites[sMenu->curMonSpriteId].y2 -= 34;
+            sMenu->curMonTileStart = (void*)(OBJ_VRAM0 + (sMenu->curMonSheet * 32));
+            sMenu->curMonPalette = (sMenu->curMonPalette * 16) + 0x100;
+        }
+    }
+    else
+    {
+        Dma3CopyLarge16_(sMenu->partySheets[loadId], sMenu->curMonTileStart, MON_PIC_SIZE);
+        LoadPalette(sMenu->partyPalettes[loadId], sMenu->curMonPalette, 32);
+    }
+}
+
+static void LoadAndCreateSelectionIcons(void)
+{
+    u16 i, spriteId;
+    struct SpriteSheet spriteSheets[4];
+    struct SpriteTemplate spriteTemplate;
+    struct SpritePalette spritePals[3];
+    struct SpriteSheet spriteSheet2;
+    struct SpritePalette spritePal2;
+
+    LoadConditionSelectionIcons(spriteSheets, &spriteTemplate, spritePals);
+    LoadSpriteSheets(spriteSheets);
+    LoadSpritePalettes(spritePals);
+
+    // Fill pokeball selection icons up to number in party
+    for (i = 0; i < sMenu->info.numSelections - 1; i++)
+    {
+        spriteId = CreateSprite(&spriteTemplate, 226, (i * 20) + 8, 0);
+        if (spriteId != MAX_SPRITES)
+        {
+            sMenu->selectionIconSpriteIds[i] = spriteId;
+            gSprites[spriteId].data[0] = i;
+            gSprites[spriteId].callback = SpriteCB_SelectionIconPokeball;
+        }
+        else
+        {
+            sMenu->selectionIconSpriteIds[i] = -1;
+        }
+    }
+
+    // Fill placeholder icons for remaining (empty) party slots
+    spriteTemplate.tileTag = TAG_CONDITION_BALL_PLACEHOLDER;
+    for (; i < PARTY_SIZE; i++)
+    {
+        spriteId = CreateSprite(&spriteTemplate, 230, (i * 20) + 8, 0);
+        if (spriteId != MAX_SPRITES)
+        {
+            sMenu->selectionIconSpriteIds[i] = spriteId;
+            gSprites[spriteId].oam.size = 0;
+        }
+        else
+        {
+            sMenu->selectionIconSpriteIds[i] = -1;
+        }
+    }
+
+    // Add cancel selection icon at bottom
+    spriteTemplate.tileTag = TAG_CONDITION_CANCEL;
+    spriteTemplate.callback = SpriteCB_SelectionIconCancel;
+    spriteId = CreateSprite(&spriteTemplate, 222, (i * 20) + 8, 0);
+    if (spriteId != MAX_SPRITES)
+    {
+        sMenu->selectionIconSpriteIds[i] = spriteId;
+        gSprites[spriteId].oam.shape = SPRITE_SHAPE(32x16);
+        gSprites[spriteId].oam.size = SPRITE_SIZE(32x16);
+    }
+    else
+    {
+        sMenu->selectionIconSpriteIds[i] = -1;
+    }
+
+    LoadConditionSparkle(&spriteSheet2, &spritePal2);
+    LoadSpriteSheet(&spriteSheet2);
+    LoadSpritePalette(&spritePal2);
+}
+
+static bool8 LoadUsePokeblockMenuGfx(void)
+{
+    switch (sMenu->info.helperState)
+    {
+    case 0:
+        ChangeBgX(0, 0, BG_COORD_SET);
+        ChangeBgY(0, 0, BG_COORD_SET);
+        ChangeBgX(1, 0, BG_COORD_SET);
+        ChangeBgY(1, 0, BG_COORD_SET);
+        ChangeBgX(2, 0, BG_COORD_SET);
+        ChangeBgY(2, 0, BG_COORD_SET);
+        ChangeBgX(3, 0, BG_COORD_SET);
+        ChangeBgY(3, 136 << 6, BG_COORD_SET);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
+        SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG2 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_BG1);
+        SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(11, 4));
+        break;
+    case 1:
+        sGraph_Gfx = Alloc(6656);
+        sGraph_Tilemap = Alloc(1280);
+        sMonFrame_TilemapPtr = Alloc(1280);
+        break;
+    case 2:
+        LZ77UnCompVram(sMonFrame_Tilemap, sMonFrame_TilemapPtr);
+        break;
+    case 3:
+        LoadBgTiles(3, sMonFrame_Gfx, 224, 0);
+        break;
+    case 4:
+         LoadBgTilemap(3, sMonFrame_TilemapPtr, 1280, 0);
+        break;
+    case 5:
+        LoadPalette(sMonFrame_Pal, 208, 32);
+        sMenu->curMonXOffset = -80;
+        break;
+    case 6:
+        LZ77UnCompVram(gUsePokeblockGraph_Gfx, sGraph_Gfx);
+        break;
+    case 7:
+        LZ77UnCompVram(gUsePokeblockGraph_Tilemap, sGraph_Tilemap);
+        LoadPalette(gUsePokeblockGraph_Pal, 32, 32);
+        break;
+    case 8:
+        LoadBgTiles(1, sGraph_Gfx, 6656, 160 << 2);
+        break;
+    case 9:
+        SetBgTilemapBuffer(1, sGraph_Tilemap);
+        CopyToBgTilemapBufferRect(1, gUsePokeblockNatureWin_Pal, 0, 13, 12, 4);
+        CopyBgTilemapBufferToVram(1);
+        break;
+    case 10:
+        LZ77UnCompVram(sGraphData_Tilemap, sMenu->tilemapBuffer);
+        break;
+    case 11:
+        LoadBgTilemap(2, sMenu->tilemapBuffer, 1280, 0);
+        LoadPalette(gConditionGraphData_Pal, 48, 32);
+        LoadPalette(gConditionText_Pal, 240, 32);
+        ConditionGraph_InitWindow(2);
+        break;
+    default:
+        sMenu->info.helperState = 0;
+        return FALSE;
+    }
+
+    sMenu->info.helperState++;
+    return TRUE;
+}
+
+static void UpdateMonInfoText(u16 loadId, bool8 firstPrint)
+{
+    u8 partyIndex;
+    u8 nature;
+    u8 *str;
+
+    FillWindowPixelBuffer(WIN_NAME, PIXEL_FILL(0));
+    FillWindowPixelBuffer(WIN_NATURE, PIXEL_FILL(0));
+    if (sMenu->info.curSelection != sMenu->info.numSelections - 1)
+    {
+        AddTextPrinterParameterized(WIN_NAME, FONT_NORMAL, sMenu->monNameStrings[loadId], 0, 1, 0, NULL);
+        partyIndex = GetPartyIdFromSelectionId(sMenu->info.curSelection);
+        nature = GetNature(&gPlayerParty[partyIndex]);
+        str = StringCopy(sMenu->info.natureText, gText_NatureSlash);
+        str = StringCopy(str, gNatureNamePointers[nature]);
+        AddTextPrinterParameterized3(WIN_NATURE, FONT_NORMAL, 2, 1, sNatureTextColors, 0, sMenu->info.natureText);
+    }
+
+    if (firstPrint)
+    {
+        CopyWindowToVram(WIN_NAME, COPYWIN_FULL);
+        CopyWindowToVram(WIN_NATURE, COPYWIN_FULL);
+    }
+    else
+    {
+        CopyWindowToVram(WIN_NAME, COPYWIN_GFX);
+        CopyWindowToVram(WIN_NATURE, COPYWIN_GFX);
+    }
+}
+
+static void UpdateSelection(bool8 up)
+{
+    u16 newLoadId;
+    bool32 startedOnMon, endedOnMon;
+
+    if (up)
+        newLoadId = sMenu->prevLoadId;
+    else
+        newLoadId = sMenu->nextLoadId;
+
+    ConditionGraph_SetNewPositions(&sMenu->graph, sMenu->graph.savedPositions[sMenu->curLoadId], sMenu->graph.savedPositions[newLoadId]);
+
+    if (sMenu->info.curSelection == sMenu->info.numSelections - 1)
+        startedOnMon = FALSE; // moving off of Cancel
+    else
+        startedOnMon = TRUE;
+
+    if (up)
+    {
+        sMenu->prevLoadId = sMenu->nextLoadId; // temporarily store nextLoadId, prevLoadId no longer needed
+        sMenu->nextLoadId = sMenu->curLoadId;
+        sMenu->curLoadId = newLoadId;
+        sMenu->toLoadId = sMenu->prevLoadId; // next load will be the mon that's one up from new selection
+
+        // Check for wrap to bottom of list
+        sMenu->info.curSelection = (sMenu->info.curSelection == 0)
+            ? sMenu->info.numSelections - 1
+            : sMenu->info.curSelection - 1;
+
+        sMenu->toLoadSelection = (sMenu->info.curSelection == 0)
+            ? sMenu->info.numSelections - 1
+            : sMenu->info.curSelection - 1;
+    }
+    else
+    {
+        sMenu->nextLoadId = sMenu->prevLoadId; // temporarily store prevLoadId, nextLoadId no longer needed
+        sMenu->prevLoadId = sMenu->curLoadId;
+        sMenu->curLoadId = newLoadId;
+        sMenu->toLoadId = sMenu->nextLoadId; // next load will be the mon that's one down from new selection
+
+        // Check for wrap to top of list
+        sMenu->info.curSelection = (sMenu->info.curSelection < sMenu->info.numSelections - 1)
+            ? sMenu->info.curSelection + 1
+            : 0;
+
+        sMenu->toLoadSelection = (sMenu->info.curSelection < sMenu->info.numSelections - 1)
+            ? sMenu->info.curSelection + 1
+            : 0;
+    }
+
+    if (sMenu->info.curSelection == sMenu->info.numSelections - 1)
+        endedOnMon = FALSE; // moving onto Cancel
+    else
+        endedOnMon = TRUE;
+
+    DestroyConditionSparkleSprites(sMenu->sparkles);
+
+    if (!startedOnMon)
+        sMenu->info.loadNewSelection = LoadNewSelection_CancelToMon;
+    else if (!endedOnMon)
+        sMenu->info.loadNewSelection = LoadNewSelection_MonToCancel;
+    else
+        sMenu->info.loadNewSelection = LoadNewSelection_MonToMon;
+}
+
+static bool8 LoadNewSelection_CancelToMon(void)
+{
+    switch (sMenu->info.helperState)
+    {
+    case 0:
+        UpdateMonPic(sMenu->curLoadId);
+        sMenu->info.helperState++;
+        break;
+    case 1:
+        UpdateMonInfoText(sMenu->curLoadId, FALSE);
+        sMenu->info.helperState++;
+        break;
+    case 2:
+        if (!ConditionMenu_UpdateMonEnter(&sMenu->graph, &sMenu->curMonXOffset))
+        {
+            // Load the new adjacent pokemon (not the one being shown)
+            LoadMonInfo(sMenu->toLoadSelection, sMenu->toLoadId);
+            sMenu->info.helperState++;
+        }
+        break;
+    case 3:
+        ResetConditionSparkleSprites(sMenu->sparkles);
+        if (sMenu->info.curSelection != sMenu->info.numSelections - 1)
+        {
+            u8 numSparkles = sMenu->numSparkles[sMenu->curLoadId];
+            CreateConditionSparkleSprites(sMenu->sparkles, sMenu->curMonSpriteId, numSparkles);
+        }
+
+        sMenu->info.helperState = 0;
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 LoadNewSelection_MonToCancel(void)
+{
+    switch (sMenu->info.helperState)
+    {
+    case 0:
+        if (!ConditionMenu_UpdateMonExit(&sMenu->graph, &sMenu->curMonXOffset))
+            sMenu->info.helperState++;
+        break;
+    case 1:
+        UpdateMonInfoText(sMenu->curLoadId, FALSE);
+        sMenu->info.helperState++;
+        break;
+    case 2:
+        LoadMonInfo(sMenu->toLoadSelection, sMenu->toLoadId);
+        sMenu->info.helperState++;
+        break;
+    case 3:
+        sMenu->info.helperState = 0;
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static bool8 LoadNewSelection_MonToMon(void)
+{
+    switch (sMenu->info.helperState)
+    {
+    case 0:
+        ConditionGraph_TryUpdate(&sMenu->graph);
+        if (!MoveConditionMonOffscreen(&sMenu->curMonXOffset))
+        {
+            UpdateMonPic(sMenu->curLoadId);
+            sMenu->info.helperState++;
+        }
+        break;
+    case 1:
+        UpdateMonInfoText(sMenu->curLoadId, FALSE);
+        sMenu->info.helperState++;
+        break;
+    case 2:
+        if (!ConditionMenu_UpdateMonEnter(&sMenu->graph, &sMenu->curMonXOffset))
+        {
+            // Load the new adjacent pokemon (not the one being shown)
+            LoadMonInfo(sMenu->toLoadSelection, sMenu->toLoadId);
+            sMenu->info.helperState++;
+        }
+        break;
+    case 3:
+        ResetConditionSparkleSprites(sMenu->sparkles);
+        if (sMenu->info.curSelection != sMenu->info.numSelections - 1)
+        {
+            u8 numSparkles = sMenu->numSparkles[sMenu->curLoadId];
+            CreateConditionSparkleSprites(sMenu->sparkles, sMenu->curMonSpriteId, numSparkles);
+        }
+
+        sMenu->info.helperState = 0;
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void SpriteCB_MonPic(struct Sprite *sprite)
+{
+    sprite->x = sMenu->curMonXOffset + 38;
+}
+
+static void SpriteCB_SelectionIconPokeball(struct Sprite *sprite)
+{
+    if (sprite->data[0] == sMenu->info.curSelection)
+        StartSpriteAnim(sprite, CONDITION_ICON_SELECTED);
+    else
+        StartSpriteAnim(sprite, CONDITION_ICON_UNSELECTED);
+}
+
+static void SpriteCB_SelectionIconCancel(struct Sprite *sprite)
+{
+    if (sMenu->info.curSelection == sMenu->info.numSelections - 1)
+        sprite->oam.paletteNum = IndexOfSpritePaletteTag(TAG_CONDITION_BALL);
+    else
+        sprite->oam.paletteNum = IndexOfSpritePaletteTag(TAG_CONDITION_CANCEL);
+}
+
+// Calculate the max id for sparkles/stars that appear around the pokemon on the condition screen
+// All pokemon start with 1 sparkle (added by CreateConditionSparkleSprites), so the number here +1
+// is the total number of sparkles that appear
+static void CalculateNumAdditionalSparkles(u8 monIndex)
+{
+    u8 sheen = GetMonData(&gPlayerParty[monIndex], MON_DATA_SHEEN);
+    sMenu->numSparkles[sMenu->curLoadId] = GET_NUM_CONDITION_SPARKLES(sheen);
+}
+
+static void LoadConditionGfx(void)
+{
+    struct CompressedSpriteSheet spriteSheet;
+    struct SpritePalette spritePalette;
+
+    spritePalette = sSpritePalette_Condition;
+    spriteSheet.data = gUsePokeblockCondition_Gfx;
+    spriteSheet.size = 0x800;
+    spriteSheet.tag = TAG_CONDITION;
+    LoadCompressedSpriteSheet(&spriteSheet);
+    LoadSpritePalette(&spritePalette);
+}
+
+static void CreateConditionSprite(void)
+{
+    u16 i;
+    s16 xDiff, xStart;
+    int yStart = 17;
+    int var = 8;
+    struct Sprite **sprites = sMenu->condition;
+    const struct SpriteTemplate *template = &sSpriteTemplate_Condition;
+
+    for (i = 0, xDiff = 64, xStart = -96; i < 2; i++)
+    {
+        u8 spriteId = CreateSprite(template, i * xDiff + xStart, yStart, 0);
+        if (spriteId != MAX_SPRITES)
+        {
+            gSprites[spriteId].data[0] = var;
+            gSprites[spriteId].data[1] = (i * xDiff) | 0x20;
+            gSprites[spriteId].data[2] = i;
+            StartSpriteAnim(&gSprites[spriteId], i);
+            sprites[i] = &gSprites[spriteId];
+        }
+    }
+}
+
+static bool8 LoadConditionTitle(void)
+{
+    switch (sMenu->info.helperState)
+    {
+    case 0:
+        LoadConditionGfx();
+        sMenu->info.helperState++;
+        return TRUE;
+    case 1:
+        CreateConditionSprite();
+        sMenu->info.helperState = 0;
+        return FALSE;
+    }
+
+    return FALSE;
+}
+
+// Literally the word "Condition", the title block that appears over the mon icon
+static void SpriteCB_Condition(struct Sprite *sprite)
+{
+    s16 prevX = sprite->x;
+
+    sprite->x += sprite->data[0];
+    if ((prevX <= sprite->data[1] && sprite->x >= sprite->data[1])
+     || (prevX >= sprite->data[1] && sprite->x <= sprite->data[1]))
+    {
+        sprite->x = sprite->data[1];
+        sprite->callback = SpriteCallbackDummy;
+    }
+}