pokeemerald/src/battle_pyramid_bag.c

#include "global.h"
#include "battle.h"
#include "battle_controllers.h"
#include "battle_pyramid_bag.h"
#include "bg.h"
#include "decompress.h"
#include "event_data.h"
#include "field_effect.h"
#include "field_weather.h"
#include "graphics.h"
#include "gpu_regs.h"
#include "international_string_util.h"
#include "item.h"
#include "item_icon.h"
#include "item_menu.h"
#include "item_use.h"
#include "list_menu.h"
#include "mail.h"
#include "main.h"
#include "malloc.h"
#include "menu.h"
#include "menu_helpers.h"
#include "overworld.h"
#include "palette.h"
#include "party_menu.h"
#include "task.h"
#include "text_window.h"
#include "scanline_effect.h"
#include "script.h"
#include "sound.h"
#include "string_util.h"
#include "strings.h"
#include "constants/items.h"
#include "constants/rgb.h"
#include "constants/songs.h"

#define TAG_SCROLL_ARROW  2910
#define TAG_PYRAMID_BAG   4132
#define TAG_ITEM_ICON     4133
#define TAG_ITEM_ICON_ALT 4134

#define POS_NONE ((u8)-1)

enum {
    WIN_LIST,
    WIN_INFO,
    WIN_MSG,
    WIN_TOSS_NUM,
};

EWRAM_DATA struct PyramidBagMenu *gPyramidBagMenu = NULL;
EWRAM_DATA struct PyramidBagMenuState gPyramidBagMenuState = {0};

static void Task_HandlePyramidBagInput(u8);
static void Task_ChooseItemsToTossFromPyramidBag(u8);
static void Task_ClosePyramidBag(u8);
static void Task_BeginItemSwap(u8);
static void OpenContextMenu(u8);
static void TryCloseBagToGiveItem(u8);
static void HandleMenuActionInput_2x2(u8);
static void HandleMenuActionInput_SingleRow(u8);
static void Task_WaitCloseErrorMessage(u8);
static void SetTaskToMainPyramidBagInputHandler(u8);
static void AskConfirmToss(u8);
static void Task_ChooseHowManyToToss(u8);
static void Task_TossItem(u8);
static void ShowCantHoldMessage(u8);
static void PerformItemSwap(u8);
static void Task_ItemSwapHandleInput(u8);
static void CancelItemSwap(u8);
static void SetBagItemsListTemplate(void);
static void CB2_LoadPyramidBagMenu(void);
static void InitPyramidBagBgs(void);
static void AddScrollArrows(void);
static void CreatePyramidBagInputTask(void);
static void InitPyramidBagScroll(void);
static void InitPyramidBagWindows(void);
static void CreatePyramidBagSprite(void);
static void CreateSwapLine(void);
static void LoadPyramidBagPalette(void);
static void ShakePyramidBag(void);
static void ShowNumToToss(void);
static void CloseBattlePyramidBagTextWindow(void);
static bool8 LoadPyramidBagGfx(void);
static bool8 LoadPyramidBagMenu(void);
static void ShowItemIcon(u16, u8);
static void CopyBagItemName(u8 *, u16);
static void FreeItemIconSpriteByAltId(u8);
static void PrintItemDescription(s32);
static void PrintSelectorArrowAtPos(u8, u8);
static void PyramidBagPrint(u8, const u8 *, u8, u8, u8, u8, u8, u8);
static void PyramidBagPrint_Quantity(u8, const u8 *, u8, u8, u8, u8, u8, u8);
static u8 OpenMenuActionWindowById(u8);
static void CloseMenuActionWindowById(u8);
static void PrintMenuActionText_SingleRow(u8);
static void PrintMenuActionText_MultiRow(u8, u8, u8);
static bool8 IsValidMenuAction(s8);
static void CreatePyramidBagYesNo(u8, const struct YesNoFuncTable *);
static void DrawTossNumberWindow(u8);
static void UpdateSwapLinePos(u8);
static void SetSwapLineInvisibility(bool8);
static void SpriteCB_BagWaitForShake(struct Sprite *);
static void BagAction_UseOnField(u8);
static void BagAction_Toss(u8);
static void BagAction_Give(u8);
static void BagAction_Cancel(u8);
static void BagAction_UseInBattle(u8);
static void BagCursorMoved(s32, bool8, struct ListMenu *);
static void PrintItemQuantity(u8 windowId, u32 itemId, u8 y);
static void TossItem(u8);
static void DontTossItem(u8);

static const struct BgTemplate sBgTemplates[] =
{
    {
        .bg = 0,
        .charBaseIndex = 0,
        .mapBaseIndex = 31,
        .screenSize = 0,
        .paletteMode = 0,
        .priority = 1,
        .baseTile = 0
    },
    {
        .bg = 1,
        .charBaseIndex = 0,
        .mapBaseIndex = 30,
        .screenSize = 0,
        .paletteMode = 0,
        .priority = 0,
        .baseTile = 0
    },
    {
        .bg = 2,
        .charBaseIndex = 3,
        .mapBaseIndex = 29,
        .screenSize = 0,
        .paletteMode = 0,
        .priority = 2,
        .baseTile = 0
    },
};

static const struct ListMenuTemplate sListMenuTemplate =
{
    .items = NULL,
    .moveCursorFunc = BagCursorMoved,
    .itemPrintFunc = PrintItemQuantity,
    .totalItems = 0,
    .maxShowed = 0,
    .windowId = WIN_LIST,
    .header_X = 0,
    .item_X = 8,
    .cursor_X = 0,
    .upText_Y = 1,
    .cursorPal = 2,
    .fillValue = 0,
    .cursorShadowPal = 3,
    .lettersSpacing = 0,
    .itemVerticalPadding = 0,
    .scrollMultiple = LIST_NO_MULTIPLE_SCROLL,
    .fontId = FONT_NARROW,
    .cursorKind = 0
};

enum {
    ACTION_USE_FIELD,
    ACTION_TOSS,
    ACTION_GIVE,
    ACTION_CANCEL,
    ACTION_USE_BATTLE,
    ACTION_DUMMY,
};

static const struct MenuAction sMenuActions[] =
{
    [ACTION_USE_FIELD] =    { gMenuText_Use, BagAction_UseOnField },
    [ACTION_TOSS] =         { gMenuText_Toss, BagAction_Toss },
    [ACTION_GIVE] =         { gMenuText_Give, BagAction_Give },
    [ACTION_CANCEL] =       { gText_Cancel2, BagAction_Cancel },
    [ACTION_USE_BATTLE] =   { gMenuText_Use, BagAction_UseInBattle },
    [ACTION_DUMMY] =        { gText_EmptyString2, NULL },
};

static const u8 sMenuActionIds_Field[] = {ACTION_USE_FIELD, ACTION_GIVE, ACTION_TOSS, ACTION_CANCEL};
static const u8 sMenuActionIds_ChooseToss[] = {ACTION_TOSS, ACTION_CANCEL};
static const u8 sMenuActionIds_Battle[] = {ACTION_USE_BATTLE, ACTION_CANCEL};
static const u8 sMenuActionIds_BattleCannotUse[] = {ACTION_CANCEL};

static const struct YesNoFuncTable sYesNoTossFuncions =
{
    TossItem, DontTossItem
};

enum {
    COLORID_DARK_GRAY,
    COLORID_LIGHT_GRAY,
    COLORID_WHITE_BG,
    COLORID_NONE = 0xFF
};

static const u8 sTextColors[][3] =
{
    [COLORID_DARK_GRAY]  = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_DARK_GRAY,  TEXT_COLOR_LIGHT_GRAY},
    [COLORID_LIGHT_GRAY] = {TEXT_COLOR_TRANSPARENT, TEXT_COLOR_LIGHT_GRAY, TEXT_COLOR_WHITE},
    [COLORID_WHITE_BG]   = {TEXT_COLOR_WHITE,       TEXT_COLOR_DARK_GRAY,  TEXT_COLOR_LIGHT_GRAY}, // Unused
};

static const struct WindowTemplate sWindowTemplates[] =
{
    [WIN_LIST] = {
        .bg = 0,
        .tilemapLeft = 14,
        .tilemapTop = 2,
        .width = 15,
        .height = 16,
        .paletteNum = 15,
        .baseBlock = 30
    },
    [WIN_INFO] = {
        .bg = 0,
        .tilemapLeft = 0,
        .tilemapTop = 13,
        .width = 14,
        .height = 6,
        .paletteNum = 15,
        .baseBlock = 270
    },
    [WIN_MSG] = {
        .bg = 1,
        .tilemapLeft = 2,
        .tilemapTop = 15,
        .width = 27,
        .height = 4,
        .paletteNum = 15,
        .baseBlock = 354
    },
    [WIN_TOSS_NUM] = {
        .bg = 1,
        .tilemapLeft = 24,
        .tilemapTop = 17,
        .width = 5,
        .height = 2,
        .paletteNum = 15,
        .baseBlock = 462
    },
    DUMMY_WIN_TEMPLATE,
};

enum {
    MENU_WIN_1x1,
    MENU_WIN_1x2,
    MENU_WIN_2x2,
    MENU_WIN_2x3,
    MENU_WIN_YESNO,
};

static const struct WindowTemplate sWindowTemplates_MenuActions[] =
{
    [MENU_WIN_1x1] = {
        .bg = 1,
        .tilemapLeft = 22,
        .tilemapTop = 17,
        .width = 7,
        .height = 2,
        .paletteNum = 15,
        .baseBlock = 472
    },
    [MENU_WIN_1x2] = {
        .bg = 1,
        .tilemapLeft = 22,
        .tilemapTop = 15,
        .width = 7,
        .height = 4,
        .paletteNum = 15,
        .baseBlock = 472
    },
    [MENU_WIN_2x2] = {
        .bg = 1,
        .tilemapLeft = 15,
        .tilemapTop = 15,
        .width = 14,
        .height = 4,
        .paletteNum = 15,
        .baseBlock = 472
    },
    [MENU_WIN_2x3] = { // Unused
        .bg = 1,
        .tilemapLeft = 15,
        .tilemapTop = 13,
        .width = 14,
        .height = 6,
        .paletteNum = 15,
        .baseBlock = 472
    },
    [MENU_WIN_YESNO] = {
        .bg = 1,
        .tilemapLeft = 24,
        .tilemapTop = 15,
        .width = 5,
        .height = 4,
        .paletteNum = 15,
        .baseBlock = 472
    },
};

static const struct OamData sOamData_PyramidBag =
{
    .y = 0,
    .affineMode = ST_OAM_AFFINE_NORMAL,
    .objMode = ST_OAM_OBJ_NORMAL,
    .mosaic = 0,
    .bpp = ST_OAM_4BPP,
    .shape = SPRITE_SHAPE(64x64),
    .x = 0,
    .matrixNum = 0,
    .size = SPRITE_SIZE(64x64),
    .tileNum = 0,
    .priority = 1,
    .paletteNum = 0,
    .affineParam = 0,
};

static const union AnimCmd sAnim_PyramidBag[] =
{
    ANIMCMD_FRAME(0, 4),
    ANIMCMD_END,
};

static const union AnimCmd * const sAnims_PyramidBag[] =
{
    sAnim_PyramidBag,
};

static const union AffineAnimCmd sAffineAnim_PyramidBag_Still[] =
{
    AFFINEANIMCMD_FRAME(256, 256, 0, 0),
    AFFINEANIMCMD_END,
};

static const union AffineAnimCmd sAffineAnim_PyramidBag_Shake[] =
{
    AFFINEANIMCMD_FRAME(0, 0, 254, 2),
    AFFINEANIMCMD_FRAME(0, 0, 2, 4),
    AFFINEANIMCMD_FRAME(0, 0, 254, 4),
    AFFINEANIMCMD_FRAME(0, 0, 2, 2),
    AFFINEANIMCMD_END,
};

enum {
    ANIM_BAG_STILL,
    ANIM_BAG_SHAKE,
};

static const union AffineAnimCmd * const sAffineAnims_PyramidBag[] =
{
    [ANIM_BAG_STILL] = sAffineAnim_PyramidBag_Still,
    [ANIM_BAG_SHAKE] = sAffineAnim_PyramidBag_Shake,
};

static const struct CompressedSpriteSheet sSpriteSheet_PyramidBag = {gBattlePyramidBag_Gfx, 0x0800, TAG_PYRAMID_BAG};

static const struct SpriteTemplate sSpriteTemplate_PyramidBag =
{
    .tileTag = TAG_PYRAMID_BAG,
    .paletteTag = TAG_PYRAMID_BAG,
    .oam = &sOamData_PyramidBag,
    .anims = sAnims_PyramidBag,
    .images = NULL,
    .affineAnims = sAffineAnims_PyramidBag,
    .callback = SpriteCallbackDummy
};

void InitBattlePyramidBagCursorPosition(void)
{
    gPyramidBagMenuState.cursorPosition = 0;
    gPyramidBagMenuState.scrollPosition = 0;
}

void CB2_PyramidBagMenuFromStartMenu(void)
{
    GoToBattlePyramidBagMenu(PYRAMIDBAG_LOC_FIELD, CB2_ReturnToFieldWithOpenMenu);
}

// Unused, CB2_BagMenuFromBattle is used instead
static void OpenBattlePyramidBagInBattle(void)
{
    GoToBattlePyramidBagMenu(PYRAMIDBAG_LOC_BATTLE, CB2_SetUpReshowBattleScreenAfterMenu2);
}

// If the player finishes a round at the Battle Pyramid with insufficient space in their
// Pyramid Bag to store the party's held items, they may choose items to toss in order to
// make room.
void ChooseItemsToTossFromPyramidBag(void)
{
    ScriptContext2_Enable();
    FadeScreen(FADE_TO_BLACK, 0);
    CreateTask(Task_ChooseItemsToTossFromPyramidBag, 10);
}

static void Task_ChooseItemsToTossFromPyramidBag(u8 taskId)
{
    if (!gPaletteFade.active)
    {
        CleanupOverworldWindowsAndTilemaps();
        gFieldCallback2 = CB2_FadeFromPartyMenu;
        GoToBattlePyramidBagMenu(PYRAMIDBAG_LOC_CHOOSE_TOSS, CB2_ReturnToField);
        DestroyTask(taskId);
    }
}

void CB2_ReturnToPyramidBagMenu(void)
{
    GoToBattlePyramidBagMenu(PYRAMIDBAG_LOC_PREV, gPyramidBagMenuState.exitCallback);
}

void GoToBattlePyramidBagMenu(u8 location, void (*exitCallback)(void))
{
    gPyramidBagMenu = AllocZeroed(sizeof(*gPyramidBagMenu));

    if (location != PYRAMIDBAG_LOC_PREV)
        gPyramidBagMenuState.location = location;

    if (exitCallback != NULL)
        gPyramidBagMenuState.exitCallback = exitCallback;

    gPyramidBagMenu->newScreenCallback = NULL;
    gPyramidBagMenu->toSwapPos = POS_NONE;
    gPyramidBagMenu->scrollIndicatorsTaskId = TASK_NONE;

    memset(gPyramidBagMenu->spriteIds, SPRITE_NONE, sizeof(gPyramidBagMenu->spriteIds));
    memset(gPyramidBagMenu->windowIds, WINDOW_NONE, sizeof(gPyramidBagMenu->windowIds));

    SetMainCallback2(CB2_LoadPyramidBagMenu);
}

static void CB2_PyramidBag(void)
{
    RunTasks();
    AnimateSprites();
    BuildOamBuffer();
    DoScheduledBgTilemapCopiesToVram();
    UpdatePaletteFade();
}

static void VBlankCB_PyramidBag(void)
{
    LoadOam();
    ProcessSpriteCopyRequests();
    TransferPlttBuffer();
}

static void CB2_LoadPyramidBagMenu(void)
{
    while (MenuHelpers_ShouldWaitForLinkRecv() != TRUE
        && LoadPyramidBagMenu() != TRUE
        && MenuHelpers_IsLinkActive() != TRUE);
}

static bool8 LoadPyramidBagMenu(void)
{
    switch (gMain.state)
    {
        case 0:
            SetVBlankHBlankCallbacksToNull();
            ClearScheduledBgCopiesToVram();
            gMain.state++;
            break;
        case 1:
            ScanlineEffect_Stop();
            gMain.state++;
            break;
        case 2:
            FreeAllSpritePalettes();
            gMain.state++;
            break;
        case 3:
            ResetPaletteFade();
            gPaletteFade.bufferTransferDisabled = TRUE;
            gMain.state++;
            break;
        case 4:
            ResetSpriteData();
            gMain.state++;
            break;
        case 5:
            if (!MenuHelpers_IsLinkActive())
                ResetTasks();
            gMain.state++;
            break;
        case 6:
            InitPyramidBagBgs();
            gPyramidBagMenu->state = 0;
            gMain.state++;
            break;
        case 7:
            if (LoadPyramidBagGfx())
                gMain.state++;
            break;
        case 8:
            InitPyramidBagWindows();
            gMain.state++;
            break;
        case 9:
            UpdatePyramidBagList();
            UpdatePyramidBagCursorPos();
            InitPyramidBagScroll();
            gMain.state++;
            break;
        case 10:
            SetBagItemsListTemplate();
            gMain.state++;
            break;
        case 11:
            CreatePyramidBagInputTask();
            gMain.state++;
            break;
        case 12:
            CreatePyramidBagSprite();
            gMain.state++;
            break;
        case 13:
            AddScrollArrows();
            gMain.state++;
            break;
        case 14:
            CreateSwapLine();
            gMain.state++;
            break;
        case 15:
            BlendPalettes(PALETTES_ALL, 16, 0);
            gMain.state++;
            break;
        case 16:
            BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB_BLACK);
            gPaletteFade.bufferTransferDisabled = FALSE;
            gMain.state++;
            break;
        default:
            SetVBlankCallback(VBlankCB_PyramidBag);
            SetMainCallback2(CB2_PyramidBag);
            return TRUE;
    }
    return FALSE;
}

static void InitPyramidBagBgs(void)
{
    ResetVramOamAndBgCntRegs();
    ResetBgsAndClearDma3BusyFlags(0);
    InitBgsFromTemplates(0, sBgTemplates, ARRAY_COUNT(sBgTemplates));
    SetBgTilemapBuffer(2, gPyramidBagMenu->tilemapBuffer);
    ResetAllBgsCoordinates();
    ScheduleBgCopyTilemapToVram(2);
    SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 |
                                  DISPCNT_OBJ_1D_MAP |
                                  DISPCNT_OBJ_ON);
    ShowBg(0);
    ShowBg(1);
    ShowBg(2);
    SetGpuReg(REG_OFFSET_BLDCNT, 0);
}

static bool8 LoadPyramidBagGfx(void)
{
    switch (gPyramidBagMenu->state)
    {
    case 0:
        ResetTempTileDataBuffers();
        DecompressAndCopyTileDataToVram(2, gBagScreen_Gfx, 0, 0, 0);
        gPyramidBagMenu->state++;
        break;
    case 1:
        if (FreeTempTileDataBuffersIfPossible() != TRUE)
        {
            LZDecompressWram(gBattlePyramidBagTilemap, gPyramidBagMenu->tilemapBuffer);
            gPyramidBagMenu->state++;
        }
        break;
    case 2:
        LoadCompressedPalette(gBattlePyramidBagInterface_Pal, 0, 32);
        gPyramidBagMenu->state++;
        break;
    case 3:
        LoadCompressedSpriteSheet(&sSpriteSheet_PyramidBag);
        gPyramidBagMenu->state++;
        break;
    case 4:
        LoadPyramidBagPalette();
        gPyramidBagMenu->state++;
        break;
    default:
        LoadListMenuSwapLineGfx();
        gPyramidBagMenu->state = 0;
        return TRUE;
    }

    return FALSE;
}

static void SetBagItemsListTemplate(void)
{
    u16 i;
    u16 *itemIds = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode];

    for (i = 0; i < gPyramidBagMenu->listMenuCount - 1; i++)
    {
        CopyBagItemName(gPyramidBagMenu->itemStrings[i], itemIds[i]);
        gPyramidBagMenu->bagListItems[i].name = gPyramidBagMenu->itemStrings[i];
        gPyramidBagMenu->bagListItems[i].id = i;
    }
    StringCopy(gPyramidBagMenu->itemStrings[i], gText_CloseBag);
    gPyramidBagMenu->bagListItems[i].name = gPyramidBagMenu->itemStrings[i];
    gPyramidBagMenu->bagListItems[i].id = LIST_CANCEL;
    gMultiuseListMenuTemplate = sListMenuTemplate;
    gMultiuseListMenuTemplate.totalItems = gPyramidBagMenu->listMenuCount;
    gMultiuseListMenuTemplate.items = gPyramidBagMenu->bagListItems;
    gMultiuseListMenuTemplate.maxShowed = gPyramidBagMenu->listMenuMaxShown;
}

static void CopyBagItemName(u8 *dst, u16 itemId)
{
    if (ItemId_GetPocket(itemId) == POCKET_BERRIES)
    {
        ConvertIntToDecimalStringN(gStringVar1, ITEM_TO_BERRY(itemId), STR_CONV_MODE_LEADING_ZEROS, 2);
        CopyItemName(itemId, gStringVar2);
        StringExpandPlaceholders(dst, gText_NumberItem_TMBerry);
    }
    else
    {
        CopyItemName(itemId, dst);
    }
}

static void BagCursorMoved(s32 itemIndex, bool8 onInit, struct ListMenu *list)
{
    if (onInit != TRUE)
    {
        PlaySE(SE_SELECT);
        ShakePyramidBag();
    }
    if (gPyramidBagMenu->toSwapPos == POS_NONE)
    {
        FreeItemIconSpriteByAltId(gPyramidBagMenu->isAltIcon ^ 1);
        if (itemIndex != LIST_CANCEL)
            ShowItemIcon(gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode][itemIndex], gPyramidBagMenu->isAltIcon);
        else
            ShowItemIcon(0xFFFF, gPyramidBagMenu->isAltIcon); // Show exit arrow if on Cancel
        gPyramidBagMenu->isAltIcon ^= 1;
        PrintItemDescription(itemIndex);
    }
}

static void PrintItemQuantity(u8 windowId, u32 itemIndex, u8 y)
{
    s32 xAlign;
    if (itemIndex == LIST_CANCEL)
        return;

    if (gPyramidBagMenu->toSwapPos != POS_NONE)
    {
        // Performing a swap. Keep a gray selector arrow on the position to swap to
        // and erase the selector arrow anywhere else
        if (gPyramidBagMenu->toSwapPos == (u8)(itemIndex))
            PrintSelectorArrowAtPos(y, COLORID_LIGHT_GRAY);
        else
            PrintSelectorArrowAtPos(y, COLORID_NONE);
    }

    ConvertIntToDecimalStringN(gStringVar1,
                               gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode][itemIndex],
                               STR_CONV_MODE_RIGHT_ALIGN,
                               2);
    StringExpandPlaceholders(gStringVar4, gText_xVar1);
    xAlign = GetStringRightAlignXOffset(FONT_NARROW, gStringVar4, 119);
    PyramidBagPrint_Quantity(windowId, gStringVar4, xAlign, y, 0, 0, TEXT_SKIP_DRAW, COLORID_DARK_GRAY);
}

static void PrintItemDescription(s32 listMenuId)
{
    const u8 *desc;
    if (listMenuId != LIST_CANCEL)
    {
        desc = ItemId_GetDescription(gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode][listMenuId]);
    }
    else
    {
        StringCopy(gStringVar1, gPyramidBagMenu_ReturnToStrings[gPyramidBagMenuState.location]);
        StringExpandPlaceholders(gStringVar4, gText_ReturnToVar1);
        desc = gStringVar4;
    }
    FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
    PyramidBagPrint(WIN_INFO, desc, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
}

static void AddScrollArrows(void)
{
    if (gPyramidBagMenu->scrollIndicatorsTaskId == TASK_NONE)
        gPyramidBagMenu->scrollIndicatorsTaskId = AddScrollIndicatorArrowPairParameterized(SCROLL_ARROW_UP, 172, 12, 148,
                                                                                            gPyramidBagMenu->listMenuCount - gPyramidBagMenu->listMenuMaxShown,
                                                                                            TAG_SCROLL_ARROW, TAG_SCROLL_ARROW,
                                                                                            &gPyramidBagMenuState.scrollPosition);
}

static void RemoveScrollArrow(void)
{
    if (gPyramidBagMenu->scrollIndicatorsTaskId != TASK_NONE)
    {
        RemoveScrollIndicatorArrowPair(gPyramidBagMenu->scrollIndicatorsTaskId);
        gPyramidBagMenu->scrollIndicatorsTaskId = TASK_NONE;
    }
}

#define tListTaskId data[0]
#define tListPos    data[1]
#define tQuantity   data[2]
#define tNumToToss  data[8]

static void CreatePyramidBagInputTask(void)
{
    u8 taskId = CreateTask(Task_HandlePyramidBagInput, 0);
    s16 *data = gTasks[taskId].data;
    tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, gPyramidBagMenuState.scrollPosition, gPyramidBagMenuState.cursorPosition);
}

static void SwapItems(u8 id1, u8 id2)
{
    u16 temp;
    u16 *itemIds = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode];
    u8 *quantities = gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode];

    SWAP(itemIds[id1], itemIds[id2], temp);
    SWAP(quantities[id1], quantities[id2], temp);
}

static void MovePyramidBagItemSlotInList(u8 from, u8 to)
{
    u16 *itemIds = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode];
    u8 *quantities = gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode];

    if (from != to)
    {
        s16 i;
        u16 firstSlotItemId = itemIds[from];
        u8 firstSlotQuantity = quantities[from];

        if (to > from)
        {
            to--;
            for (i = from; i < to; i++)
            {
                itemIds[i] = itemIds[i + 1];
                quantities[i] = quantities[i + 1];
            }
        }
        else
        {
            for (i = from; i > to; i--)
            {
                itemIds[i] = itemIds[i - 1];
                quantities[i] = quantities[i - 1];
            }
        }
        itemIds[to] = firstSlotItemId;
        quantities[to] = firstSlotQuantity;
    }
}

static void CompactItems(void)
{
    u8 i, j;
    u16 *itemIds = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode];
    u8 *quantities = gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode];

    for (i = 0; i < PYRAMID_BAG_ITEMS_COUNT; i++)
    {
        if (itemIds[i] == ITEM_NONE || quantities[i] == 0)
        {
            itemIds[i] = ITEM_NONE;
            quantities[i] = 0;
        }
    }
    for (i = 0; i < PYRAMID_BAG_ITEMS_COUNT - 1; i++)
    {
        for (j = i + 1; j < PYRAMID_BAG_ITEMS_COUNT; j++)
        {
            if (itemIds[i] == ITEM_NONE || quantities[i] == 0)
                SwapItems(i, j);
        }
    }
}

void UpdatePyramidBagList(void)
{
    u16 i;
    u16 *itemIds = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode];

    CompactItems();
    gPyramidBagMenu->listMenuCount = 0;
    for (i = 0; i < PYRAMID_BAG_ITEMS_COUNT; i++)
    {
        if (itemIds[i] != ITEM_NONE)
            gPyramidBagMenu->listMenuCount++;
    }
    gPyramidBagMenu->listMenuCount++;
    if (gPyramidBagMenu->listMenuCount > 8)
        gPyramidBagMenu->listMenuMaxShown = 8;
    else
        gPyramidBagMenu->listMenuMaxShown = gPyramidBagMenu->listMenuCount;
}

void UpdatePyramidBagCursorPos(void)
{
    if (gPyramidBagMenuState.scrollPosition != 0 && gPyramidBagMenuState.scrollPosition + gPyramidBagMenu->listMenuMaxShown > gPyramidBagMenu->listMenuCount)
        gPyramidBagMenuState.scrollPosition = gPyramidBagMenu->listMenuCount - gPyramidBagMenu->listMenuMaxShown;

    if (gPyramidBagMenuState.scrollPosition + gPyramidBagMenuState.cursorPosition >= gPyramidBagMenu->listMenuCount)
    {
        if (gPyramidBagMenu->listMenuCount == 0)
            gPyramidBagMenuState.cursorPosition = 0;
        else
            gPyramidBagMenuState.cursorPosition = gPyramidBagMenu->listMenuCount - 1;
    }
}

static void InitPyramidBagScroll(void)
{
    u8 i;

    if (gPyramidBagMenuState.cursorPosition > 4)
    {
        for (i = 0; i <= gPyramidBagMenuState.cursorPosition - 4; i++)
        {
            if (gPyramidBagMenuState.scrollPosition + gPyramidBagMenu->listMenuMaxShown == gPyramidBagMenu->listMenuCount)
                break;

            gPyramidBagMenuState.cursorPosition--;
            gPyramidBagMenuState.scrollPosition++;
        }
    }
}

static void PrintSelectorArrow(u8 listMenuTaskId, u8 colorId)
{
    u8 y = ListMenuGetYCoordForPrintingArrowCursor(listMenuTaskId);
    PrintSelectorArrowAtPos(y, colorId);
}

static void PrintSelectorArrowAtPos(u8 y, u8 colorId)
{
    if (colorId == COLORID_NONE) // If 'no color', erase arrow
        FillWindowPixelRect(WIN_LIST, PIXEL_FILL(0), 0, y, GetMenuCursorDimensionByFont(FONT_NORMAL, 0), GetMenuCursorDimensionByFont(FONT_NORMAL, 1));
    else
        PyramidBagPrint(WIN_LIST, gText_SelectorArrow2, 0, y, 0, 0, 0, colorId);
}

void CloseBattlePyramidBag(u8 taskId)
{
    BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB_BLACK);
    gTasks[taskId].func = Task_ClosePyramidBag;
}

static void Task_ClosePyramidBag(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    if (!gPaletteFade.active)
    {
        DestroyListMenuTask(tListTaskId, &gPyramidBagMenuState.scrollPosition, &gPyramidBagMenuState.cursorPosition);

        // If ready for a new screen (e.g. party menu for giving an item) go to that screen
        // Otherwise exit the bag and use callback set up when the bag was first opened
        if (gPyramidBagMenu->newScreenCallback != NULL)
            SetMainCallback2(gPyramidBagMenu->newScreenCallback);
        else
            SetMainCallback2(gPyramidBagMenuState.exitCallback);
        RemoveScrollArrow();
        ResetSpriteData();
        FreeAllSpritePalettes();
        FreeAllWindowBuffers();
        Free(gPyramidBagMenu);
        DestroyTask(taskId);
    }
}

static void Task_HandlePyramidBagInput(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    if (MenuHelpers_ShouldWaitForLinkRecv() == TRUE || gPaletteFade.active)
        return;

    if (JOY_NEW(SELECT_BUTTON))
    {
        if (gPyramidBagMenuState.location != PYRAMIDBAG_LOC_PARTY)
        {
            ListMenuGetScrollAndRow(tListTaskId, &gPyramidBagMenuState.scrollPosition, &gPyramidBagMenuState.cursorPosition);
            if (gPyramidBagMenuState.scrollPosition + gPyramidBagMenuState.cursorPosition != gPyramidBagMenu->listMenuCount - 1)
            {
                PlaySE(SE_SELECT);
                Task_BeginItemSwap(taskId);
            }
        }
    }
    else
    {
        s32 listId = ListMenu_ProcessInput(tListTaskId);
        ListMenuGetScrollAndRow(tListTaskId, &gPyramidBagMenuState.scrollPosition, &gPyramidBagMenuState.cursorPosition);
        switch (listId)
        {
        case LIST_NOTHING_CHOSEN:
            break;
        case LIST_CANCEL:
            PlaySE(SE_SELECT);
            gSpecialVar_ItemId = ITEM_NONE;
            CloseBattlePyramidBag(taskId);
            break;
        default:
            PlaySE(SE_SELECT);
            gSpecialVar_ItemId = gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode][listId];
            tListPos = listId;
            tQuantity = gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode][listId];
            if (gPyramidBagMenuState.location == PYRAMIDBAG_LOC_PARTY)
                TryCloseBagToGiveItem(taskId);
            else
                OpenContextMenu(taskId);
            break;
        }
    }
}

static void OpenContextMenu(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    RemoveScrollArrow();
    PrintSelectorArrow(tListTaskId, COLORID_LIGHT_GRAY);
    switch (gPyramidBagMenuState.location)
    {
    default:
//  case PYRAMIDBAG_LOC_FIELD:
//  case PYRAMIDBAG_LOC_PARTY:
        gPyramidBagMenu->menuActionIds = sMenuActionIds_Field;
        gPyramidBagMenu->menuActionsCount = ARRAY_COUNT(sMenuActionIds_Field);
        break;
    case PYRAMIDBAG_LOC_BATTLE:
        if (ItemId_GetBattleUsage(gSpecialVar_ItemId))
        {
            gPyramidBagMenu->menuActionIds = sMenuActionIds_Battle;
            gPyramidBagMenu->menuActionsCount = ARRAY_COUNT(sMenuActionIds_Battle);
        }
        else
        {
            gPyramidBagMenu->menuActionIds = sMenuActionIds_BattleCannotUse;
            gPyramidBagMenu->menuActionsCount = ARRAY_COUNT(sMenuActionIds_BattleCannotUse);
        }
        break;
    case PYRAMIDBAG_LOC_CHOOSE_TOSS:
        gPyramidBagMenu->menuActionIds = sMenuActionIds_ChooseToss;
        gPyramidBagMenu->menuActionsCount = ARRAY_COUNT(sMenuActionIds_ChooseToss);
        break;
    }

    CopyItemName(gSpecialVar_ItemId, gStringVar1);
    StringExpandPlaceholders(gStringVar4, gText_Var1IsSelected);
    FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
    PyramidBagPrint(WIN_INFO, gStringVar4, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
    if (gPyramidBagMenu->menuActionsCount == 1)
        PrintMenuActionText_SingleRow(OpenMenuActionWindowById(MENU_WIN_1x1));
    else if (gPyramidBagMenu->menuActionsCount == 2)
        PrintMenuActionText_SingleRow(OpenMenuActionWindowById(MENU_WIN_1x2));
    else
        PrintMenuActionText_MultiRow(OpenMenuActionWindowById(MENU_WIN_2x2), 2, 2);

    if (gPyramidBagMenu->menuActionsCount == 2 * 2) // Assumes any non 2x2 menu is single-row
        gTasks[taskId].func = HandleMenuActionInput_2x2;
    else
        gTasks[taskId].func = HandleMenuActionInput_SingleRow;
}

static void PrintMenuActionText_SingleRow(u8 windowId)
{
    PrintMenuActionTexts(windowId, FONT_NARROW, 8, 1, 0, 0x10, gPyramidBagMenu->menuActionsCount, sMenuActions, gPyramidBagMenu->menuActionIds);
    InitMenuInUpperLeftCornerNormal(windowId, gPyramidBagMenu->menuActionsCount, 0);
}

static void PrintMenuActionText_MultiRow(u8 windowId, u8 horizontalCount, u8 verticalCount)
{
    PrintMenuActionGrid(windowId, FONT_NARROW, 8, 1, 56, horizontalCount, verticalCount, sMenuActions, gPyramidBagMenu->menuActionIds);
    InitMenuActionGrid(windowId, 56, horizontalCount, verticalCount, 0);
}

static void HandleMenuActionInput_SingleRow(u8 taskId)
{
    if (MenuHelpers_ShouldWaitForLinkRecv() != TRUE)
    {
        s32 id = Menu_ProcessInputNoWrap();
        switch (id)
        {
        case MENU_NOTHING_CHOSEN:
            break;
        case MENU_B_PRESSED:
            PlaySE(SE_SELECT);
            sMenuActions[ACTION_CANCEL].func.void_u8(taskId);
            break;
        default:
            PlaySE(SE_SELECT);
            if (sMenuActions[gPyramidBagMenu->menuActionIds[id]].func.void_u8 != NULL)
                sMenuActions[gPyramidBagMenu->menuActionIds[id]].func.void_u8(taskId);
            break;
        }
    }
}

static void HandleMenuActionInput_2x2(u8 taskId)
{
    if (MenuHelpers_ShouldWaitForLinkRecv() != TRUE)
    {
        s8 id = Menu_GetCursorPos();
        if (JOY_NEW(DPAD_UP))
        {
            if (id > 0 && IsValidMenuAction(id - 2))
            {
                PlaySE(SE_SELECT);
                ChangeMenuGridCursorPosition(MENU_CURSOR_DELTA_NONE, MENU_CURSOR_DELTA_UP);
            }
        }
        else if (JOY_NEW(DPAD_DOWN))
        {
            if (id < gPyramidBagMenu->menuActionsCount - 2 && IsValidMenuAction(id + 2))
            {
                PlaySE(SE_SELECT);
                ChangeMenuGridCursorPosition(MENU_CURSOR_DELTA_NONE, MENU_CURSOR_DELTA_DOWN);
            }
        }
        else if (JOY_NEW(DPAD_LEFT) || GetLRKeysPressed() == MENU_L_PRESSED)
        {
            if (id & 1 && IsValidMenuAction(id - 1))
            {
                PlaySE(SE_SELECT);
                ChangeMenuGridCursorPosition(MENU_CURSOR_DELTA_LEFT, MENU_CURSOR_DELTA_NONE);
            }
        }
        else if (JOY_NEW(DPAD_RIGHT) || GetLRKeysPressed() == MENU_R_PRESSED)
        {
            if (!(id & 1) && IsValidMenuAction(id + 1))
            {
                PlaySE(SE_SELECT);
                ChangeMenuGridCursorPosition(MENU_CURSOR_DELTA_RIGHT, MENU_CURSOR_DELTA_NONE);
            }
        }
        else if (JOY_NEW(A_BUTTON))
        {
            PlaySE(SE_SELECT);
            if (sMenuActions[gPyramidBagMenu->menuActionIds[id]].func.void_u8 != NULL)
                sMenuActions[gPyramidBagMenu->menuActionIds[id]].func.void_u8(taskId);
        }
        else if (JOY_NEW(B_BUTTON))
        {
            PlaySE(SE_SELECT);
            sMenuActions[ACTION_CANCEL].func.void_u8(taskId);
        }
    }
}

static bool8 IsValidMenuAction(s8 actionTableId)
{
    if (actionTableId < 0)
        return FALSE;
    else if (actionTableId > gPyramidBagMenu->menuActionsCount)
        return FALSE;
    else if (gPyramidBagMenu->menuActionIds[actionTableId] == ACTION_DUMMY)
        return FALSE;
    else
        return TRUE;
}

static void CloseMenuActionWindow(void)
{
    if (gPyramidBagMenu->menuActionsCount == 1)
        CloseMenuActionWindowById(MENU_WIN_1x1);
    else if (gPyramidBagMenu->menuActionsCount == 2)
        CloseMenuActionWindowById(MENU_WIN_1x2);
    else
        CloseMenuActionWindowById(MENU_WIN_2x2);
}

static void BagAction_UseOnField(u8 taskId)
{
    u8 pocketId = ItemId_GetPocket(gSpecialVar_ItemId);

    if (pocketId == POCKET_KEY_ITEMS
        || pocketId == POCKET_POKE_BALLS
        || pocketId == POCKET_TM_HM
        || ItemIsMail(gSpecialVar_ItemId) == TRUE)
    {
        CloseMenuActionWindow();
        DisplayItemMessageInBattlePyramid(taskId, gText_DadsAdvice, Task_CloseBattlePyramidBagMessage);
    }
    else if (ItemId_GetFieldFunc(gSpecialVar_ItemId) != NULL)
    {
        CloseMenuActionWindow();
        FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
        ScheduleBgCopyTilemapToVram(0);
        ItemId_GetFieldFunc(gSpecialVar_ItemId)(taskId);
    }
}

static void BagAction_Cancel(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    CloseMenuActionWindow();
    PrintItemDescription(tListPos);
    ScheduleBgCopyTilemapToVram(0);
    ScheduleBgCopyTilemapToVram(1);
    PrintSelectorArrow(tListTaskId, COLORID_DARK_GRAY);
    SetTaskToMainPyramidBagInputHandler(taskId);
}

static void SetTaskToMainPyramidBagInputHandler(u8 taskId)
{
    AddScrollArrows();
    gTasks[taskId].func = Task_HandlePyramidBagInput;
}

static void BagAction_Toss(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    CloseMenuActionWindow();
    tNumToToss = 1;
    if (tQuantity == 1)
    {
        AskConfirmToss(taskId);
    }
    else
    {
        CopyItemName(gSpecialVar_ItemId, gStringVar1);
        StringExpandPlaceholders(gStringVar4, gText_TossHowManyVar1s);
        FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
        PyramidBagPrint(WIN_INFO, gStringVar4, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
        ShowNumToToss();
        gTasks[taskId].func = Task_ChooseHowManyToToss;
    }
}

static void AskConfirmToss(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    CopyItemName(gSpecialVar_ItemId, gStringVar1);
    ConvertIntToDecimalStringN(gStringVar2, tNumToToss, STR_CONV_MODE_LEFT_ALIGN, 2);
    StringExpandPlaceholders(gStringVar4, gText_ConfirmTossItems);
    FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
    PyramidBagPrint(WIN_INFO, gStringVar4, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
    CreatePyramidBagYesNo(taskId, &sYesNoTossFuncions);
}

static void DontTossItem(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    PrintItemDescription(tListPos);
    PrintSelectorArrow(tListTaskId, COLORID_DARK_GRAY);
    SetTaskToMainPyramidBagInputHandler(taskId);
}

static void ShowNumToToss(void)
{
    s32 x;
    ConvertIntToDecimalStringN(gStringVar1, 1, STR_CONV_MODE_LEADING_ZEROS, 2);
    StringExpandPlaceholders(gStringVar4, gText_xVar1);
    DrawTossNumberWindow(WIN_TOSS_NUM);
    x = GetStringCenterAlignXOffset(FONT_NORMAL, gStringVar4, 0x28);
    AddTextPrinterParameterized(WIN_TOSS_NUM, FONT_NORMAL, gStringVar4, x, 2, 0, NULL);
}

static void UpdateNumToToss(s16 num)
{
    s32 x;
    ConvertIntToDecimalStringN(gStringVar1, num, STR_CONV_MODE_LEADING_ZEROS, 2);
    StringExpandPlaceholders(gStringVar4, gText_xVar1);
    x = GetStringCenterAlignXOffset(FONT_NORMAL, gStringVar4, 0x28);
    AddTextPrinterParameterized(WIN_TOSS_NUM, FONT_NORMAL, gStringVar4, x, 2, 0, NULL);
}

static void Task_ChooseHowManyToToss(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    if (AdjustQuantityAccordingToDPadInput(&tNumToToss, tQuantity) == TRUE)
    {
        UpdateNumToToss(tNumToToss);
    }
    else if (JOY_NEW(A_BUTTON))
    {
        // Toss
        PlaySE(SE_SELECT);
        ClearStdWindowAndFrameToTransparent(WIN_TOSS_NUM, FALSE);
        ClearWindowTilemap(WIN_TOSS_NUM);
        ScheduleBgCopyTilemapToVram(1);
        AskConfirmToss(taskId);
    }
    else if (JOY_NEW(B_BUTTON))
    {
        // Cancel tossing
        PlaySE(SE_SELECT);
        ClearStdWindowAndFrameToTransparent(WIN_TOSS_NUM, FALSE);
        ClearWindowTilemap(WIN_TOSS_NUM);
        ScheduleBgCopyTilemapToVram(1);
        DontTossItem(taskId);
    }
}

static void TossItem(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    CopyItemName(gSpecialVar_ItemId, gStringVar1);
    ConvertIntToDecimalStringN(gStringVar2, tNumToToss, STR_CONV_MODE_LEFT_ALIGN, 2);
    StringExpandPlaceholders(gStringVar4, gText_ThrewAwayVar2Var1s);
    FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
    PyramidBagPrint(WIN_INFO, gStringVar4, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
    gTasks[taskId].func = Task_TossItem;
}

static void Task_TossItem(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    u16 *scrollOffset = &gPyramidBagMenuState.scrollPosition;
    u16 *selectedRow = &gPyramidBagMenuState.cursorPosition;

    if (JOY_NEW(A_BUTTON | B_BUTTON))
    {
        PlaySE(SE_SELECT);
        RemovePyramidBagItem(gSpecialVar_ItemId, tNumToToss);
        DestroyListMenuTask(tListTaskId, scrollOffset, selectedRow);
        UpdatePyramidBagList();
        UpdatePyramidBagCursorPos();
        SetBagItemsListTemplate();
        tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, *scrollOffset, *selectedRow);
        ScheduleBgCopyTilemapToVram(0);
        SetTaskToMainPyramidBagInputHandler(taskId);
    }
}

static void BagAction_Give(u8 taskId)
{
    CloseMenuActionWindow();
    if (ItemIsMail(gSpecialVar_ItemId) == TRUE)
    {
        DisplayItemMessageInBattlePyramid(taskId, gText_CantWriteMail, Task_WaitCloseErrorMessage);
    }
    else if (!ItemId_GetImportance(gSpecialVar_ItemId))
    {
        gPyramidBagMenu->newScreenCallback = CB2_ChooseMonToGiveItem;
        CloseBattlePyramidBag(taskId);
    }
    else
    {
        ShowCantHoldMessage(taskId);
    }
}

static void ShowCantHoldMessage(u8 taskId)
{
    CopyItemName(gSpecialVar_ItemId, gStringVar1);
    StringExpandPlaceholders(gStringVar4, gText_Var1CantBeHeld);
    DisplayItemMessageInBattlePyramid(taskId, gStringVar4, Task_WaitCloseErrorMessage);
}

static void Task_WaitCloseErrorMessage(u8 taskId)
{
    if (JOY_NEW(A_BUTTON))
    {
        PlaySE(SE_SELECT);
        Task_CloseBattlePyramidBagMessage(taskId);
    }
}

void Task_CloseBattlePyramidBagMessage(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    CloseBattlePyramidBagTextWindow();
    PrintItemDescription(tListPos);
    PrintSelectorArrow(tListTaskId, COLORID_DARK_GRAY);
    SetTaskToMainPyramidBagInputHandler(taskId);
}

static void TryCloseBagToGiveItem(u8 taskId)
{
    if (!IsWritingMailAllowed(gSpecialVar_ItemId))
        DisplayItemMessageInBattlePyramid(taskId, gText_CantWriteMail, Task_WaitCloseErrorMessage);
    else if (!ItemId_GetImportance(gSpecialVar_ItemId))
        CloseBattlePyramidBag(taskId);
    else
        ShowCantHoldMessage(taskId);
}

static void BagAction_UseInBattle(u8 taskId)
{
    if (ItemId_GetBattleFunc(gSpecialVar_ItemId) != NULL)
    {
        CloseMenuActionWindow();
        ItemId_GetBattleFunc(gSpecialVar_ItemId)(taskId);
    }
}

static void Task_BeginItemSwap(u8 taskId)
{
    s16 *data = gTasks[taskId].data;

    tListPos = gPyramidBagMenuState.scrollPosition + gPyramidBagMenuState.cursorPosition;
    gPyramidBagMenu->toSwapPos = tListPos;
    ListMenuSetUnkIndicatorsStructField(tListTaskId, 0x10, 1);
    CopyItemName(gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode][tListPos], gStringVar1);
    StringExpandPlaceholders(gStringVar4, gText_MoveVar1Where);
    FillWindowPixelBuffer(WIN_INFO, PIXEL_FILL(0));
    PyramidBagPrint(WIN_INFO, gStringVar4, 3, 0, 0, 1, 0, COLORID_DARK_GRAY);
    PrintSelectorArrow(tListTaskId, COLORID_LIGHT_GRAY);
    UpdateSwapLinePos(tListPos);
    gTasks[taskId].func = Task_ItemSwapHandleInput;
}

static void Task_ItemSwapHandleInput(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    if (MenuHelpers_ShouldWaitForLinkRecv() != TRUE)
    {
        if (JOY_NEW(SELECT_BUTTON))
        {
            PlaySE(SE_SELECT);
            ListMenuGetScrollAndRow(tListTaskId, &gPyramidBagMenuState.scrollPosition, &gPyramidBagMenuState.cursorPosition);
            PerformItemSwap(taskId);
        }
        else
        {
            s32 id = ListMenu_ProcessInput(tListTaskId);
            ListMenuGetScrollAndRow(tListTaskId, &gPyramidBagMenuState.scrollPosition, &gPyramidBagMenuState.cursorPosition);
            SetSwapLineInvisibility(FALSE);
            UpdateSwapLinePos(gPyramidBagMenuState.cursorPosition);
            switch (id)
            {
            case LIST_NOTHING_CHOSEN:
                break;
            case LIST_CANCEL:
                PlaySE(SE_SELECT);
                if (JOY_NEW(A_BUTTON))
                    PerformItemSwap(taskId);
                else
                    CancelItemSwap(taskId);
                break;
            default:
                PlaySE(SE_SELECT);
                PerformItemSwap(taskId);
                break;
            }
        }
    }
}

static void PerformItemSwap(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    u16 *scrollOffset = &gPyramidBagMenuState.scrollPosition;
    u16 *selectedRow = &gPyramidBagMenuState.cursorPosition;
    u16 swapPos = *scrollOffset + *selectedRow;

    if (tListPos == swapPos || tListPos == swapPos - 1)
    {
        CancelItemSwap(taskId);
    }
    else
    {
        MovePyramidBagItemSlotInList(tListPos, swapPos);
        gPyramidBagMenu->toSwapPos = POS_NONE;
        SetSwapLineInvisibility(TRUE);
        DestroyListMenuTask(tListTaskId, scrollOffset, selectedRow);
        if (tListPos < swapPos)
            gPyramidBagMenuState.cursorPosition--;
        SetBagItemsListTemplate();
        tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, *scrollOffset, *selectedRow);
        SetTaskToMainPyramidBagInputHandler(taskId);
    }
}

static void CancelItemSwap(u8 taskId)
{
    s16 *data = gTasks[taskId].data;
    u16 *scrollOffset = &gPyramidBagMenuState.scrollPosition;
    u16 *selectedRow = &gPyramidBagMenuState.cursorPosition;

    gPyramidBagMenu->toSwapPos = POS_NONE;
    SetSwapLineInvisibility(TRUE);
    DestroyListMenuTask(tListTaskId, scrollOffset, selectedRow);
    if (tListPos < *scrollOffset + *selectedRow)
        gPyramidBagMenuState.cursorPosition--;
    SetBagItemsListTemplate();
    tListTaskId = ListMenuInit(&gMultiuseListMenuTemplate, *scrollOffset, *selectedRow);
    SetTaskToMainPyramidBagInputHandler(taskId);
}

void TryStoreHeldItemsInPyramidBag(void)
{
    u8 i;
    struct Pokemon *party = gPlayerParty;
    u16 *newItems = Alloc(PYRAMID_BAG_ITEMS_COUNT * sizeof(u16));
    u8 *newQuantities = Alloc(PYRAMID_BAG_ITEMS_COUNT * sizeof(u8));
    u16 heldItem;

    memcpy(newItems, gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode], PYRAMID_BAG_ITEMS_COUNT * sizeof(u16));
    memcpy(newQuantities, gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode], PYRAMID_BAG_ITEMS_COUNT * sizeof(u8));
    for (i = 0; i < FRONTIER_PARTY_SIZE; i++)
    {
        heldItem = GetMonData(&party[i], MON_DATA_HELD_ITEM);
        if (heldItem != ITEM_NONE && !AddBagItem(heldItem, 1))
        {
            // Cant store party held items in pyramid bag because bag is full
            memcpy(gSaveBlock2Ptr->frontier.pyramidBag.itemId[gSaveBlock2Ptr->frontier.lvlMode], newItems, PYRAMID_BAG_ITEMS_COUNT * sizeof(u16));
            memcpy(gSaveBlock2Ptr->frontier.pyramidBag.quantity[gSaveBlock2Ptr->frontier.lvlMode], newQuantities, PYRAMID_BAG_ITEMS_COUNT * sizeof(u8));
            Free(newItems);
            Free(newQuantities);
            gSpecialVar_Result = 1;
            return;
        }
    }

    heldItem = ITEM_NONE;
    for (i = 0; i < FRONTIER_PARTY_SIZE; i++)
        SetMonData(&party[i], MON_DATA_HELD_ITEM, &heldItem);
    gSpecialVar_Result = 0;
    Free(newItems);
    Free(newQuantities);
}

static void InitPyramidBagWindows(void)
{
    u8 i;

    InitWindows(sWindowTemplates);
    DeactivateAllTextPrinters();
    LoadUserWindowBorderGfx(0, 0x1, 0xE0);
    LoadMessageBoxGfx(0, 0xA, 0xD0);
    LoadPalette(gStandardMenuPalette, 0xF0, 0x20);

    for (i = 0; i < ARRAY_COUNT(sWindowTemplates); i++)
        FillWindowPixelBuffer(i, PIXEL_FILL(0));

    PutWindowTilemap(WIN_LIST);
    PutWindowTilemap(WIN_INFO);
    ScheduleBgCopyTilemapToVram(0);
    ScheduleBgCopyTilemapToVram(1);
}

static void PyramidBagPrint(u8 windowId, const u8 *src, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 speed, u8 colorTableId)
{
    AddTextPrinterParameterized4(windowId, FONT_NORMAL, x, y, letterSpacing, lineSpacing, sTextColors[colorTableId], speed, src);
}

static void PyramidBagPrint_Quantity(u8 windowId, const u8 *src, u8 x, u8 y, u8 letterSpacing, u8 lineSpacing, u8 speed, u8 colorTableId)
{
    AddTextPrinterParameterized4(windowId, FONT_NARROW, x, y, letterSpacing, lineSpacing, sTextColors[colorTableId], speed, src);
}

static void DrawTossNumberWindow(u8 windowId)
{
    DrawStdFrameWithCustomTileAndPalette(windowId, FALSE, 1, 0xE);
    ScheduleBgCopyTilemapToVram(1);
}

// Unused
static u8 GetMenuActionWindowId(u8 windowArrayId)
{
    return gPyramidBagMenu->windowIds[windowArrayId];
}

static u8 OpenMenuActionWindowById(u8 windowArrayId)
{
    u8 *windowId = &gPyramidBagMenu->windowIds[windowArrayId];
    if (*windowId == WINDOW_NONE)
    {
        *windowId = AddWindow(&sWindowTemplates_MenuActions[windowArrayId]);
        DrawStdFrameWithCustomTileAndPalette(*windowId, FALSE, 1, 0xE);
        ScheduleBgCopyTilemapToVram(1);
    }
    return *windowId;
}

static void CloseMenuActionWindowById(u8 windowArrayId)
{
    u8 *windowId = &gPyramidBagMenu->windowIds[windowArrayId];
    if (*windowId != WINDOW_NONE)
    {
        ClearStdWindowAndFrameToTransparent(*windowId, FALSE);
        ClearWindowTilemap(*windowId);
        RemoveWindow(*windowId);
        ScheduleBgCopyTilemapToVram(1);
        *windowId = WINDOW_NONE;
    }
}

static void CreatePyramidBagYesNo(u8 taskId, const struct YesNoFuncTable *yesNoTable)
{
    CreateYesNoMenuWithCallbacks(taskId, &sWindowTemplates_MenuActions[MENU_WIN_YESNO], 1, 0, 2, 1, 0xE, yesNoTable);
}

void DisplayItemMessageInBattlePyramid(u8 taskId, const u8 *str, void (*callback)(u8 taskId))
{
    FillWindowPixelBuffer(WIN_MSG, PIXEL_FILL(1));
    DisplayMessageAndContinueTask(taskId, WIN_MSG, 0xA, 0xD, FONT_NORMAL, GetPlayerTextSpeedDelay(), str, callback);
    ScheduleBgCopyTilemapToVram(1);
}

static void CloseBattlePyramidBagTextWindow(void)
{
    ClearDialogWindowAndFrameToTransparent(WIN_MSG, FALSE);
    // This ClearWindowTilemap call is redundant, since ClearDialogWindowAndFrameToTransparent already calls it.
    ClearWindowTilemap(WIN_MSG);
    ScheduleBgCopyTilemapToVram(1);
}

static void FreeItemIconSprite(u8 spriteArrId)
{
    u8 *spriteId = &gPyramidBagMenu->spriteIds[spriteArrId];
    if (*spriteId != SPRITE_NONE)
    {
        // spriteArrId is PBAG_SPRITE_ITEM_ICON / PBAG_SPRITE_ITEM_ICON_ALT here (1-2)
        // so tag will be TAG_ITEM_ICON / TAG_ITEM_ICON_ALT
        FreeSpriteTilesByTag(TAG_ITEM_ICON - 1 + spriteArrId);
        FreeSpritePaletteByTag(TAG_ITEM_ICON - 1 + spriteArrId);
        FreeSpriteOamMatrix(&gSprites[*spriteId]);
        DestroySprite(&gSprites[*spriteId]);
        *spriteId = SPRITE_NONE;
    }
}

static void LoadPyramidBagPalette(void)
{
    struct SpritePalette spritePalette;
    u16 *palPtr = Alloc(0x40);

    LZDecompressWram(gBattlePyramidBag_Pal, palPtr);
    spritePalette.data = palPtr + (gSaveBlock2Ptr->frontier.lvlMode * 16);
    spritePalette.tag = TAG_PYRAMID_BAG;
    LoadSpritePalette(&spritePalette);
    Free(palPtr);
}

static void CreatePyramidBagSprite(void)
{
    u8 *spriteId = &gPyramidBagMenu->spriteIds[PBAG_SPRITE_BAG];
    *spriteId = CreateSprite(&sSpriteTemplate_PyramidBag, 68, 56, 0);
}

static void ShakePyramidBag(void)
{
    struct Sprite *sprite = &gSprites[gPyramidBagMenu->spriteIds[PBAG_SPRITE_BAG]];
    if (sprite->affineAnimEnded)
    {
        StartSpriteAffineAnim(sprite, ANIM_BAG_SHAKE);
        sprite->callback = SpriteCB_BagWaitForShake;
    }
}

static void SpriteCB_BagWaitForShake(struct Sprite *sprite)
{
    if (sprite->affineAnimEnded)
    {
        StartSpriteAffineAnim(sprite, ANIM_BAG_STILL);
        sprite->callback = SpriteCallbackDummy;
    }
}

static void ShowItemIcon(u16 itemId, bool8 isAlt)
{
    u8 itemSpriteId;
    u8 *spriteId = &gPyramidBagMenu->spriteIds[isAlt + PBAG_SPRITE_ITEM_ICON];
    if (*spriteId == SPRITE_NONE)
    {
        FreeSpriteTilesByTag(TAG_ITEM_ICON + isAlt);
        FreeSpritePaletteByTag(TAG_ITEM_ICON + isAlt);
        itemSpriteId = AddItemIconSprite(TAG_ITEM_ICON + isAlt, TAG_ITEM_ICON + isAlt, itemId);
        if (itemSpriteId != MAX_SPRITES)
        {
            *spriteId = itemSpriteId;
            gSprites[itemSpriteId].x2 = 24;
            gSprites[itemSpriteId].y2 = 88;
        }
    }
}

static void FreeItemIconSpriteByAltId(bool8 isAlt)
{
    FreeItemIconSprite(isAlt + PBAG_SPRITE_ITEM_ICON);
}

static void CreateSwapLine(void)
{
    CreateSwapLineSprites(&gPyramidBagMenu->spriteIds[PBAG_SPRITE_SWAP_LINE_START], NUM_SWAP_LINE_SPRITES);
}

static void SetSwapLineInvisibility(bool8 invisible)
{
    SetSwapLineSpritesInvisibility(&gPyramidBagMenu->spriteIds[PBAG_SPRITE_SWAP_LINE_START], NUM_SWAP_LINE_SPRITES, invisible);
}

static void UpdateSwapLinePos(u8 y)
{
    UpdateSwapLineSpritesPos(&gPyramidBagMenu->spriteIds[PBAG_SPRITE_SWAP_LINE_START], NUM_SWAP_LINE_SPRITES | SWAP_LINE_HAS_MARGIN, 120, (y + 1) * 16);
}