update pokedex detail screen, resolves #23

src/pokedex/pokedex.c

@@ -0,0 +1,517 @@
+#include <agb_debug.h>
+#include <constants/pkmns.h>
+#include <pokeagb/pokeagb.h>
+#include <pokedex/pdexArrow.h>
+#include <pokedex/pdexBall.h>
+#include <pokedex/pdexBg.h>
+#include <pokedex/pdexScrollBar.h>
+#include <pokedex/pdexSelectHalf.h>
+
+#include "pokedex_common.h"
+
+#define TB_TITLE 0
+#define TB_PKMN 1
+#define TB_SEEN 2
+#define TB_CAUGHT 3
+#define TB_MAIN 4
+
+#define TB_SEEN_Y (6)
+#define TB_CAUGHT_Y 3
+
+#define DEX_SCROLL_MIN 23
+#define DEX_SCROLL_MAX 146
+#define SCROLL_SPEED_MAX 6
+
+void pdex_load(void);
+void pdex_vblank_handler(void);
+void pdex_loop(u8 tid);
+void pdex_cb_handler(void);
+
+extern const pchar pdex_str_title[];
+extern const pchar pdex_str_seen[];
+extern const pchar pdex_str_caught[];
+extern const pchar pdex_str_empty[];
+
+static const u8 pdex_y_offset[] = {19, 35, 51, 67, 83, 99, 115, 131};
+static const u16 scroll_speed_delays[] = {20, 20, 20, 20,10, 5, 0};
+
+struct TextboxTemplate pdex_boxes[] = {
+    {.bg_id = 0, .x = 11, .y = 0, .width = 10, .height = 2, .pal_id = 15, .charbase = 1},
+    {.bg_id = 0, .x = 2, .y = 2, .width = 10, .height = 2, .pal_id = 15, .charbase = 21},
+    {.bg_id = 0, .x = 3, .y = 13, .width = 9, .height = 3, .pal_id = 15, .charbase = 41},
+    {.bg_id = 0, .x = 3, .y = 16, .width = 9, .height = 2, .pal_id = 15, .charbase = 59},
+
+    {.bg_id = 1, .x = 16, .y = 0, .width = 11, .height = 32, .pal_id = 15, .charbase = 77},
+
+    {.bg_id = 0xFF},
+};
+
+s16 pdex_get_y_offset(s8 n) {
+    s8 modOffset = n + pokedex_context->hardware_scroll_amount;
+    if (modOffset < -1) {
+        modOffset += 16;
+    }
+
+    if (modOffset > 14) {
+        modOffset -= 16;
+    }
+    return (19 + (16 * modOffset));
+}
+
+void pdex_main_box_species_fill(s8 n, u16 species, bool seen, bool caught) {
+    seen = true;
+    s16 y = pdex_get_y_offset(n);
+    rboxid_fill_rectangle(TB_MAIN, 0, 0, y, 11 * 8, 16);
+    const pchar *stringToPrint = (seen || caught) ? &pokemon_names[species][0] : &pdex_str_empty[0];
+    const pchar stringWhitespace[] = {0x0, 0xFF};
+    fmt_int_10(string_buffer, pokedex_context->cursor_position_top + n, 2, 3);
+    pstrcat(string_buffer, &stringWhitespace[0]);
+    pstrcat(string_buffer, stringToPrint);
+    rboxid_print(TB_MAIN, FONT_DEX_STD, 4, y, &pdex_text_color, 0, string_buffer);
+}
+
+void pdex_update_balls(void) {
+    for (u8 i = 0; i < 8; ++i) {
+        if (pdex_lazy_lookup_entry(i + pokedex_context->cursor_position_top)->caught)
+            OBJID_SHOW(pokedex_context->ball_oams[i]);
+        else
+            OBJID_HIDE(pokedex_context->ball_oams[i]);
+    }
+}
+
+void pdex_update_page_full() {
+    rboxid_clear_pixels(TB_MAIN, 0);
+    for (u16 i = pokedex_context->cursor_position_top; i < pokedex_context->cursor_position_top + 8; ++i) {
+        pdex_main_box_species_fill(i - pokedex_context->cursor_position_top, pdex_lazy_lookup_entry(i)->species,
+                                   pdex_lazy_lookup_entry(i)->seen, pdex_lazy_lookup_entry(i)->caught);
+    }
+    pdex_update_balls();
+    rboxid_update_tilemap_and_tileset(TB_MAIN);
+}
+
+void pdex_load_sc(void) {
+    rboxid_clear_pixels(TB_SEEN, 0);
+    rboxid_clear_pixels(TB_CAUGHT, 0);
+    u32 seen = pokedex_count(false) + 10;
+    u32 caught = pokedex_count(true);
+    pchar seenBuffer[4];
+    pchar caughtBuffer[4];
+    fmt_int_10(seenBuffer, seen, 0, MAX3_COUNT_DIGITS(seen));
+    fmt_int_10(caughtBuffer, caught, 0, MAX3_COUNT_DIGITS(caught));
+
+    u32 twidthSeen = font_get_width_of_string(FONT_DEX_STD, seenBuffer, 0x0000);
+    u32 twidthCaught = font_get_width_of_string(FONT_DEX_STD, caughtBuffer, 0x0000);
+
+    rboxid_print(TB_SEEN, FONT_DEX_STD, 0, TB_SEEN_Y, &pdex_text_color, 0, &pdex_str_seen[0]);
+    rboxid_print(TB_CAUGHT, FONT_DEX_STD, 0, TB_CAUGHT_Y, &pdex_text_color, 0, &pdex_str_caught[0]);
+
+    rboxid_print(TB_SEEN, FONT_DEX_STD, TB_STD_RIGHT(twidthSeen, TB_BOT_LEN_PX), TB_SEEN_Y + 1, &pdex_text_color, 0,
+                 seenBuffer);
+    rboxid_print(TB_CAUGHT, FONT_DEX_STD, TB_STD_RIGHT(twidthCaught, TB_BOT_LEN_PX), TB_CAUGHT_Y + 1, &pdex_text_color,
+                 0, caughtBuffer);
+
+    rboxid_update_tilemap_and_tileset(TB_SEEN);
+    rboxid_update_tilemap_and_tileset(TB_CAUGHT);
+}
+
+void pdex_pokemon_load(u16 species) {
+    /* this is very temporary */
+    rboxid_clear_pixels(TB_PKMN, 0);
+    u32 twidth = font_get_width_of_string(FONT_DEX_STD, &pokemon_names[species][0], 0x0000);
+    rboxid_print(TB_PKMN, FONT_DEX_STD, TB_STD_CENTER(twidth, TB_STD_LEN_PX), 3, &pdex_text_color, 0,
+                 &pokemon_names[species][0]);
+    if (pokedex_context->pokemon_oam != -1) {
+        lz77UnCompVram(pokemon_graphics_front[species].data,
+                       ((void *)(objects[pokedex_context->pokemon_oam].final_oam.tile_num * 32) + ADDR_VRAM + 0x10000));
+        gpu_pal_apply_compressed(pokemon_palette_normal[species].data,
+                                 16 * (objects[pokedex_context->pokemon_oam].final_oam.palette_num + 16), 32);
+    } else {
+        struct SpriteTiles pkmnTiles = {pokemon_graphics_front[species].data, 2048, DEX_PKMN_TAG};
+        struct SpritePalette pkmnPal = {pokemon_palette_normal[species].data, DEX_PKMN_TAG};
+        const struct Template pkmnTemplate = {
+            .tiles_tag = DEX_PKMN_TAG,
+            .pal_tag = DEX_PKMN_TAG,
+            .oam = &pdex_oam_pkmn,
+            .animation = &anim_image_empty,
+            .graphics = &pkmnTiles,
+            .rotscale = &rotscale_empty,
+            .callback = oac_nullsub,
+        };
+        gpu_tile_obj_decompress_alloc_tag_and_upload(&pkmnTiles);
+
+        gpu_pal_decompress_alloc_tag_and_upload(&pkmnPal);
+        pokedex_context->pokemon_oam = (s8)template_instanciate_forward_search(&pkmnTemplate, 10, 10, 0);
+
+        objects[pokedex_context->pokemon_oam].pos1.x = 55;
+        objects[pokedex_context->pokemon_oam].pos1.y = 76;
+    }
+    rboxid_update_tilemap_and_tileset(TB_PKMN);
+}
+
+struct SpriteTiles pdex_ball_tiles = {pdexBallTiles, 128, DEX_BALL_TAG};
+struct SpritePalette pdex_ball_pal = {pdexBallPal, DEX_BALL_TAG};
+const struct OamData pdex_ball_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 1,
+};
+
+const struct Template pdex_ball_template = {
+    .tiles_tag = DEX_BALL_TAG,
+    .pal_tag = DEX_BALL_TAG,
+    .oam = &pdex_ball_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_ball_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = oac_nullsub,
+};
+
+void pdex_pokeballs_init(void) {
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&pdex_ball_tiles);
+    gpu_pal_obj_alloc_tag_and_apply(&pdex_ball_pal);
+    for (u8 i = 0; i < 8; ++i) {
+        pokedex_context->ball_oams[i] =
+            template_instanciate_forward_search(&pdex_ball_template, 124, 8 + pdex_y_offset[i], 1);
+    }
+}
+
+void pdex_oac_cursor_follow(struct Object *obj) { obj->pos1.y = objects[pokedex_context->cursor_main_oam].pos1.y; }
+
+void pdex_oac_cursor_main(struct Object *obj) {
+    obj->pos1.y = 13 + pdex_y_offset[pokedex_context->cursor_position_internal];
+}
+
+struct SpriteTiles pdex_cursor_tiles = {pdexSelectHalfTiles, 1024, DEX_CURSOR_TAG};
+struct SpritePalette pdex_cursor_pal = {pdexSelectHalfPal, DEX_CURSOR_TAG};
+const struct OamData pdex_cursor_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 1,
+    .size = 3,
+};
+
+const struct Template pdex_ball_main_template = {
+    .tiles_tag = DEX_CURSOR_TAG,
+    .pal_tag = DEX_CURSOR_TAG,
+    .oam = &pdex_cursor_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_cursor_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = pdex_oac_cursor_main,
+};
+
+const struct Template pdex_ball_follow_template = {
+    .tiles_tag = DEX_CURSOR_TAG,
+    .pal_tag = DEX_CURSOR_TAG,
+    .oam = &pdex_cursor_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_cursor_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = pdex_oac_cursor_follow,
+};
+
+void pdex_cursor_init(void) {
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&pdex_cursor_tiles);
+    gpu_pal_obj_alloc_tag_and_apply(&pdex_cursor_pal);
+    pokedex_context->cursor_main_oam = template_instanciate_forward_search(&pdex_ball_main_template, 144, 32, 0);
+    pokedex_context->cursor_follow_oam =
+        template_instanciate_forward_search(&pdex_ball_follow_template, 144 + 48, 32, 0);
+    objects[pokedex_context->cursor_follow_oam].final_oam.h_flip = true;
+}
+
+void pdex_oac_scroll_bar(struct Object *obj) {
+    obj->pos1.y = 23 + (((pokedex_context->cursor_position_top + pokedex_context->cursor_position_internal) * 123) /
+                        PDEX_LAST_SHOWN);
+}
+
+void pdex_oac_arrow(struct Object *obj) {
+    if (obj->priv[0]) {
+        // this is the down facing arrow
+        if (pokedex_context->cursor_position_top + 8 > PDEX_LAST_SHOWN) {
+            obj->final_oam.palette_num = obj->priv[2];
+        } else {
+            obj->final_oam.palette_num = obj->priv[1];
+        }
+    } else {
+        // this is the up facing arrow
+        if (pokedex_context->cursor_position_top == pokedex_context->first_seen) {
+            obj->final_oam.palette_num = obj->priv[2];
+        } else {
+            obj->final_oam.palette_num = obj->priv[1];
+        }
+    }
+}
+
+struct SpriteTiles pdex_scroll_bar_tiles = {pdexScrollBarTiles, 32, DEX_SCROLL_TAG};
+struct SpritePalette pdex_scroll_bar_pal = {pdexScrollBarPal, DEX_SCROLL_TAG};
+struct SpriteTiles pdex_arrow_tiles = {pdexArrowTiles, 128, DEX_ARROW_TAG};
+struct SpritePalette pdex_arrow_pal = {pdexArrowPal, DEX_ARROW_TAG};
+struct SpritePalette pdex_arrow_pal_gray = {pdexArrowPal, DEX_ARROW_TAG_EPAL};
+
+const struct OamData pdex_scroll_bar_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 0,
+};
+
+const struct OamData pdex_arrow_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 1,
+};
+
+const struct Template pdex_scroll_bar_template = {
+    .tiles_tag = DEX_SCROLL_TAG,
+    .pal_tag = DEX_SCROLL_TAG,
+    .oam = &pdex_scroll_bar_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_scroll_bar_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = pdex_oac_scroll_bar,
+};
+
+const struct Template pdex_arrow_template = {
+    .tiles_tag = DEX_ARROW_TAG,
+    .pal_tag = DEX_ARROW_TAG,
+    .oam = &pdex_arrow_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_arrow_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = pdex_oac_arrow,
+};
+
+void pdex_load_scroll_ui(void) {
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&pdex_scroll_bar_tiles);
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&pdex_arrow_tiles);
+    gpu_pal_obj_alloc_tag_and_apply(&pdex_scroll_bar_pal);
+    u8 normalPal = gpu_pal_obj_alloc_tag_and_apply(&pdex_arrow_pal);
+    u8 grayPal = gpu_pal_obj_alloc_tag_and_apply(&pdex_arrow_pal_gray);
+    tint_palette_gray(&palette_bg_unfaded[16 * (16 + grayPal)], 16);
+    (void)template_instanciate_forward_search(&pdex_scroll_bar_template, 233, 23, 0);
+    u8 upArrow = template_instanciate_forward_search(&pdex_arrow_template, 232, 19, 0);
+    u8 downArrow = template_instanciate_forward_search(&pdex_arrow_template, 232, 150, 0);
+    objects[downArrow].priv[0] = true;
+    objects[downArrow].final_oam.v_flip = true;
+    objects[upArrow].priv[1] = normalPal;
+    objects[downArrow].priv[1] = normalPal;
+    objects[upArrow].priv[2] = grayPal;
+    objects[downArrow].priv[2] = grayPal;
+}
+
+void pdex_data_setup(void) { pokedex_context->first_seen = 1; }
+
+void pdex_hardware_scroll(bool up) {
+    if (up) {
+        if (pokedex_context->hardware_scroll_amount > -15) {
+            bgid_mod_y_offset(1, -(16 << 8), 1);
+            pokedex_context->hardware_scroll_amount--;
+        } else {
+            pokedex_context->hardware_scroll_amount = 0;
+            bgid_mod_y_offset(1, 0, 0);
+        }
+    } else {
+
+        if (pokedex_context->hardware_scroll_amount < 15) {
+            bgid_mod_y_offset(1, 16 << 8, 1);
+            pokedex_context->hardware_scroll_amount++;
+        } else {
+            pokedex_context->hardware_scroll_amount = 0;
+            bgid_mod_y_offset(1, 0, 0);
+        }
+    }
+}
+
+void pdex_fill_previous_slot(void) {
+    u16 pIndex = pokedex_context->cursor_position_top - 1;
+    pdex_main_box_species_fill(-1, pdex_lazy_lookup_entry(pIndex)->species, pdex_lazy_lookup_entry(pIndex)->seen,
+                               pdex_lazy_lookup_entry(pIndex)->caught);
+}
+
+void pdex_fill_next_slot(void) {
+    u16 pIndex = pokedex_context->cursor_position_top + 8;
+    pdex_main_box_species_fill(8, pdex_lazy_lookup_entry(pIndex)->species, pdex_lazy_lookup_entry(pIndex)->seen,
+                               pdex_lazy_lookup_entry(pIndex)->caught);
+}
+
+void pdex_try_advance(u8 reverse) {
+    if (reverse) {
+        if (pokedex_context->cursor_position_internal > 0) {
+            pokedex_context->cursor_position_internal--;
+            m4aSongNumStart(600);
+        } else if ((pokedex_context->cursor_position_top) > (pokedex_context->first_seen)) {
+            pdex_fill_previous_slot();
+            pokedex_context->cursor_position_top--;
+            pdex_hardware_scroll(true);
+            m4aSongNumStart(600);
+        }
+    } else {
+        if (pokedex_context->cursor_position_internal < 7) {
+            pokedex_context->cursor_position_internal++;
+            m4aSongNumStart(600);
+        } else if (pokedex_context->cursor_position_top < (PDEX_LAST_SHOWN - 7)) {
+            pdex_fill_next_slot();
+            pokedex_context->cursor_position_top++;
+            pdex_hardware_scroll(false);
+            m4aSongNumStart(600);
+        }
+    }
+
+    u16 pkIndexToLoad = pokedex_context->cursor_position_internal + pokedex_context->cursor_position_top;
+    if (pdex_lazy_lookup_entry(pkIndexToLoad)->seen || pdex_lazy_lookup_entry(pkIndexToLoad)->caught)
+        pdex_pokemon_load(pdex_lazy_lookup_entry(pkIndexToLoad)->species);
+    else
+        pdex_pokemon_load(pdex_lazy_lookup_entry(pkIndexToLoad)->species); /* debug, just display the mofo */
+    pdex_update_balls();
+}
+
+void pdex_loop(u8 tid) {
+    switch (pokedex_context->state) {
+    case 0:
+        pokedex_context->state++;
+        break;
+    case 1:
+        for (u8 i = 0; i < 4; ++i)
+            bgid_send_tilemap(i);
+        rboxid_clear_pixels(TB_TITLE, 0);
+        rboxid_print(TB_TITLE, FONT_DEX_STD, 0, 0, &pdex_text_color, 0, &pdex_str_title[0]);
+        rboxid_update_tilemap_and_tileset(TB_TITLE);
+
+        pdex_data_setup();
+        pdex_cursor_init();
+
+        pdex_pokeballs_init();
+        pdex_load_scroll_ui();
+        pdex_pokemon_load(
+            pdex_lazy_lookup_entry(pokedex_context->cursor_position_top + pokedex_context->cursor_position_internal)
+                ->species);
+        pdex_load_sc();
+        pdex_update_page_full();
+
+        palette_bg_faded_fill_black();
+        pokedex_context->state++;
+        break;
+    case 2:
+        gpu_sync_bg_show(0);
+        gpu_sync_bg_show(1);
+        gpu_sync_bg_hide(3);
+
+        gpu_sync_bg_show(2);
+        fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 16, 0, 0x0000);
+        pokedex_context->state++;
+
+        break;
+    case 3:
+        if (!pal_fade_control.active)
+            pokedex_context->state++;
+        break;
+    case 4:
+        /* main control */
+        if (super.buttons_new & KEY_A) {
+            pokedex_context->state = 15;
+            m4aSongNumStart(5);
+        }
+        if (super.buttons_new & KEY_B) {
+            pokedex_context->state = 10;
+            m4aSongNumStart(601);
+        }
+        if ((super.buttons_new & KEY_DOWN)) {
+            pdex_try_advance(false);
+            pokedex_context->scroll_speed = 0;
+            pokedex_context->delay_count = 0;
+        } else if (super.buttons_held & KEY_DOWN) {
+            if (pokedex_context->scroll_speed < SCROLL_SPEED_MAX) {
+                if (pokedex_context->delay_count >= scroll_speed_delays[pokedex_context->scroll_speed]) {
+                    pdex_try_advance(false);
+                    pokedex_context->delay_count = 0;
+                    pokedex_context->scroll_speed++;
+                } else {
+                    pokedex_context->delay_count++;
+                }
+            } else {
+                pdex_try_advance(false);
+            }
+        }
+        if ((super.buttons_new & KEY_UP)) {
+            pdex_try_advance(true);
+            pokedex_context->scroll_speed = 0;
+            pokedex_context->delay_count = 0;
+        } else if (super.buttons_held & KEY_UP) {
+            if (pokedex_context->scroll_speed < SCROLL_SPEED_MAX) {
+                if (pokedex_context->delay_count >= scroll_speed_delays[pokedex_context->scroll_speed]) {
+                    pdex_try_advance(true);
+                    pokedex_context->delay_count = 0;
+                    pokedex_context->scroll_speed++;
+                } else {
+                    pokedex_context->delay_count++;
+                }
+            } else {
+                pdex_try_advance(true);
+            }
+        }
+        break;
+    case 10:
+        /* control flow exit */
+        fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 0, 16, 0x000);
+        pokedex_context->state++;
+        break;
+    case 11:
+        if (!pal_fade_control.active) {
+            task_del(tid);
+            pdex_vram_free_bgmaps();
+            pdex_free_memory();
+            void region_select_load(void);
+            set_callback2(region_select_load);
+        }
+        break;
+    case 15:
+        /* load the detail screen */
+        fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 0, 16, 0x0000);
+        pokedex_context->state++;
+        break;
+    case 16:
+        if (!pal_fade_control.active) {
+            pdex_vram_free_bgmaps();
+            task_del(tid);
+            void dexdetail_load(void);
+            set_callback2(dexdetail_load);
+        }
+    default:
+        break;
+    }
+}
+
+void pdex_load_gfx(void) {
+    /*TODO: setup text boxes here */
+    rbox_init_from_templates(&pdex_boxes[0]);
+
+    lz77UnCompVram(pdexBgTiles, (void *)0x0600C000);
+    LZ77UnCompWram(pdexBgMap, bgid_get_tilemap(2));
+    gpu_pal_apply_compressed(pdexBgPal, 0, 32);
+    gpu_pal_apply(pdex_text_pal, 15 * 16, 32);
+
+    /*setup window*/
+    lcd_io_set(REG_ID_WIN0H, (128 << 8) | (216));
+    lcd_io_set(REG_ID_WIN0V, ((20 << 8) | (148)));
+    lcd_io_set(REG_ID_WININ, WIN_BG0 | WIN_BG1 | WIN_BG2 | WIN_BG3 | WIN_OBJ);
+    lcd_io_set(REG_ID_WINOUT, WIN_BG0 | WIN_BG2 | WIN_BG3 | WIN_OBJ);
+    bgid_mark_for_sync(0);
+}
+
+void pdex_load(void) {
+
+    pdex_vram_setup();
+    pdex_load_gfx();
+
+    pokedex_context->pokemon_oam = -1;
+    pokedex_context->state = 0;
+    pokedex_context->hardware_scroll_amount = 0;
+    task_add(pdex_loop, 0);
+    set_callback2(pdex_cb_handler);
+}

src/pokedex/pokedex_common.c

@@ -0,0 +1,167 @@
+#include "pokedex_common.h"
+#include <constants/pkmns.h>
+#include <pokeagb/pokeagb.h>
+
+const u16 pdex_text_pal[] = {rgb5(255, 0, 255), rgb5(255, 255, 255), rgb5(0, 0, 0),     rgb5(255, 0, 255),
+                             rgb5(255, 0, 255), rgb5(255, 0, 255),   rgb5(255, 0, 255), rgb5(255, 0, 255),
+                             rgb5(255, 0, 255), rgb5(255, 0, 255),   rgb5(255, 0, 255), rgb5(255, 0, 255),
+                             rgb5(255, 0, 255), rgb5(255, 0, 255),   rgb5(255, 0, 255), rgb5(255, 0, 255)};
+
+const struct BgConfig pdex_bg_config[4] = {
+    {
+        .padding = 0,
+        .b_padding = 0,
+        .priority = 0,
+        .palette = 0,
+        .size = 0,
+        .map_base = 29,
+        .character_base = 0,
+        .bgid = 0,
+    },
+    {
+        .padding = 0,
+        .b_padding = 0,
+        .priority = 1,
+        .palette = 0,
+        .size = 0,
+        .map_base = 28,
+        .character_base = 0,
+        .bgid = 1,
+    },
+    {
+        .padding = 0,
+        .b_padding = 0,
+        .priority = 2,
+        .palette = 0,
+        .size = 0,
+        .map_base = 30,
+        .character_base = 3,
+        .bgid = 2,
+    },
+    {
+        .padding = 0,
+        .b_padding = 0,
+        .priority = 3,
+        .palette = 0,
+        .size = 1,
+        .map_base = 31,
+        .character_base = 3,
+        .bgid = 3,
+    },
+};
+
+struct DexForm pdex_forms[FORM_COUNT] = 
+{
+    {.index = 19, .forms = {{814, PKMN_ALOLA_RATTFRATZ, ALOLA}, {0xFFFF, 0xFFFF, FORM_END}}},
+    {.index = 20, .forms = {{815, PKMN_ALOLA_RATIKARL, ALOLA}, {0xFFFF, 0xFFFF, FORM_END}}},
+    {.index = 0xFFFF, .forms = {{0xFFFF, 0xFFFF, FORM_END}}},
+};
+
+const struct OamData pdex_oam_pkmn = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 3,
+};
+
+struct TextColor pdex_text_color = {0, 1, 2};
+
+void pdex_vblank_handler(void) {
+    gpu_sprites_upload();
+    copy_queue_process();
+    gpu_pal_upload();
+}
+
+u8 pstr_lines(pchar *str) {
+    u8 lines = 1;
+    while (*str != 0xFF) {
+        if (*str == 0xFE)
+            lines++;
+        str++;
+    }
+    return lines;
+}
+
+void pdex_cb_handler(void) {
+    if (pal_fade_control.active)
+        process_palfade();
+    else {
+        task_exec();
+        objc_exec();
+        obj_sync_superstate();
+        tilemaps_sync();
+        remoboxes_upload_tilesets();
+    }
+}
+
+void pdex_vram_free_bgmaps(void) {
+    for (u8 i = 0; i < 3; ++i) {
+        void *tmap = bgid_get_tilemap(i);
+        if (tmap != NULL) {
+            free(tmap);
+            bgid_nullify_tilemap(i);
+        }
+    }
+}
+
+struct PdexLookup *pdex_fill_lookup(u16 dexIndex) {
+    u16 species = pokedex_index_to_species(dexIndex);
+    pokedex_context->lookup[dexIndex].species = species;
+    pokedex_context->lookup[dexIndex].seen = dex_flag_pokedex_index(dexIndex, DEX_FLAG_CHECK_SEEN);
+    pokedex_context->lookup[dexIndex].caught = dex_flag_pokedex_index(dexIndex, DEX_FLAG_CHECK_CAUGHT);
+    return &pokedex_context->lookup[dexIndex];
+}
+
+struct PdexLookup *pdex_lazy_lookup_entry(u16 dexIndex) {
+    if (pokedex_context->lookup[dexIndex].species != -1) {
+        return &pokedex_context->lookup[dexIndex];
+    } else {
+        return pdex_fill_lookup(dexIndex);
+    }
+}
+
+void pdex_free_memory(void) {
+    if (pokedex_context->lookup != NULL)
+        free(pokedex_context->lookup);
+    free(pokedex_context);
+}
+
+void pdex_alloc_memory(void) {
+    pokedex_context = malloc_and_clear(sizeof(struct PdexCtx));
+    pokedex_context->lookup = malloc_and_clear((PDEX_LAST_ENTRY + 1) * sizeof(struct PdexLookup));
+    memset(pokedex_context->lookup, 0xFF, (PDEX_LAST_ENTRY + 1) * sizeof(struct PdexLookup));
+}
+
+void pdex_vram_allocate_bgmaps(void) {
+    bgid_set_tilemap(0, malloc(0x800));
+    bgid_set_tilemap(1, malloc(0x800));
+    bgid_set_tilemap(2, malloc(0x800));
+}
+
+void pdex_vram_setup(void) {
+    vblank_handler_set(NULL);
+    pal_fade_control_and_dead_struct_reset();
+    gpu_tile_bg_drop_all_sets(true);
+    obj_and_aux_reset_all();
+    gpu_tile_obj_tags_reset();
+    gpu_pal_allocator_reset();
+    rboxes_free();
+    tasks_init();
+    bg_vram_setup(0, &pdex_bg_config[0], 4);
+    u32 set = 0;
+    CpuFastSet((void *)&set, (void *)0x06000000, CPUModeFS(0x10000, CPUFSSET));
+
+    bgid_mod_x_offset(0, 0, 0);
+    bgid_mod_y_offset(0, 0, 0);
+    bgid_mod_x_offset(1, 0, 0);
+    bgid_mod_y_offset(1, 0, 0);
+    bgid_mod_x_offset(2, 0, 0);
+    bgid_mod_y_offset(2, 0, 0);
+    bgid_mod_x_offset(3, 0, 0);
+    bgid_mod_y_offset(3, 0, 0);
+
+    vblank_handler_set(pdex_vblank_handler);
+    interrupts_enable(INTERRUPT_VBLANK);
+    pdex_vram_allocate_bgmaps();
+}

src/pokedex/pokedex_common.h

@@ -0,0 +1,69 @@
+#ifndef PDEX_C_H_
+#define PDEX_C_H_
+
+#include <pokeagb/pokeagb.h>
+
+#define PDEX_ALOLA_COUNT (18)
+#define PDEX_LAST_ENTRY (813 + PDEX_ALOLA_COUNT)
+#define PDEX_LAST_SHOWN (813)
+
+#define CPUFSCPY 0
+#define CPUFSSET 1
+#define CPUModeFS(size, mode) ((size >> 2) | (mode << 24))
+#define MAX3_COUNT_DIGITS(n) (n >= 100 ? 3 : (n >= 10 ? 2 : 1))
+
+#define OBJID_HIDE(objid) objects[objid].final_oam.affine_mode = 2
+#define OBJID_SHOW(objid) objects[objid].final_oam.affine_mode = 0
+
+#define PDEX_FADEIN_SPD 1
+
+#define FONT_DEX_STD 1
+
+#define TB_STD_LEN 10
+#define TB_STD_LEN_PX (TB_STD_LEN * 8)
+#define TB_BOT_LEN 9
+#define TB_BOT_LEN_PX (TB_BOT_LEN * 8)
+
+#define TB_STD_CENTER(t,w) (((w - t) >> 1) + 2)
+#define TB_STD_RIGHT(t,w) ((w - t))
+
+#define DEX_PKMN_TAG 0x1300
+#define DEX_BALL_TAG 0x1301
+#define DEX_CURSOR_TAG 0x1302
+#define DEX_ARROW_TAG 0x1303
+#define DEX_ARROW_TAG_EPAL 0x1304
+#define DEX_SCROLL_TAG 0x1305
+#define DEX_REGION_SELECT 0x1306
+#define DEX_DETAIL_TYPE1 0x130E
+#define DEX_DETAIL_TYPE2 0x130F
+#define DEX_DETAIL_TYPEPAL 0x130E
+
+#define DEX_REGION_PAL(i) (0x1307 + i)
+#define DEX_REGION_ICON(i) (0x1307 + i)
+#define MAX_FORMS 7
+#define FORM_COUNT 20
+
+struct DexForm
+{
+    u16 index;
+    struct DexFormEntry forms[MAX_FORMS];
+};
+
+void pdex_cb_handler(void);
+void pdex_vblank_handler(void);
+void pdex_vram_setup(void);
+void pdex_vram_free_bgmaps(void);
+void pdex_free_memory(void);
+void pdex_alloc_memory(void);
+struct PdexLookup *pdex_lazy_lookup_entry(u16 dexIndex);
+void pdex_load(void);
+
+const u16 pdex_text_pal[16];
+const struct BgConfig pdex_bg_config[4];
+struct TextColor pdex_text_color;
+const struct OamData pdex_oam_pkmn;
+struct DexForm pdex_forms[FORM_COUNT];
+
+u8 pstr_lines(pchar* str);
+
+#endif

src/pokedex/pokedex_detail.c

@@ -0,0 +1,367 @@
+#include <agb_debug.h>
+#include <pokeagb/pokeagb.h>
+#include <pokedex/pdexArrowRotated.h>
+#include <pokedex/pdexDetailBg.h>
+
+#include "pokedex_common.h"
+
+#define TB_PKNAME 0
+#define TB_PKSIZE 1
+#define TB_DESC 2
+
+#define TB_PKNAME_W 30
+#define TB_SW_W 12
+
+extern pchar pdex_entry_debug[];
+extern pchar pdex_str_size[];
+extern pchar pdex_str_weight[];
+extern pchar pdex_str_size_unit[];
+extern pchar pdex_str_weight_unit[];
+extern pchar pdex_str_comma[];
+
+struct TextboxTemplate dexdetail_boxes[] = {
+    {.bg_id = 0, .x = 0, .y = 0, .width = TB_PKNAME_W, .height = 4, .pal_id = 15, .charbase = 1},
+    {.bg_id = 0, .x = 17, .y = 5, .width = TB_SW_W, .height = 4, .pal_id = 15, .charbase = 121},
+    {.bg_id = 1, .x = 1, .y = 0, .width = 28, .height = 20, .pal_id = 15, .charbase = 161},
+
+    {.bg_id = 0xFF},
+};
+
+u8 dexdetail_type_to_oam_type[18] = {0, 9, 8, 12, 6, 5, 11, 10, 14, 17, 1, 2, 3, 4, 13, 7, 16, 15};
+
+#define O_TYPE(t) (dexdetail_type_to_oam_type[t])
+
+struct OamData dexdetail_type_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 1,
+    .size = 2,
+};
+
+void dexdetail_update_type_oam(u8 type, struct Object *obj) {
+    memcpy((void *)((0x06010000) + (obj->final_oam.tile_num * 0x20)),
+           pokemon_type_chart_gfx + (128 * O_TYPE(type)) + (512 * (O_TYPE(type) >> 2)), 128);
+    memcpy((void *)((0x06010000) + 128 + (obj->final_oam.tile_num * 0x20)),
+           pokemon_type_chart_gfx + 512 + (128 * O_TYPE(type)) + (512 * (O_TYPE(type) >> 2)), 128);
+}
+
+s8 dexdetail_load_type_oam(u8 type, u16 tag) {
+    struct SpriteTiles typeTiles = {(&pokemon_type_chart_gfx[0]) + 256 * O_TYPE(type), 256, tag};
+    gpu_tile_obj_alloc_tag_and_upload(&typeTiles);
+    const struct Template typeTemplate = {
+        .tiles_tag = tag,
+        .pal_tag = DEX_DETAIL_TYPEPAL,
+        .oam = &dexdetail_type_oam,
+        .animation = &anim_image_empty,
+        .graphics = &typeTiles,
+        .rotscale = &rotscale_empty,
+        .callback = oac_nullsub,
+    };
+    s8 id = (s8)template_instanciate_forward_search(&typeTemplate, 100, 100, 0);
+    dexdetail_update_type_oam(type, &objects[id]);
+    return id;
+}
+
+extern pchar pdex_str_form_alola[];
+
+void dexdetail_load_pokemon(u16 dexindex, enum DexFormType formType) {
+    u16 species = pdex_lazy_lookup_entry(dexindex)->species;
+    rboxid_clear_pixels(TB_PKNAME, 0);
+    rboxid_clear_pixels(TB_PKSIZE, 0);
+    rboxid_clear_pixels(TB_DESC, 0);
+    pstrcpy(string_buffer, &pokemon_names[species][0]);
+    switch (formType) {
+    case ALOLA:
+        pstrcat(string_buffer, pdex_str_form_alola);
+        break;
+    default:
+        break;
+    }
+    u16 twidth = font_get_width_of_string(FONT_DEX_STD, string_buffer, 0x0000);
+    rboxid_print(TB_PKNAME, FONT_DEX_STD, TB_STD_CENTER(twidth, 8 * TB_PKNAME_W), 0, &pdex_text_color, 0,
+                 string_buffer);
+
+    pchar *strType = &pokedex_data[dexindex].category_name[0];
+    u16 typeTwidth = font_get_width_of_string(FONT_DEX_STD, strType, 0x0000);
+    rboxid_print(TB_PKNAME, FONT_DEX_STD, TB_STD_CENTER(typeTwidth, 88) + 110, 14, &pdex_text_color, 0, strType);
+    rboxid_print(TB_PKSIZE, FONT_DEX_STD, 4, 1, &pdex_text_color, 0, pdex_str_size);
+    rboxid_print(TB_PKSIZE, FONT_DEX_STD, 4, 14, &pdex_text_color, 0, pdex_str_weight);
+
+    u16 weightNumber = pokedex_data[dexindex].weight / 10;
+    u16 weightDecimal = pokedex_data[dexindex].weight % 10;
+    pchar buffer[20];
+    fmt_int_10(string_buffer, weightNumber, 0, 3);
+    fmt_int_10(&buffer[0], weightDecimal, 0, 1);
+    pstrcat(string_buffer, pdex_str_comma);
+    pstrcat(string_buffer, buffer);
+    pstrcat(string_buffer, pdex_str_weight_unit);
+    u16 weightTwidth = font_get_width_of_string(FONT_DEX_STD, string_buffer, 0x0000);
+
+    rboxid_print(TB_PKSIZE, FONT_DEX_STD, TB_STD_RIGHT(weightTwidth, TB_SW_W * 8) - 6, 1, &pdex_text_color, 0,
+                 string_buffer);
+
+    u16 sizeNumber = pokedex_data[dexindex].height / 10;
+    u16 sizeDecimal = pokedex_data[dexindex].height % 10;
+    fmt_int_10(string_buffer, sizeNumber, 0, 3);
+    fmt_int_10(&buffer[0], sizeDecimal, 0, 1);
+    pstrcat(string_buffer, pdex_str_comma);
+    pstrcat(string_buffer, buffer);
+    pstrcat(string_buffer, pdex_str_size_unit);
+
+    rboxid_print(TB_PKSIZE, FONT_DEX_STD, TB_STD_RIGHT(weightTwidth, TB_SW_W * 8) - 6, 14, &pdex_text_color, 0,
+                 string_buffer);
+
+    rboxid_print(TB_DESC, FONT_DEX_STD, 3, 2, &pdex_text_color, 0, pokedex_data[dexindex].description1);
+
+    /* load the species sprite */
+    if (pokedex_context->detail_pokemon_oam != -1) {
+        lz77UnCompVram(
+            pokemon_graphics_front[species].data,
+            ((void *)(objects[pokedex_context->detail_pokemon_oam].final_oam.tile_num * 32) + ADDR_VRAM + 0x10000));
+        gpu_pal_apply_compressed(pokemon_palette_normal[species].data,
+                                 16 * (objects[pokedex_context->detail_pokemon_oam].final_oam.palette_num + 16), 32);
+    } else {
+        struct SpriteTiles pkmnTiles = {pokemon_graphics_front[species].data, 2048, DEX_PKMN_TAG};
+        struct SpritePalette pkmnPal = {pokemon_palette_normal[species].data, DEX_PKMN_TAG};
+        const struct Template pkmnTemplate = {
+            .tiles_tag = DEX_PKMN_TAG,
+            .pal_tag = DEX_PKMN_TAG,
+            .oam = &pdex_oam_pkmn,
+            .animation = &anim_image_empty,
+            .graphics = &pkmnTiles,
+            .rotscale = &rotscale_empty,
+            .callback = oac_nullsub,
+        };
+        gpu_tile_obj_decompress_alloc_tag_and_upload(&pkmnTiles);
+
+        gpu_pal_decompress_alloc_tag_and_upload(&pkmnPal);
+        pokedex_context->detail_pokemon_oam = (s8)template_instanciate_forward_search(&pkmnTemplate, 10, 10, 0);
+
+        objects[pokedex_context->detail_pokemon_oam].pos1.x = 55;
+        objects[pokedex_context->detail_pokemon_oam].pos1.y = 55;
+    }
+
+    // draw the first type icon
+    if (pokedex_context->detail_type_oam[0] != -1) {
+        dexdetail_update_type_oam(pokemon_base_stats[species].type[0], &objects[pokedex_context->detail_type_oam[0]]);
+    } else {
+        pokedex_context->detail_type_oam[0] =
+            dexdetail_load_type_oam(pokemon_base_stats[species].type[0], DEX_DETAIL_TYPE1);
+        objects[pokedex_context->detail_type_oam[0]].pos1.x = 156;
+        objects[pokedex_context->detail_type_oam[0]].pos1.y = 80;
+    }
+    // draw the second type icon eventually
+    if (pokemon_base_stats[species].type[0] != pokemon_base_stats[species].type[1]) {
+        if (pokedex_context->detail_type_oam[1] != -1) {
+            dexdetail_update_type_oam(pokemon_base_stats[species].type[1],
+                                      &objects[pokedex_context->detail_type_oam[1]]);
+        } else {
+            pokedex_context->detail_type_oam[1] =
+                dexdetail_load_type_oam(pokemon_base_stats[species].type[1], DEX_DETAIL_TYPE2);
+            objects[pokedex_context->detail_type_oam[1]].pos1.x = 210;
+            objects[pokedex_context->detail_type_oam[1]].pos1.y = 80;
+        }
+        OBJID_SHOW(pokedex_context->detail_type_oam[1]);
+    } else {
+        OBJID_HIDE(pokedex_context->detail_type_oam[1]);
+    }
+    rboxid_update_tilemap_and_tileset(TB_DESC);
+    rboxid_update_tilemap_and_tileset(TB_PKNAME);
+    rboxid_update_tilemap_and_tileset(TB_PKSIZE);
+}
+
+void dexdetail_update_form(u16 form) {
+    REG_DISPCNT &= ~((1 << 8) | (1 << 9));
+    if (form == 0) {
+        dexdetail_load_pokemon(pokedex_context->cursor_position_top + pokedex_context->cursor_position_internal,
+                               NORMAL);
+    } else {
+        form--;
+        if (pokedex_context->detail_forms[form].index > PDEX_LAST_SHOWN) {
+            dexdetail_load_pokemon(pokedex_context->detail_forms[form].index, pokedex_context->detail_forms[form].type);
+        } else {
+            // update the oam only
+            u16 species = pokedex_context->detail_forms[form].species;
+            lz77UnCompVram(
+                pokemon_graphics_front[species].data,
+                ((void *)(objects[pokedex_context->detail_pokemon_oam].final_oam.tile_num * 32) + ADDR_VRAM + 0x10000));
+            gpu_pal_apply_compressed(pokemon_palette_normal[species].data,
+                                     16 * (objects[pokedex_context->detail_pokemon_oam].final_oam.palette_num + 16),
+                                     32);
+        }
+    }
+    REG_DISPCNT |= ((1 << 8) | (1 << 9));
+}
+
+struct DexFormEntry *dexdetail_get_forms(u16 index) {
+    u16 current = 0;
+    while (pdex_forms[current].index != 0xFFFF) {
+        if (pdex_forms[current].index == index)
+            return &pdex_forms[current].forms[0];
+        current++;
+    }
+    return NULL;
+}
+
+void dexdetail_oac_arrow(struct Object *obj) {
+    if (pokedex_context->detail_forms != NULL) {
+        if (obj->priv[0]) {
+            // this is the left arrow
+            if (pokedex_context->detail_form_position != 0) {
+                obj->final_oam.palette_num = obj->priv[1];
+            } else {
+                obj->final_oam.palette_num = obj->priv[2];
+            }
+        } else {
+            // this is the right arrow
+            if (pokedex_context->detail_forms[pokedex_context->detail_form_position].type != FORM_END) {
+                obj->final_oam.palette_num = obj->priv[1];
+            } else {
+                obj->final_oam.palette_num = obj->priv[2];
+            }
+        }
+    }
+}
+
+struct SpriteTiles pdex_arrow_rot_tiles = {pdexArrowRotatedTiles, 256, DEX_ARROW_TAG};
+struct SpritePalette pdex_arrow_rot_pal = {pdexArrowRotatedPal, DEX_ARROW_TAG};
+struct SpritePalette pdex_arrow_rot_pal_gray = {pdexArrowRotatedPal, DEX_ARROW_TAG_EPAL};
+
+const struct OamData pdex_arrow_rot_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 1,
+};
+
+const struct Template pdex_arrow_rot_template = {
+    .tiles_tag = DEX_ARROW_TAG,
+    .pal_tag = DEX_ARROW_TAG,
+    .oam = &pdex_arrow_rot_oam,
+    .animation = &anim_image_empty,
+    .graphics = &pdex_arrow_rot_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = dexdetail_oac_arrow,
+};
+
+void dexdetail_load_form_arrows(void) {
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&pdex_arrow_rot_tiles);
+    u8 normalPal = gpu_pal_obj_alloc_tag_and_apply(&pdex_arrow_rot_pal);
+    u8 grayPal = gpu_pal_obj_alloc_tag_and_apply(&pdex_arrow_rot_pal_gray);
+    tint_palette_gray(&palette_bg_unfaded[16 * (16 + grayPal)], 16);
+    u8 leftArrow = template_instanciate_forward_search(&pdex_arrow_rot_template, 20, 80, 0);
+    u8 rightArrow = template_instanciate_forward_search(&pdex_arrow_rot_template, 80, 80, 0);
+    objects[leftArrow].priv[0] = true;
+    objects[leftArrow].final_oam.h_flip = true;
+    objects[leftArrow].priv[1] = normalPal;
+    objects[leftArrow].priv[2] = grayPal;
+    objects[rightArrow].priv[0] = false;
+    objects[rightArrow].priv[1] = normalPal;
+    objects[rightArrow].priv[2] = grayPal;
+    pokedex_context->detail_arrows_oam[0] = leftArrow;
+    pokedex_context->detail_arrows_oam[1] = rightArrow;
+}
+
+void dexdetail_loop(u8 tid) {
+    (void)tid;
+    switch (pokedex_context->state) {
+    case 0:
+        bgid_send_tilemap(2);
+        u16 currentIndex = pokedex_context->cursor_position_top + pokedex_context->cursor_position_internal;
+        dexdetail_load_form_arrows();
+        dexdetail_load_pokemon(currentIndex, NORMAL);
+        pokedex_context->detail_form_position = 0;
+        struct DexFormEntry *forms = dexdetail_get_forms(currentIndex);
+        if (forms != NULL) {
+            OBJID_SHOW(pokedex_context->detail_arrows_oam[0]);
+            OBJID_SHOW(pokedex_context->detail_arrows_oam[1]);
+        } else {
+            OBJID_HIDE(pokedex_context->detail_arrows_oam[0]);
+            OBJID_HIDE(pokedex_context->detail_arrows_oam[1]);
+        }
+        dprintf("test: %d", pokedex_index_to_species(1000));
+        pokedex_context->detail_forms = forms;
+
+        palette_bg_faded_fill_black();
+        pokedex_context->state++;
+        break;
+    case 1:
+        gpu_sync_bg_show(0);
+        gpu_sync_bg_show(1);
+        gpu_sync_bg_hide(3);
+
+        gpu_sync_bg_show(2);
+        fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 16, 0, 0x0000);
+        pokedex_context->state++;
+        break;
+    case 2:
+        switch (super.buttons_new) {
+        case KEY_B:
+            pokedex_context->state = 12;
+            u16 dexindex = pokedex_context->cursor_position_top + pokedex_context->cursor_position_internal;
+            if (dexindex <= PDEX_LAST_SHOWN - 7) {
+                pokedex_context->cursor_position_top = dexindex;
+                pokedex_context->cursor_position_internal = 0;
+            } else {
+                pokedex_context->cursor_position_top = PDEX_LAST_SHOWN - 7;
+                pokedex_context->cursor_position_internal = (dexindex - pokedex_context->cursor_position_top);
+            }
+
+            fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 0, 16, 0x0000);
+            break;
+        case KEY_LEFT:
+            if (pokedex_context->detail_form_position != 0) {
+                pokedex_context->detail_form_position--;
+                dexdetail_update_form(pokedex_context->detail_form_position);
+            }
+            break;
+        case KEY_RIGHT:
+            if (pokedex_context->detail_forms[pokedex_context->detail_form_position].type != FORM_END) {
+                pokedex_context->detail_form_position++;
+                dexdetail_update_form(pokedex_context->detail_form_position);
+            }
+            break;
+        }
+        break;
+    case 12:
+        if (!pal_fade_control.active) {
+            task_del(tid);
+            pdex_vram_free_bgmaps();
+            set_callback2(pdex_load);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+struct SpritePalette dexdetail_type_pal = {&pokemon_type_chart_pal[0], DEX_DETAIL_TYPEPAL};
+
+void dexdetail_load_gfx(void) {
+    rbox_init_from_templates(&dexdetail_boxes[0]);
+    lz77UnCompVram(pdexDetailBgTiles, (void *)0x0600C000);
+    LZ77UnCompWram(pdexDetailBgMap, bgid_get_tilemap(2));
+    gpu_pal_apply_compressed(pdexDetailBgPal, 0, 32);
+    gpu_pal_apply(pdex_text_pal, 15 * 16, 32);
+    gpu_pal_obj_alloc_tag_and_apply(&dexdetail_type_pal);
+
+    lcd_io_set(REG_ID_WIN0H, (8 << 8) | (232));
+    lcd_io_set(REG_ID_WIN0V, ((100 << 8) | (160)));
+    lcd_io_set(REG_ID_WININ, WIN_BG0 | WIN_BG1 | WIN_BG2 | WIN_BG3 | WIN_OBJ);
+    lcd_io_set(REG_ID_WINOUT, WIN_BG0 | WIN_BG2 | WIN_BG3 | WIN_OBJ);
+    bgid_mod_y_offset(1, -24576, 1);
+    bgid_mark_for_sync(0);
+}
+
+void dexdetail_load(void) {
+    pdex_vram_setup();
+    dexdetail_load_gfx();
+    pokedex_context->state = 0;
+    pokedex_context->detail_pokemon_oam = -1;
+    pokedex_context->detail_type_oam[0] = -1;
+    pokedex_context->detail_type_oam[1] = -1;
+    task_add(dexdetail_loop, 0);
+    set_callback2(pdex_cb_handler);
+}

src/pokedex/pokedex_region.c

@@ -0,0 +1,231 @@
+#include <agb_debug.h>
+#include <constants/pkmns.h>
+#include <pokeagb/pokeagb.h>
+#include <pokeagb/core/m4a.h>
+#include <pokedex/pdexSelectBg.h>
+#include <pokedex/pdexSelectRegion.h>
+
+#include "pokedex_common.h"
+
+void region_select_load(void);
+extern const pchar *pdex_str_regions[];
+extern const pchar *pdex_str_empty;
+
+const u16 region_to_dex[] = {1, 152, 252, 393, 501, 656, 728};
+
+struct TextboxTemplate region_select_boxes[] = {
+    {.bg_id = 0, .x = 4, .y = 7, .width = 6, .height = 3, .pal_id = 15, .charbase = 1},
+    {.bg_id = 0, .x = 13, .y = 7, .width = 6, .height = 3, .pal_id = 15, .charbase = 19},
+    {.bg_id = 0, .x = 22, .y = 7, .width = 6, .height = 3, .pal_id = 15, .charbase = 38},
+
+    {.bg_id = 0, .x = 2, .y = 17, .width = 6, .height = 2, .pal_id = 15, .charbase = 57},
+    {.bg_id = 0, .x = 9, .y = 17, .width = 6, .height = 2, .pal_id = 15, .charbase = 69},
+    {.bg_id = 0, .x = 17, .y = 17, .width = 6, .height = 2, .pal_id = 15, .charbase = 81},
+    {.bg_id = 0, .x = 24, .y = 17, .width = 6, .height = 2, .pal_id = 15, .charbase = 93},
+
+    {.bg_id = 0xFF},
+};
+
+u8 region_text_x_offset[] = {2, 4, 2, 1, 5, 1, 4};
+u8 region_text_y_offset[] = {7, 7, 7, 2, 2, 2, 2};
+u8 region_select_x_offset[] = {54, 128, 198, 38, 97, 156, 215};
+u8 region_select_y_offset[] = {40, 40, 40, 115, 115, 115, 115};
+
+u16 region_icons[] = {PKMN_BISASAM,   PKMN_SCHIGGY, PKMN_GLUMANDA, PKMN_ENDIVIE, PKMN_KARNIMANI, PKMN_FEURIGEL,
+                      PKMN_GECKARBOR, PKMN_HYDROPI, PKMN_FLEMMLI,  PKMN_CHELAST, PKMN_PLINFA,    PKMN_PANFLAM,
+                      PKMN_SERPIFEU,  PKMN_OTTARO,  PKMN_FLOINK,   PKMN_IGAMARO, PKMN_FROXY,     PKMN_FYNX,
+                      PKMN_BAUZ,      PKMN_ROBBALL, PKMN_FLAMIAU};
+
+u16 region_icons_x_offset[] = {37, 49, 58, 110, 122, 133, 182, 193, 206, 22, 33,
+                               43, 80, 93, 103, 139, 150, 161, 196, 207, 219};
+
+u16 region_icons_y_offset[] = {39,  17,  39, 39,  19,  39, 39,  19,  39, 117, 94,
+                               116, 116, 95, 115, 116, 95, 116, 120, 99, 120};
+
+bool sm_pdex_init(void) {
+    if (pal_fade_control.active)
+        return false;
+    audioDampenMaybe();
+    sav1_secure_increment(0x29); // this is something the original dex routine does, probably for statistics
+    /* maybe clean up safari stuff here if necessary */
+    overworld_free_bgmaps();
+
+    malloc_init((void *)0x2000000, 0x1C000);
+    set_callback2(region_select_load);
+    return true;
+}
+
+void region_select_load_gfx() {
+    rbox_init_from_templates(&region_select_boxes[0]);
+    lz77UnCompVram(pdexSelectBgTiles, (void *)0x0600C000);
+    LZ77UnCompWram(pdexSelectBgMap, bgid_get_tilemap(2));
+    gpu_pal_apply_compressed(pdexSelectBgPal, 0, 32);
+    gpu_pal_apply(pdex_text_pal, 15 * 16, 32);
+    bgid_mark_for_sync(0);
+}
+
+void region_oac_select(struct Object *obj) {
+    obj->pos1.x = region_select_x_offset[pokedex_context->region_selected];
+    obj->pos1.y = region_select_y_offset[pokedex_context->region_selected];
+}
+
+struct SpriteTiles region_select_tiles = {pdexSelectRegionTiles, 2048, DEX_REGION_SELECT};
+struct SpritePalette region_select_pal = {pdexSelectRegionPal, DEX_REGION_SELECT};
+
+const struct OamData region_select_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 3,
+};
+
+struct Template region_select_template = {
+    .tiles_tag = DEX_REGION_SELECT,
+    .pal_tag = DEX_REGION_SELECT,
+    .oam = &region_select_oam,
+    .animation = &anim_image_empty,
+    .graphics = &region_select_tiles,
+    .rotscale = &rotscale_empty,
+    .callback = region_oac_select,
+};
+
+void region_load_icon_palettes(void) {
+    for (u8 i = 0; i < 3; ++i) {
+        struct SpritePalette current = {pokeicon_pals[i], DEX_REGION_PAL(i)};
+        gpu_pal_obj_alloc_tag_and_apply(&current);
+    }
+}
+
+const struct OamData region_icon_oam = {
+    .affine_mode = 0,
+    .obj_mode = 0,
+    .mosaic = false,
+    .shape = 0,
+    .size = 2,
+};
+
+void region_load_icon(u8 i) {
+    struct SpriteTiles current = {pokeicon_table[region_icons[i]], 512, DEX_REGION_ICON(i)};
+    gpu_tile_obj_alloc_tag_and_upload(&current);
+    struct Template region_icon_template = {
+        .tiles_tag = DEX_REGION_ICON(i),
+        .pal_tag = DEX_REGION_PAL(pokeicon_pal_indices[region_icons[i]]),
+        .oam = &region_icon_oam,
+        .animation = &anim_image_empty,
+        .graphics = &current,
+        .rotscale = &rotscale_empty,
+        .callback = oac_nullsub,
+    };
+    template_instanciate_forward_search(&region_icon_template, region_icons_x_offset[i], region_icons_y_offset[i], 0);
+}
+
+void region_load_border() {
+    gpu_tile_obj_decompress_alloc_tag_and_upload(&region_select_tiles);
+    gpu_pal_obj_alloc_tag_and_apply(&region_select_pal);
+    (void)template_instanciate_forward_search(&region_select_template, 100, 100, 0);
+}
+
+void region_loop(u8 tid) {
+    (void)tid;
+    switch (pokedex_context->state) {
+    case 0:
+        bgid_send_tilemap(2);
+
+        for (u8 i = 0; i < 7; ++i) {
+            rboxid_clear_pixels(i, 0);
+            rboxid_print(i, FONT_DEX_STD, region_text_x_offset[i], region_text_y_offset[i], &pdex_text_color, 0,
+                         pdex_str_regions[i + 1]);
+            rboxid_update_tilemap_and_tileset(i);
+        }
+
+        region_load_border();
+        region_load_icon_palettes();
+        for (u8 i = 0; i < 21; ++i)
+            region_load_icon(i);
+
+        palette_bg_faded_fill_black();
+        pokedex_context->state++;
+        break;
+    case 1:
+        gpu_sync_bg_show(0);
+        gpu_sync_bg_hide(1);
+        gpu_sync_bg_hide(3);
+
+        gpu_sync_bg_show(2);
+        fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 16, 0, 0x0000);
+        pokedex_context->state++;
+        break;
+    case 2:
+        if (!pal_fade_control.active)
+            pokedex_context->state++;
+        break;
+    case 3:
+        switch (super.buttons_new) {
+        case KEY_RIGHT:
+            if (pokedex_context->region_selected < 6) {
+                pokedex_context->region_selected++;
+                m4aSongNumStart(101);
+            }
+            break;
+        case KEY_DOWN:
+            if (pokedex_context->region_selected < 3) {
+                pokedex_context->region_selected += 3;
+                m4aSongNumStart(101);
+            }
+            break;
+        case KEY_LEFT:
+            if (pokedex_context->region_selected > 0) {
+                pokedex_context->region_selected--;
+                m4aSongNumStart(101);
+            }
+            break;
+        case KEY_UP:
+            if ((pokedex_context->region_selected > 2) && (pokedex_context->region_selected < 6)) {
+                pokedex_context->region_selected -= 3;
+                m4aSongNumStart(101);
+            }
+            break;
+        case KEY_A:
+            fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 0, 16, 0x0000);
+            pokedex_context->state = 10;
+            m4aSongNumStart(5);
+            break;
+        case KEY_B:
+            fade_screen(0xFFFFFFFF, PDEX_FADEIN_SPD, 0, 16, 0x0000);
+            pokedex_context->state = 11;
+            m4aSongNumStart(601);
+        default:
+            break;
+        }
+        break;
+    case 10:
+        if (!pal_fade_control.active) {
+            task_del(tid);
+            pdex_vram_free_bgmaps();
+            pokedex_context->cursor_position_top = region_to_dex[pokedex_context->region_selected];
+            set_callback2(pdex_load);
+        }
+        break;
+    case 11:
+        if (!pal_fade_control.active) {
+            task_del(tid);
+            pdex_free_memory();
+            set_callback2(c2_overworld_switch_start_menu);
+            set_callback1(c1_overworld);
+        }
+        break;
+    default:
+
+        break;
+    }
+}
+
+void region_select_load(void) {
+    pdex_vram_setup();
+    pdex_alloc_memory();
+
+    region_select_load_gfx();
+    task_add(region_loop, 0);
+    set_callback2(pdex_cb_handler);
+}

src/pokedex/pokedex_string.s

@@ -0,0 +1,97 @@
+.align 2
+.thumb
+.text
+.global pdex_str_title
+pdex_str_title:
+    .string LAN_DE "Amitec Pokédex"
+    .string LAN_EN "Amitec Pokédex"
+
+.global pdex_str_seen
+pdex_str_seen:
+    .string LAN_DE "Ges.:"
+    .string LAN_EN "Seen:"
+
+.global pdex_str_caught
+pdex_str_caught:
+    .string LAN_DE "Gef.:"
+    .string LAN_EN "Caught:"
+
+.global pdex_str_size
+pdex_str_size:
+    .string LAN_DE "Größe:"
+    .string LAN_EN "Size:"
+
+.global pdex_str_weight
+pdex_str_weight:
+    .string LAN_DE "Gewicht:"
+    .string LAN_EN "Weight:"
+
+.global pdex_str_size_unit
+pdex_str_size_unit:
+    .string LAN_DE "m"
+    .string LAN_EN "m"
+
+.global pdex_str_weight_unit
+pdex_str_weight_unit:
+    .string LAN_DE "kg"
+    .string LAN_EN "kg"
+
+.global pdex_str_comma
+pdex_str_comma:
+    .string LAN_DE ","
+    .string LAN_EN ","
+
+.global pdex_str_empty
+pdex_str_empty:
+    .string LAN_DE "----------"
+    .string LAN_EN "----------"
+
+.global pdex_str_form_alola
+pdex_str_form_alola:
+    .string LAN_DE " (Alola)"
+    .string LAN_DE " (Alola)"
+
+.align 2
+.global pdex_str_regions
+pdex_str_regions:
+.word pdex_str_empty
+.word pdex_str_kanto
+.word pdex_str_jotho
+.word pdex_str_hoeen
+.word pdex_str_sinnoh
+.word pdex_str_unova
+.word pdex_str_kalos
+.word pdex_str_alola
+
+pdex_str_kanto:
+    .string LAN_DE "Kanto"
+    .string LAN_EN "Kanto"
+
+pdex_str_jotho:
+    .string LAN_DE "Johto"
+    .string LAN_EN "Johto"
+
+pdex_str_hoeen:
+    .string LAN_DE "Hoenn"
+    .string LAN_EN "Hoenn"
+
+pdex_str_sinnoh:
+    .string LAN_DE "Sinnoh"
+    .string LAN_EN "Sinnoh"
+
+pdex_str_unova:
+    .string LAN_DE "Einall"
+    .string LAN_EN " Unova"
+
+pdex_str_kalos:
+    .string LAN_DE "Kalos"
+    .string LAN_EN "Kalos"
+
+pdex_str_alola:
+    .string LAN_DE "Alola"
+    .string LAN_EN "Alola"
+
+.global pdex_entry_debug
+pdex_entry_debug:
+    .string LAN_DE "Glurak fliegt durch die Lüfte, um starke\nGegner aufzuspüren. Sein heißer Feuer-\natem bringt alles zum Schmelzen.\nAber es richtet seinen Feueratem nie auf\nschwächere Gegner."
+    .string LAN_EN "Glurak fliegt durch die Lüfte, um starke Gegner aufzuspüren.\nSein heißer Feueratem bringt alles zum Schmelzen.\nAber es richtet seinen Feueratem nie auf schwächere Gegner."