shop.c

Go to the documentation of this file.

 
#include "game/shop.h"
 
#include "audio_utils.h"
#include "background_shop_gfx.h"
#include "bitset.h"
#include "button.h"
#include "game.h"
#include "game/blind_select.h"
#include "game/joker_row.h"
#include "game_variables.h"
#include "joker.h"
#include "layout.h"
#include "list.h"
#include "mgba_logger.h"
#include "random.h"
#include "save.h"
#include "skip_tag.h"
#include "soundbank.h"
#include "state_machine.h"
#include "timer.h"
#include "util.h"
 
#include <string.h>
 
// Timer defs
#define TM_END_GAME_SHOP_INTRO    12
#define TM_CREATE_SHOP_ITEMS_WAIT 1
#define TM_SHIFT_SHOP_ICON_WAIT   7
#define TM_SHOW_ITEM_DESC_WAIT    12
#define TM_HIDE_DECK_WAIT         5
 
// Pixel sized
#define ITEM_SHOP_Y               71
#define OWNED_ITEMS_HIDE_Y_OFFSET 50
 
// Shop
#define REROLL_BASE_COST     5 // Base cost for rerolling the shop items
#define NEXT_ROUND_BTN_SEL_X 0
 
// Palette IDs
#define REROLL_BTN_PAL_IDX                     3
#define NEXT_ROUND_BTN_SELECTED_BORDER_PAL_IDX 5
#define SHOP_PANEL_SHADOW_PAL_IDX              6
#define REROLL_BTN_SELECTED_BORDER_PAL_IDX     7
#define SHOP_LIGHTS_1_PAL_IDX                  8
#define SHOP_LIGHTS_2_PAL_IDX                  14
#define NEXT_ROUND_BTN_PAL_IDX                 16
#define SHOP_LIGHTS_3_PAL_IDX                  17
#define SHOP_LIGHTS_4_PAL_IDX                  22
#define SHOP_BOTTOM_PANEL_BORDER_PAL_IDX       26
#define SHOP_DESC_RARITY_MAIN_COLOR_PAL_IDX    27
#define SHOP_DESC_RARITY_SHADOW_COLOR_PAL_IDX  28
 
#define SHOP_LIGHTS_1_CLR 0xFFFF
#define SHOP_LIGHTS_2_CLR 0x32BE
#define SHOP_LIGHTS_3_CLR 0x4B5F
#define SHOP_LIGHTS_4_CLR 0x5F9F
 
// clang-format off
// Positions in tiles
static const Rect     SHOP_ICON_FROM_RECT           = {  0, 26,  8, 26};
static const BG_POINT SHOP_ICON_TO_POS              = {  0,  0};
static const BG_POINT OWNED_ITEMS_PANEL_3X3_SRC_POS = { 29, 21};
static const Rect     OWNED_JOKERS_PANEL_RECT       = {  9,  1, 21,  5};
static const Rect     OWNED_CONSUMABLES_PANEL_RECT  = { 23,  1, 28,  5};
static const Rect     OWNED_ITEMS_PANEL_RECT        = {  9,  1, 28,  5};
static const Rect     OWNED_ITEMS_PANEL_ANIM_CLEAR  = {  9,  0, 28,  1};
static const Rect     ITEM_DESC_9_PTCH_TO_RECT      = {  9,  6, 28, 18};
static const NinePatchRect ITEM_DESC_9_PTCH_SRC = {
                                        .patch_rect = { 27, 25, 31, 31},
                                        .margins    = {  2,  3,  2,  3}
};
static const int      ITEM_DESC_MAX_TEXT_HEIGHT     = ITEM_DESC_9_PTCH_TO_RECT.bottom -
                                                      ITEM_DESC_9_PTCH_TO_RECT.top + 1 -
                                                      ITEM_DESC_9_PTCH_SRC.margins.top -
                                                      ITEM_DESC_9_PTCH_SRC.margins.bottom;
static const Rect     ITEM_DESC_TEXT_RECT           = { 11,  9, 26, 18};
static const Rect     ITEM_NAME_TEXT_RECT           = { 10,  7, 27,  7};
 
// Positions in pixels
static const BG_POINT SHOP_JOKER_SPRITES_INIT_POS = {120, 160};
static const BG_POINT ITEM_DESCRIPTION_SPRITE_POS = {135,   9};
static const Rect     SHOP_PRICES_TEXT_RECT       = { 72,  56, 192, 160 };
static const Rect     SHOP_REROLL_RECT            = { 88,  96, UNDEFINED, UNDEFINED };
// clang-format on
 
static List s_shop_items_list = LIST_DEFAULT;
 
enum GameShopStates
{
    GAME_SHOP_SKIP_TAGS,
    GAME_SHOP_INTRO,
    GAME_SHOP_ACTIVE,
    GAME_SHOP_SHOW_ITEM_DESC,
    GAME_SHOP_HIDE_ITEM_DESC,
    GAME_SHOP_EXIT,
    GAME_SHOP_MAX
};
 
static void shop_redeem_skip_tags(void);
static void shop_intro(void);
static void shop_process_user_input(void);
static void shop_show_item_desc_on_init(void);
static void shop_show_item_desc_on_update(void);
static void shop_hide_item_desc_on_init(void);
static void shop_hide_item_desc_on_update(void);
static void shop_hide_item_desc_on_exit(void);
static void shop_outro(void);
 
// clang-format off
static StateInfo shop_state_actions[GAME_SHOP_MAX] = {
    [GAME_SHOP_SKIP_TAGS]      = STATE_INFO_UPDATE_FN_ONLY(shop_redeem_skip_tags),
    [GAME_SHOP_INTRO]          = STATE_INFO_UPDATE_FN_ONLY(shop_intro),
    [GAME_SHOP_ACTIVE]         = STATE_INFO_UPDATE_FN_ONLY(shop_process_user_input),
    [GAME_SHOP_SHOW_ITEM_DESC] = STATE_INFO_INIT_UPDATE_FN(
                                    shop_show_item_desc_on_init,
                                    shop_show_item_desc_on_update),
    [GAME_SHOP_HIDE_ITEM_DESC] = {.on_init   = shop_hide_item_desc_on_init,
                                  .on_update = shop_hide_item_desc_on_update,
                                  .on_exit   = shop_hide_item_desc_on_exit},
    [GAME_SHOP_EXIT]           = STATE_INFO_UPDATE_FN_ONLY(shop_outro),
};
// clang-format on
 
static StateMachine shop_sm = STATE_MACHINE_DEFINE(shop_state_actions, GAME_SHOP_MAX);
 
// Shop SelectionGrid
 
#define SHOP_GRID_OWNED_ROW    0
#define SHOP_GRID_FOR_SALE_ROW 1
 
static int shop_top_row_get_size(void);
static bool shop_top_row_on_selection_changed(
    SelectionGrid* selection_grid,
    int row_idx,
    const Selection* prev_selection,
    const Selection* new_selection
);
static void shop_top_row_on_key_transit(SelectionGrid* selection_grid, Selection* selection);
static int shop_reroll_row_get_size(void);
static bool shop_reroll_row_on_selection_changed(
    SelectionGrid* selection_grid,
    int row_idx,
    const Selection* prev_selection,
    const Selection* new_selection
);
static void shop_reroll_row_on_key_transit(SelectionGrid* selection_grid, Selection* selection);
 
static SelectionGridRow shop_selection_rows[] = {
    {0, jokers_sel_row_get_size,  jokers_sel_row_on_selection_changed,  jokers_sel_row_on_key_transit,  {.wrap = false, .has_h_exit_idx = false, .h_exit_idx = 0}},
    {1, shop_top_row_get_size,    shop_top_row_on_selection_changed,    shop_top_row_on_key_transit,    {.wrap = false, .has_h_exit_idx = false, .h_exit_idx = 0}},
    {2, shop_reroll_row_get_size, shop_reroll_row_on_selection_changed, shop_reroll_row_on_key_transit, {.wrap = false, .has_h_exit_idx = true, .h_exit_idx = 1} },
};
 
static const Selection SHOP_INIT_SEL = {-1, 1};
 
static SelectionGrid shop_selection_grid = {
    shop_selection_rows,
    NUM_ELEM_IN_ARR(shop_selection_rows),
    SHOP_INIT_SEL
};
 
// Shop Buttons
 
static void next_round_on_pressed(void);
static void reroll_on_pressed(void);
static bool reroll_can_be_pressed(void);
static Button next_round_button =
    {NEXT_ROUND_BTN_SELECTED_BORDER_PAL_IDX, NEXT_ROUND_BTN_PAL_IDX, next_round_on_pressed, NULL};
static Button reroll_button = {
    REROLL_BTN_SELECTED_BORDER_PAL_IDX,
    REROLL_BTN_PAL_IDX,
    reroll_on_pressed,
    reroll_can_be_pressed
};
 
// Shop internal variables
 
static int s_timer;
 
static int s_reroll_cost = REROLL_BASE_COST;
 
// Variables relative to the Card we are showing the description of
 
static Item* s_description_item = NULL;
static FIXED s_description_item_original_x_pos = UNDEFINED;
static FIXED s_description_item_original_y_pos = UNDEFINED;
static int s_show_description_anim_progress = 0;
 
Item* shop_get_description_item(void)
{
    return s_description_item;
}
 
int shop_get_reroll_cost(void)
{
    return s_reroll_cost;
}
 
void shop_set_reroll_cost(int cost)
{
    s_reroll_cost = cost;
}
 
void shop_reset(void)
{
    list_clear(&s_shop_items_list);
    s_shop_items_list = list_init();
    joker_reset_rollable_jokers();
}
 
void shop_change_background(void)
{
    toggle_windows(false, true);
 
    GRIT_CPY(pal_bg_mem, background_shop_gfxPal);
    GRIT_CPY(&tile_mem[MAIN_BG_CBB], background_shop_gfxTiles);
    GRIT_CPY(&se_mem[MAIN_BG_SBB], background_shop_gfxMap);
 
    // Set the outline colors for the shop background. This is used for the alternate shop
    // palettes when opening packs
    pal_bg_mem[SHOP_BOTTOM_PANEL_BORDER_PAL_IDX] = 0x213D;
    pal_bg_mem[SHOP_PANEL_SHADOW_PAL_IDX] = 0x10B4;
 
    // Reset the shop lights to correct colors
    pal_bg_mem[SHOP_LIGHTS_2_PAL_IDX] = SHOP_LIGHTS_2_CLR;
    pal_bg_mem[SHOP_LIGHTS_3_PAL_IDX] = SHOP_LIGHTS_3_CLR;
    pal_bg_mem[SHOP_LIGHTS_4_PAL_IDX] = SHOP_LIGHTS_4_CLR;
    pal_bg_mem[SHOP_LIGHTS_1_PAL_IDX] = SHOP_LIGHTS_1_CLR;
 
    // Disable the button highlight colors
    pal_bg_mem[REROLL_BTN_SELECTED_BORDER_PAL_IDX] = pal_bg_mem[REROLL_BTN_PAL_IDX];
    pal_bg_mem[NEXT_ROUND_BTN_SELECTED_BORDER_PAL_IDX] = pal_bg_mem[NEXT_ROUND_BTN_PAL_IDX];
}
 
void shop_on_init(void)
{
    shop_change_background();
 
    s_timer = TM_ZERO;
 
    state_machine_register(&shop_sm);
    state_machine_change_state(&shop_sm, GAME_SHOP_SKIP_TAGS);
 
    skip_tag_process_start(SKIP_TAG_EVENT_ON_SHOP_INIT);
 
    // The selection grid is initialized outside of bounds and moved
    // to trigger the selection change so the initial selection is visible
    shop_selection_grid.selection = SHOP_INIT_SEL;
    selection_grid_move_selection_horz(&shop_selection_grid, 1);
}
 
static void shop_redeem_skip_tags(void)
{
    if (skip_tag_process_get_proc_stage() == SKIP_TAG_PROCESS_STAGE_END)
    {
        s_timer = TM_ZERO;
        state_machine_change_state(&shop_sm, GAME_SHOP_INTRO);
    }
}
 
static Item* shop_create_top_row_item(void)
{
    // TODO: Randomize item type when consumables are implemented
    return item_roll_new(ITEM_TYPE_JOKER, RNG_SEQ_SHOP_ITEMS);
}
 
static void shop_create_top_row_items(void)
{
    tte_erase_rect_wrapper(SHOP_PRICES_TEXT_RECT);
 
    List* shop_items_list = &s_shop_items_list;
 
    list_clear(shop_items_list);
    *shop_items_list = list_init();
 
    for (int i = 0; i < MAX_SHOP_ITEMS; i++)
    {
        Item* item = shop_create_top_row_item();
 
        if (item == NULL)
        {
            MGBA_FUNC_WARN("Could not create shop item");
 
            // TODO: Decide how to handle this case gracefully
            // If the issue for example is that we can't generate any more jokers,
            // because for example the user owns all of them,
            // maybe we need to generate consumables instead.
            return;
        }
 
        item->x = int2fx(SHOP_JOKER_SPRITES_INIT_POS.x + i * CARD_SPRITE_SIZE_PX);
        item->y = int2fx(SHOP_JOKER_SPRITES_INIT_POS.y);
        item->tx = item->x;
        item->ty = int2fx(ITEM_SHOP_Y);
 
        item_print_buy_price_under(item);
 
        list_push_back(shop_items_list, item);
    }
}
 
static void shop_intro()
{
    main_bg_se_copy_rect_1_tile_vert(POP_MENU_ANIM_RECT, SCREEN_UP);
 
    if (s_timer == TM_CREATE_SHOP_ITEMS_WAIT)
    {
        shop_create_top_row_items();
    }
 
    if (s_timer >= TM_SHIFT_SHOP_ICON_WAIT) // Shift the shop icon
    {
        int timer_offset = s_timer - 6;
 
        // TODO: Extract to generic function?
        for (int y = 0; y < timer_offset; y++)
        {
            Rect from = SHOP_ICON_FROM_RECT;
            from.top += y - timer_offset;
            from.bottom += y - timer_offset;
 
            BG_POINT to = SHOP_ICON_TO_POS;
            to.y = y;
 
            main_bg_se_copy_rect(from, to);
        }
    }
 
    if (s_timer == TM_END_GAME_SHOP_INTRO)
    {
        state_machine_change_state(&shop_sm, GAME_SHOP_ACTIVE);
        s_timer = TM_ZERO; // Reset the timer
 
        // print initial reroll cost only when the panel is in place
        tte_printf(
            "#{P:%d,%d; cx:0x%X000}$%d",
            SHOP_REROLL_RECT.left,
            SHOP_REROLL_RECT.top,
            TTE_WHITE_PB,
            s_reroll_cost
        );
    }
}
 
static int shop_top_row_get_size(void)
{
    // + 1 to account for next round button
    return list_get_len(&s_shop_items_list) + 1;
}
 
static inline void shop_buy_item(int shop_item_idx)
{
    List* shop_items_list = &s_shop_items_list;
    Item* item = (Item*)list_get_at_idx(shop_items_list, shop_item_idx);
 
    g_game_vars.money -= item_get_buy_price(item);
    display_money();
    sprite_object_erase_text_under((SpriteObject*)item);
    sprite_object_set_focus((SpriteObject*)item, false);
    item_acquire(item);
    list_remove_at_idx(shop_items_list, shop_item_idx); // Remove the joker from the shop
}
 
static void shop_top_row_on_key_transit(SelectionGrid* selection_grid, Selection* selection)
{
    if (!key_hit(SELECT_CARD))
        return;
 
    if (selection->x == NEXT_ROUND_BTN_SEL_X)
    {
        button_press(&next_round_button);
    }
    else
    {
        int shop_item_idx = selection->x - 1; // - 1 to account for next round button
        Item* item = (Item*)list_get_at_idx(&s_shop_items_list, shop_item_idx);
        if (!item_can_acquire(item) || g_game_vars.money < item_get_buy_price(item))
        {
            return;
        }
 
        shop_buy_item(shop_item_idx);
        selection_grid_move_selection_horz(selection_grid, -1);
    }
}
 
static bool shop_top_row_on_selection_changed(
    SelectionGrid* selection_grid,
    int row_idx,
    const Selection* prev_selection,
    const Selection* new_selection
)
{
    List* shop_items_list = &s_shop_items_list;
    // Guard if we move down while on jokers
    if (new_selection->y > row_idx && prev_selection->x > 0)
        return false;
 
    // The selection grid system only guarantees that the new selection is within bounds
    // but not the previous one...
    // This allows using INIT_SEL = {-1, 1} and move to set the initial selection in a hacky way...
    if (prev_selection->y == row_idx && prev_selection->x >= 0 &&
        prev_selection->x < shop_top_row_get_size())
    {
        if (prev_selection->x == NEXT_ROUND_BTN_SEL_X)
        {
            button_set_highlight(&next_round_button, false);
        }
        else
        {
            int idx = prev_selection->x - 1; // -1 to account for next round button
            SpriteObject* sprite_object = (SpriteObject*)list_get_at_idx(shop_items_list, idx);
            sprite_object_set_focus(sprite_object, false);
        }
    }
 
    if (new_selection->y == row_idx)
    {
        if (new_selection->x == NEXT_ROUND_BTN_SEL_X)
        {
            button_set_highlight(&next_round_button, true);
        }
        else
        {
            int idx = new_selection->x - 1; // -1 to account for next round button
            SpriteObject* sprite_object = (SpriteObject*)list_get_at_idx(shop_items_list, idx);
            sprite_object_set_focus(sprite_object, true);
        }
    }
 
    return true;
}
 
static int shop_reroll_row_get_size()
{
    return 1;
}
 
static bool shop_reroll_row_on_selection_changed(
    SelectionGrid* selection_grid,
    int row_idx,
    const Selection* prev_selection,
    const Selection* new_selection
)
{
    if (row_idx == prev_selection->y)
    {
        button_set_highlight(&reroll_button, false);
 
        if (new_selection->x != NEXT_ROUND_BTN_SEL_X)
        {
            int idx = new_selection->x - 1;
            SpriteObject* sprite_object = (SpriteObject*)list_get_at_idx(&s_shop_items_list, idx);
            sprite_object_set_focus(sprite_object, true);
        }
    }
    else if (row_idx == new_selection->y)
    {
        button_set_highlight(&reroll_button, true);
    }
 
    return true;
}
 
static inline void shop_reroll(void)
{
    g_game_vars.money -= s_reroll_cost;
    display_money(); // Update the money display
 
    List* shop_items_list = &s_shop_items_list;
    ListItr itr = list_itr_create(shop_items_list);
    Item* item;
 
    while ((item = list_itr_next(&itr)))
    {
        if (item != NULL && item->type == ITEM_TYPE_JOKER)
        {
            item_dispose(&item);
        }
    }
 
    list_clear(shop_items_list);
    *shop_items_list = list_init();
 
    shop_create_top_row_items();
 
    itr = list_itr_create(shop_items_list);
 
    SpriteObject* item_sprite_object;
    while ((item_sprite_object = list_itr_next(&itr)))
    {
        if (item_sprite_object != NULL)
        {
            item_sprite_object->y = item_sprite_object->ty;
 
            sprite_object_shake(item_sprite_object, UNDEFINED);
        }
    }
 
    s_reroll_cost++;
    tte_printf(
        "#{P:%d,%d; cx:0x%X000}$%d",
        SHOP_REROLL_RECT.left,
        SHOP_REROLL_RECT.top,
        TTE_WHITE_PB,
        s_reroll_cost
    );
}
 
static void shop_reroll_row_on_key_transit(SelectionGrid* selection_grid, Selection* selection)
{
    if (!key_hit(SELECT_CARD))
    {
        return;
    }
 
    button_press(&reroll_button);
}
 
static void next_round_on_pressed(void)
{
    // Go to next blind selection game state
    state_machine_change_state(&shop_sm, GAME_SHOP_EXIT);
    s_timer = TM_ZERO;
    s_reroll_cost = REROLL_BASE_COST;
 
    pal_bg_mem[NEXT_ROUND_BTN_SELECTED_BORDER_PAL_IDX] = pal_bg_mem[SHOP_PANEL_SHADOW_PAL_IDX];
}
 
static void reroll_on_pressed(void)
{
    // TODO: Add money sound effect
    shop_reroll();
}
 
static bool reroll_can_be_pressed(void)
{
    return g_game_vars.money >= s_reroll_cost;
}
 
static void shop_process_user_input(void)
{
    selection_grid_process_input(&shop_selection_grid);
 
    static Item* new_description_item = NULL;
 
    // Determine the Item we would show the description of
    switch (shop_selection_grid.selection.y)
    {
        case SHOP_GRID_OWNED_ROW:
        {
            new_description_item =
                list_get_at_idx(get_jokers_list(), shop_selection_grid.selection.x);
            break;
        }
 
        case SHOP_GRID_FOR_SALE_ROW:
        {
            // Ignore the "Next Round" button when selecting descripted Item: get it at
            // selection.x - 1 in the list to account for this next round button being ignored.
            new_description_item =
                (shop_selection_grid.selection.x != NEXT_ROUND_BTN_SEL_X)
                    ? list_get_at_idx(&s_shop_items_list, shop_selection_grid.selection.x - 1)
                    : NULL;
            break;
        }
 
            // TODO: handle Consumables and Vouchers when implemented
 
        default:
        {
            new_description_item = NULL;
            break;
        }
    }
 
    // Show description of selected card when pressing B
    if (new_description_item != NULL && key_held(DESELECT_CARDS))
    {
        s_description_item = new_description_item;
        s_description_item_original_x_pos = s_description_item->tx;
        s_description_item_original_y_pos = s_description_item->ty;
 
        s_timer = TM_ZERO;
        state_machine_change_state(&shop_sm, GAME_SHOP_SHOW_ITEM_DESC);
    }
}
 
static void shop_show_item_desc_on_init(void)
{
    // This starts at 0, then gets incremented up to TM_SHOW_ITEM_DESC_WAIT. Will be used to
    // revert the animation if the B button is released midway through it
    s_show_description_anim_progress = 0;
 
    // Erase shop/round text
    tte_erase_rect_wrapper(PLAYING_SCREEN_RECT);
 
    // Move all other Sprites offscreen
 
    Item* tmp_item = NULL;
 
    // Owned Jokers
    ListItr itr = list_itr_create(get_jokers_list());
    while ((tmp_item = (Item*)list_itr_next(&itr)))
    {
        if (tmp_item != s_description_item)
            tmp_item->ty -= int2fx(OWNED_ITEMS_HIDE_Y_OFFSET);
    }
 
    // Shop Jokers
    itr = list_itr_create(&s_shop_items_list);
    while ((tmp_item = (Item*)list_itr_next(&itr)))
    {
        if (tmp_item != s_description_item)
            tmp_item->ty = int2fx(SHOP_JOKER_SPRITES_INIT_POS.y + TILE_SIZE);
    }
 
    set_owned_skip_tags_moved_offscreen(true);
 
    // Set description_card new target position
 
    s_description_item->tx = int2fx(ITEM_DESCRIPTION_SPRITE_POS.x);
    s_description_item->ty = int2fx(ITEM_DESCRIPTION_SPRITE_POS.y);
}
 
static void shop_show_item_desc_on_update(void)
{
    if (s_timer <= TM_SHOW_ITEM_DESC_WAIT)
    {
        s_show_description_anim_progress++;
 
        // Hide Deck (last frames only)
        if (TM_SHOW_ITEM_DESC_WAIT - s_timer < TM_HIDE_DECK_WAIT)
            main_bg_se_move_rect_1_tile_vert(DECK_ANIM_RECT, SCREEN_DOWN);
        // Hide shop panel
        main_bg_se_move_rect_1_tile_vert(POP_MENU_ANIM_RECT, SCREEN_DOWN);
        // Hide Owned Cards panels
        main_bg_se_move_rect_1_tile_vert(OWNED_ITEMS_PANEL_RECT, SCREEN_UP);
    }
 
    // Anim end
    else if (s_timer == TM_SHOW_ITEM_DESC_WAIT + 1)
    {
        // Print the Item's name
        const char* item_name = item_get_name(s_description_item);
        tte_printf(
            TTE_WHITE_TAG "#{P:%d,%d}%*s%s",
            ITEM_NAME_TEXT_RECT.left * TILE_SIZE,
            ITEM_NAME_TEXT_RECT.top * TILE_SIZE,
            (rect_width(&ITEM_NAME_TEXT_RECT) - strlen(item_name)) / 2,
            "",
            item_name
        );
 
        // Compute needed space for the description and print it
        int nb_printed_lines = item_print_description(s_description_item, ITEM_DESC_TEXT_RECT);
        int desc_bottom_offset = ITEM_DESC_MAX_TEXT_HEIGHT - nb_printed_lines;
 
        // Print Rarity/Type and change the panel's color before drawing it so the color is already
        // set, in case there is any lag
        ItemDescSubtypeInfo item_subtype_info = item_get_subtype_info(s_description_item);
        const char* subtype_str = item_subtype_info.name_str;
        tte_printf(
            TTE_WHITE_TAG "#{P:%d,%d}%*s%s",
            ITEM_DESC_TEXT_RECT.left * TILE_SIZE,
            (ITEM_DESC_TEXT_RECT.bottom - desc_bottom_offset - 1) * TILE_SIZE,
            (rect_width(&ITEM_DESC_TEXT_RECT) - strlen(subtype_str)) / 2,
            "",
            subtype_str
        );
 
        pal_bg_mem[SHOP_DESC_RARITY_MAIN_COLOR_PAL_IDX] = item_subtype_info.main_color;
        pal_bg_mem[SHOP_DESC_RARITY_SHADOW_COLOR_PAL_IDX] = item_subtype_info.shadow_color;
 
        // Draw description panel
        Rect actual_dest_rect = ITEM_DESC_9_PTCH_TO_RECT;
        actual_dest_rect.bottom -= desc_bottom_offset;
        main_bg_se_copy_expand_9_patch(actual_dest_rect, &ITEM_DESC_9_PTCH_SRC);
    }
 
    // Actively wait for the B button to be released
    if (!key_held(DESELECT_CARDS))
    {
        s_timer = TM_ZERO;
        state_machine_change_state(&shop_sm, GAME_SHOP_HIDE_ITEM_DESC);
    }
}
 
static void shop_hide_item_desc_on_init(void)
{
    // Erase shop text and Joker Description frame if we had time to draw them
    if (s_show_description_anim_progress >= TM_SHOW_ITEM_DESC_WAIT)
    {
        main_bg_se_clear_rect(ITEM_DESC_9_PTCH_TO_RECT);
    }
    // Or clear the owned cards' panel that haven't finished moving up
    else
    {
        main_bg_se_clear_rect(OWNED_ITEMS_PANEL_ANIM_CLEAR);
    }
 
    tte_erase_rect_wrapper(PLAYING_SCREEN_RECT);
 
    // Redraw Jokers/Consumables frames
    main_bg_se_copy_expand_3x3_rect(OWNED_JOKERS_PANEL_RECT, OWNED_ITEMS_PANEL_3X3_SRC_POS);
    main_bg_se_copy_expand_3x3_rect(OWNED_CONSUMABLES_PANEL_RECT, OWNED_ITEMS_PANEL_3X3_SRC_POS);
 
    // Move Sprites back to their positions
 
    Item* tmp_item = NULL;
 
    // Owned Items
    ListItr itr = list_itr_create(get_jokers_list());
    while ((tmp_item = (Item*)list_itr_next(&itr)))
    {
        if (tmp_item != s_description_item)
            tmp_item->ty = int2fx(HELD_JOKERS_POS.y);
    }
 
    // Shop Jokers
    itr = list_itr_create(&s_shop_items_list);
    while ((tmp_item = (Item*)list_itr_next(&itr)))
    {
        if (tmp_item != s_description_item)
            tmp_item->ty = int2fx(ITEM_SHOP_Y);
    }
 
    set_owned_skip_tags_moved_offscreen(false);
 
    s_description_item->tx = s_description_item_original_x_pos;
    s_description_item->ty = s_description_item_original_y_pos;
}
 
static void shop_hide_item_desc_on_update(void)
{
    if (s_timer <= s_show_description_anim_progress)
    {
        // Show Deck (last frames only)
        if (s_show_description_anim_progress > TM_HIDE_DECK_WAIT &&
            s_timer < (s_show_description_anim_progress - (TM_HIDE_DECK_WAIT + 1)))
        {
            main_bg_se_move_rect_1_tile_vert(DECK_ANIM_RECT, SCREEN_UP);
        }
        // Show menu panel
        main_bg_se_move_rect_1_tile_vert(POP_MENU_ANIM_RECT, SCREEN_UP);
    }
 
    // Last anim frame (no need to wait for the Joker to have stopped for this):
    else if (s_timer == s_show_description_anim_progress + 1)
    {
        s_timer = TM_ZERO;
        state_machine_change_state(&shop_sm, GAME_SHOP_ACTIVE);
    }
}
 
static void shop_hide_item_desc_on_exit(void)
{
    // TODO: Do the following in a less hacky way
 
    // Need to account for the description_card being selected if it came from the shop.
    // Temporarily lower the target position of the Item so that the price is printed in the
    // appropriate place
    if (!item_is_owned(s_description_item))
        s_description_item->ty += int2fx(TILE_SIZE);
 
    // Print price under shop Jokers
    Item* item = NULL;
    ListItr itr = list_itr_create(&s_shop_items_list);
    while ((item = list_itr_next(&itr)))
    {
        item_print_buy_price_under(item);
    }
 
    // Revert what we just did so the Item still appears selected
    if (!item_is_owned(s_description_item))
        s_description_item->ty -= int2fx(TILE_SIZE);
 
    // Print Reroll prince
    tte_printf(
        "#{P:%d,%d; cx:0x%X000}$%d",
        SHOP_REROLL_RECT.left,
        SHOP_REROLL_RECT.top,
        TTE_WHITE_PB,
        s_reroll_cost
    );
 
    // Print Deck size that was erased
    display_deck_size_max();
 
    // if we are NOT pressing A, print the price under the description card if it's a card we own.
    if (!key_held(SELECT_CARD) && item_is_owned(s_description_item))
    {
        sprite_object_print_price_under(
            (SpriteObject*)s_description_item,
            item_get_sell_price(s_description_item)
        );
    }
 
    s_description_item = NULL;
}
 
static void shop_outro(void)
{
    // Shift the shop panel
    main_bg_se_move_rect_1_tile_vert(POP_MENU_ANIM_RECT, SCREEN_DOWN);
 
    main_bg_se_copy_rect_1_tile_vert(TOP_LEFT_PANEL_ANIM_RECT, SCREEN_UP);
 
    if (s_timer == 1)
    {
        tte_erase_rect_wrapper(SHOP_PRICES_TEXT_RECT); // Erase the shop prices text
 
        ListItr itr = list_itr_create(&s_shop_items_list);
        SpriteObject* shop_item;
        while ((shop_item = list_itr_next(&itr)))
        {
            if (shop_item != NULL)
            {
                shop_item->ty = int2fx(160);
            }
        }
 
        reset_top_left_panel_bottom_row();
    }
    else if (s_timer == 2)
    {
        // TODO: make heads or tails of what's going on here and replace
        // magic numbers.
        int y = 5;
        memset16(&se_mat[MAIN_BG_SBB][y - 1][0], 0x0001, 1);
        memset16(&se_mat[MAIN_BG_SBB][y - 1][1], 0x0002, 7);
        memset16(&se_mat[MAIN_BG_SBB][y - 1][8], SE_HFLIP | 0x0001, 1);
    }
 
    if (s_timer >= MENU_POP_OUT_ANIM_FRAMES)
    {
        game_change_state(GAME_STATE_BLIND_SELECT);
    }
}
 
static inline void shop_lights_anim_frame(void)
{
    // Shift palette around the border of the shop icon
    COLOR shifted_palette[4];
    shifted_palette[0] = pal_bg_mem[SHOP_LIGHTS_2_PAL_IDX];
    shifted_palette[1] = pal_bg_mem[SHOP_LIGHTS_3_PAL_IDX];
    shifted_palette[2] = pal_bg_mem[SHOP_LIGHTS_4_PAL_IDX];
    shifted_palette[3] = pal_bg_mem[SHOP_LIGHTS_1_PAL_IDX];
 
    // Circularly shift the palette
    int last = shifted_palette[3];
 
    for (int i = 3; i > 0; --i)
    {
        shifted_palette[i] = shifted_palette[i - 1];
    }
 
    shifted_palette[0] = last;
 
    // Copy the shifted palette to the next 4 slots
    pal_bg_mem[SHOP_LIGHTS_2_PAL_IDX] = shifted_palette[0];
    pal_bg_mem[SHOP_LIGHTS_3_PAL_IDX] = shifted_palette[1];
    pal_bg_mem[SHOP_LIGHTS_4_PAL_IDX] = shifted_palette[2];
    pal_bg_mem[SHOP_LIGHTS_1_PAL_IDX] = shifted_palette[3];
}
 
void shop_on_update(void)
{
    s_timer++;
 
    if (s_timer % 20 == 0)
    {
        shop_lights_anim_frame();
    }
}
 
void shop_on_exit(void)
{
    List* shop_items_list = &s_shop_items_list;
    ListItr itr = list_itr_create(shop_items_list);
    Item* item;
 
    while ((item = list_itr_next(&itr)))
    {
        item_dispose(&item);
    }
 
    list_clear(shop_items_list);
 
    increment_blind(BLIND_STATE_DEFEATED); // TODO: Move to game_round_end()?
 
    state_machine_remove(&shop_sm);
}