diff --git a/include/battle_bg.h b/include/battle_bg.h index 167ea5cf74..075159148d 100644 --- a/include/battle_bg.h +++ b/include/battle_bg.h @@ -1,6 +1,17 @@ #ifndef GUARD_BATTLE_BG_H #define GUARD_BATTLE_BG_H +#if P_ENABLE_DEBUG == TRUE +struct BattleBackground +{ + const void *tileset; + const void *tilemap; + const void *entryTileset; + const void *entryTilemap; + const void *palette; +}; +#endif + void BattleInitBgsAndWindows(void); void InitBattleBgsVideo(void); void LoadBattleMenuWindowGfx(void); diff --git a/include/constants/pokemon_config.h b/include/constants/pokemon_config.h index 6d45eb9be8..597b96f8ec 100644 --- a/include/constants/pokemon_config.h +++ b/include/constants/pokemon_config.h @@ -18,6 +18,8 @@ #define P_UPDATED_EGG_GROUPS GEN_8 // Since Gen 8, certain Pokémon have gained new egg groups. #define P_SHEDINJA_BALL GEN_8 // Since Gen 4, Shedinja requires a Poké Ball for its evolution. In Gen 3, Shedinja inherits Nincada's Ball. +#define P_ENABLE_DEBUG TRUE // Enables a debug menu for pokemon sprites and icons, accessed by pressing SELECT in the summary screen. + #ifndef ITEM_EXPANSION //Item Definitions for gEvolutionTable diff --git a/include/constants/pokemon_debug.h b/include/constants/pokemon_debug.h new file mode 100644 index 0000000000..c75392bf22 --- /dev/null +++ b/include/constants/pokemon_debug.h @@ -0,0 +1,53 @@ +#ifndef GUARD_CONSTANTS_POKEMON_DEBUG_H +#define GUARD_CONSTANTS_POKEMON_DEBUG_H + +//Defines +#define DEBUG_MON_BACK_X 62 +#define DEBUG_MON_BACK_Y 80 +#define DEBUG_ICON_X 220 +#define DEBUG_ICON_Y 140 +#define DEBUG_MON_SHINY 0 +#define DEBUG_MON_NORMAL 9 + +#define MODIFY_DIGITS_MAX 4 +#define MODIFY_DIGITS_ARROW_X 129 +#define MODIFY_DIGITS_ARROW1_Y 94 +#define MODIFY_DIGITS_ARROW2_Y 113 + +#define OPTIONS_ARROW_1_X 4 +#define OPTIONS_ARROW_2_X 236 +#define OPTIONS_ARROW_Y 119 + +#define GENDER_MALE 0 +#define GENDER_FEMALE 1 +#define MON_PIC_BACK 0 +#define MON_PIC_FRONT 1 + +//Sprite offset +#define MAX_Y_OFFSET 20 + +//Windows +#define WIN_NAME_NUMBERS 0 +#define WIN_INSTRUCTIONS 1 +#define WIN_BOTTOM_LEFT 2 +#define WIN_BOTTOM_RIGHT 3 +#define WIN_FOOTPRINT 4 +#define WIN_END 5 + +//Battle backgrounds +#define MAP_BATTLE_SCENE_NORMAL 0 +#define MAP_BATTLE_SCENE_GYM 1 +#define MAP_BATTLE_SCENE_MAGMA 2 +#define MAP_BATTLE_SCENE_AQUA 3 +#define MAP_BATTLE_SCENE_SIDNEY 4 +#define MAP_BATTLE_SCENE_PHOEBE 5 +#define MAP_BATTLE_SCENE_GLACIA 6 +#define MAP_BATTLE_SCENE_DRAKE 7 +#define MAP_BATTLE_SCENE_FRONTIER 8 +#define MAP_BATTLE_SCENE_LEADER 9 +#define MAP_BATTLE_SCENE_WALLACE 10 +#define MAP_BATTLE_SCENE_GROUDON 11 +#define MAP_BATTLE_SCENE_KYOGRE 12 +#define MAP_BATTLE_SCENE_RAYQUAZA 13 + +#endif // GUARD_CONSTANTS_POKEMON_DEBUG_H \ No newline at end of file diff --git a/include/decompress.h b/include/decompress.h index 81f1425010..0d5cb3b3d3 100644 --- a/include/decompress.h +++ b/include/decompress.h @@ -21,6 +21,7 @@ void DecompressPicFromTable(const struct CompressedSpriteSheet *src, void* buffe void DecompressPicFromTableGender(void* buffer, s32 species, u32 personality); void HandleLoadSpecialPokePic(const struct CompressedSpriteSheet *src, void *dest, s32 species, u32 personality); +void HandleLoadSpecialPokePicCustom(const struct CompressedSpriteSheet *src, void *dest, s32 species, u32 personality, bool8 isFemale); void LoadSpecialPokePic(const struct CompressedSpriteSheet *src, void *dest, s32 species, u32 personality, bool8 isFrontPic); diff --git a/include/pokedex.h b/include/pokedex.h index 49063f6b13..703b9ab8df 100644 --- a/include/pokedex.h +++ b/include/pokedex.h @@ -4,6 +4,10 @@ extern u8 gUnusedPokedexU8; extern void (*gPokedexVBlankCB)(void); +#if P_ENABLE_DEBUG == TRUE +extern const u8 *const gMonFootprintTable[]; +#endif + enum { DEX_MODE_HOENN, diff --git a/include/pokemon.h b/include/pokemon.h index 3d6f0bd27d..478f9b974c 100644 --- a/include/pokemon.h +++ b/include/pokemon.h @@ -8,6 +8,7 @@ #include "constants/map_groups.h" #define GET_BASE_SPECIES_ID(speciesId) (GetFormSpeciesId(speciesId, 0)) +#define FORM_SPECIES_END (0xffff) struct PokemonSubstruct0 { @@ -302,6 +303,7 @@ extern const u8 gStatStageRatios[MAX_STAT_STAGE + 1][2]; extern const u16 gLinkPlayerFacilityClasses[]; extern const struct SpriteTemplate gBattlerSpriteTemplates[]; extern const s8 gNatureStatTable[][5]; +extern const u16 *const gFormSpeciesIdTables[NUM_SPECIES]; void ZeroBoxMonData(struct BoxPokemon *boxMon); void ZeroMonData(struct Pokemon *mon); diff --git a/include/pokemon_debug.h b/include/pokemon_debug.h new file mode 100644 index 0000000000..e69b4a7c6b --- /dev/null +++ b/include/pokemon_debug.h @@ -0,0 +1,73 @@ +#ifndef GUARD_POKEMON_DEBUG_H +#define GUARD_POKEMON_DEBUG_H + +#include "constants/pokemon_debug.h" + +//Structs +struct PokemonDebugModifyArrows +{ + u8 arrowSpriteId[2]; + u16 minValue; + u16 maxValue; + int currValue; + u8 currentDigit; + u8 maxDigits; + u8 charDigits[MODIFY_DIGITS_MAX]; + void *modifiedValPtr; + u8 typeOfVal; +}; + +struct PokemonDebugOptionArrows +{ + u8 arrowSpriteId[1]; + u8 currentDigit; +}; + +struct PokemonDebugYPosModifiyArrows +{ + u8 arrowSpriteId[1]; + u8 currentDigit; +}; + +struct PokemonSpriteConstValues +{ + u8 backPicCoords; + u8 frontPicCoords; + u8 frontElevation; +}; + +struct PokemonSpriteOffsets +{ + s8 offset_back_picCoords; + s8 offset_front_picCoords; + s8 offset_front_elevation; +}; + +struct PokemonDebugMenu +{ + u16 currentmonId; + u8 currentmonWindowId; + u8 InstructionsWindowId; + u8 frontspriteId; + u8 backspriteId; + u8 iconspriteId; + u8 frontShadowSpriteId; + bool8 isShiny; + bool8 isFemale; + struct PokemonDebugModifyArrows modifyArrows; + struct PokemonDebugOptionArrows optionArrows; + struct PokemonDebugYPosModifiyArrows yPosModifyArrows; + struct PokemonSpriteConstValues constSpriteValues; + struct PokemonSpriteOffsets offsetsSpriteValues; + u8 animIdBack; + u8 animIdFront; + u8 battleBgType; + u8 battleTerrain; + u8 currentSubmenu; + u8 submenuYpos[3]; +}; + +void CB2_Debug_Pokemon(void); + + +#endif // GUARD_POKEMON_DEBUG_H \ No newline at end of file diff --git a/include/pokemon_icon.h b/include/pokemon_icon.h index fba6a6740a..952db1ed12 100644 --- a/include/pokemon_icon.h +++ b/include/pokemon_icon.h @@ -21,6 +21,7 @@ u8 CreateMonIconNoPersonality(u16 species, void (*callback)(struct Sprite *), s1 void FreeMonIconPalette(u16 species); void FreeAndDestroyMonIconSprite(struct Sprite *sprite); u8 CreateMonIcon(u16 species, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority, u32 personality); +u8 CreateMonIconCustom(u16 species, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority, u32 personality, bool8 isFemale, bool8 isShiny); u8 UpdateMonIconFrame(struct Sprite *sprite); void LoadMonIconPalette(u16 species); void SpriteCB_MonIcon(struct Sprite *sprite); diff --git a/include/reset_rtc_screen.h b/include/reset_rtc_screen.h index 5807dec992..f8904063b7 100644 --- a/include/reset_rtc_screen.h +++ b/include/reset_rtc_screen.h @@ -1,6 +1,9 @@ #ifndef GUARD_RESET_RTC_SCREEN_H #define GUARD_RESET_RTC_SCREEN_H +extern const struct SpritePalette sSpritePalette_Arrow; +extern const struct SpriteTemplate sSpriteTemplate_Arrow; + void CB2_InitResetRtcScreen(void); #endif // GUARD_RESET_RTC_SCREEN_H diff --git a/ld_script.txt b/ld_script.txt index 430b89ed26..33e46dd122 100644 --- a/ld_script.txt +++ b/ld_script.txt @@ -329,6 +329,7 @@ SECTIONS { src/gym_leader_rematch.o(.text); src/battle_transition_frontier.o(.text); src/international_string_util.o(.text); + src/pokemon_debug.o(.text); } =0 script_data : @@ -689,6 +690,7 @@ SECTIONS { data/mystery_gift.o(.rodata); src/m4a_tables.o(.rodata); data/sound_data.o(.rodata); + src/pokemon_debug.o(.rodata); } =0 song_data : diff --git a/src/battle_anim_mons.c b/src/battle_anim_mons.c index 3b6cc0e918..adc664c3a3 100644 --- a/src/battle_anim_mons.c +++ b/src/battle_anim_mons.c @@ -35,7 +35,11 @@ static void CreateBattlerTrace(struct Task *task, u8 taskId); EWRAM_DATA static union AffineAnimCmd *sAnimTaskAffineAnim = NULL; +#if P_ENABLE_DEBUG == TRUE +const struct UCoords8 sBattlerCoords[][MAX_BATTLERS_COUNT] = +#else static const struct UCoords8 sBattlerCoords[][MAX_BATTLERS_COUNT] = +#endif { { // Single battle { 72, 80 }, @@ -60,7 +64,11 @@ const struct MonCoords gCastformFrontSpriteCoords[NUM_CASTFORM_FORMS] = [CASTFORM_ICE] = { .size = MON_COORDS_SIZE(64, 48), .y_offset = 8 }, }; +#if P_ENABLE_DEBUG == TRUE +const u8 sCastformElevations[NUM_CASTFORM_FORMS] = +#else static const u8 sCastformElevations[NUM_CASTFORM_FORMS] = +#endif { [CASTFORM_NORMAL] = 13, [CASTFORM_FIRE] = 14, diff --git a/src/battle_bg.c b/src/battle_bg.c index f739a002f6..9d9b26627d 100644 --- a/src/battle_bg.c +++ b/src/battle_bg.c @@ -24,6 +24,7 @@ #include "constants/songs.h" #include "constants/trainers.h" +#if !P_ENABLE_DEBUG struct BattleBackground { const void *tileset; @@ -32,6 +33,7 @@ struct BattleBackground const void *entryTilemap; const void *palette; }; +#endif // .rodata static const u16 sUnrefArray[] = {0x0300, 0x0000}; //OamData? @@ -598,7 +600,11 @@ const struct WindowTemplate * const gBattleWindowTemplates[] = [B_WIN_TYPE_ARENA] = gBattleArenaWindowTemplates, }; +#if P_ENABLE_DEBUG == TRUE +const struct BattleBackground sBattleTerrainTable[] = +#else static const struct BattleBackground sBattleTerrainTable[] = +#endif { [BATTLE_TERRAIN_GRASS] = { diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index 5667731e9e..57e5d87630 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -77,7 +77,11 @@ static const struct CompressedSpriteSheet sSpriteSheets_HealthBar[MAX_BATTLERS_C {gBlankGfxCompressed, 0x0120, TAG_HEALTHBAR_OPPONENT2_TILE} }; +#if P_ENABLE_DEBUG == TRUE +const struct SpritePalette sSpritePalettes_HealthBoxHealthBar[2] = +#else static const struct SpritePalette sSpritePalettes_HealthBoxHealthBar[2] = +#endif { {gBattleInterface_BallStatusBarPal, TAG_HEALTHBOX_PAL}, {gBattleInterface_BallDisplayPal, TAG_HEALTHBAR_PAL} diff --git a/src/data/pokemon/form_species_tables.h b/src/data/pokemon/form_species_tables.h index 89b3f4eec1..810da64997 100644 --- a/src/data/pokemon/form_species_tables.h +++ b/src/data/pokemon/form_species_tables.h @@ -1,5 +1,3 @@ -#define FORM_SPECIES_END (0xffff) - static const u16 sVenusaurFormSpeciesIdTable[] = { SPECIES_VENUSAUR, SPECIES_VENUSAUR_MEGA, diff --git a/src/decompress.c b/src/decompress.c index 418c5ea253..c20b6404cf 100644 --- a/src/decompress.c +++ b/src/decompress.c @@ -3,6 +3,7 @@ #include "data.h" #include "decompress.h" #include "pokemon.h" +#include "pokemon_debug.h" #include "text.h" EWRAM_DATA ALIGNED(4) u8 gDecompressionBuffer[0x4000] = {0}; @@ -113,6 +114,45 @@ void LoadSpecialPokePic(const struct CompressedSpriteSheet *src, void *dest, s32 DrawSpindaSpots(species, personality, dest, isFrontPic); } +#if P_ENABLE_DEBUG == TRUE +static void LoadSpecialPokePicCustom(const struct CompressedSpriteSheet *src, void *dest, s32 species, u32 personality, bool8 isFrontPic, bool8 isFemale) +{ + if (species == SPECIES_UNOWN) + { + u32 id = GetUnownSpeciesId(personality); + + if (!isFrontPic) + LZ77UnCompWram(gMonBackPicTable[id].data, dest); + else + LZ77UnCompWram(gMonFrontPicTable[id].data, dest); + } + else if (species > NUM_SPECIES) // is species unknown? draw the ? icon + LZ77UnCompWram(gMonFrontPicTable[0].data, dest); + else if (SpeciesHasGenderDifference[species] && isFemale) + { + if (isFrontPic) + LZ77UnCompWram(gMonFrontPicTableFemale[species].data, dest); + else + LZ77UnCompWram(gMonBackPicTableFemale[species].data, dest); + } + else + LZ77UnCompWram(src->data, dest); + + DrawSpindaSpots(species, personality, dest, isFrontPic); +} +void HandleLoadSpecialPokePicCustom(const struct CompressedSpriteSheet *src, void *dest, s32 species, u32 personality, bool8 isFemale) +{ + bool8 isFrontPic; + + if (src == &gMonFrontPicTable[species]) + isFrontPic = TRUE; // frontPic + else + isFrontPic = FALSE; // backPic + + LoadSpecialPokePicCustom(src, dest, species, personality, isFrontPic, isFemale); +} +#endif + void Unused_LZDecompressWramIndirect(const void **src, void *dest) { LZ77UnCompWram(*src, dest); diff --git a/src/pokemon.c b/src/pokemon.c index 0b1b97d151..be12af70e9 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -1856,8 +1856,11 @@ const s8 gNatureStatTable[NUM_NATURES][NUM_NATURE_STATS] = #include "data/pokemon/form_change_table_pointers.h" // SPECIES_NONE are ignored in the following two tables, so decrement before accessing these arrays to get the right result - +#if P_ENABLE_DEBUG == TRUE +const u8 sMonFrontAnimIdsTable[NUM_SPECIES - 1] = +#else static const u8 sMonFrontAnimIdsTable[NUM_SPECIES - 1] = +#endif { [SPECIES_BULBASAUR - 1] = ANIM_V_JUMPS_H_JUMPS, [SPECIES_IVYSAUR - 1] = ANIM_V_STRETCH, diff --git a/src/pokemon_debug.c b/src/pokemon_debug.c new file mode 100644 index 0000000000..ef440611c7 --- /dev/null +++ b/src/pokemon_debug.c @@ -0,0 +1,1744 @@ +//Credits: Gamer2020, AsparagusEduardo, TheXaman, ShinyDragonHunter +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "battle_gfx_sfx_util.h" +#include "bg.h" +#include "constants/rgb.h" +#include "constants/songs.h" +#include "data.h" +#include "decompress.h" +#include "field_weather.h" +#include "gpu_regs.h" +#include "graphics.h" +#include "item.h" +#include "item_icon.h" +#include "list_menu.h" +#include "m4a.h" +#include "main.h" +#include "malloc.h" +#include "menu.h" +#include "overworld.h" +#include "palette.h" +#include "palette_util.h" +#include "pokedex.h" +#include "pokemon.h" +#include "pokemon_animation.h" +#include "pokemon_debug.h" +#include "pokemon_icon.h" +#include "reset_rtc_screen.h" +#include "scanline_effect.h" +#include "script.h" +#include "script_pokemon_util.h" +#include "sound.h" +#include "string_util.h" +#include "strings.h" +#include "task.h" +#include "text_window.h" +#include "trainer_pokemon_sprites.h" + +#include "constants/items.h" + +#if P_ENABLE_DEBUG == TRUE +extern const struct BattleBackground sBattleTerrainTable[]; +extern const struct CompressedSpriteSheet gSpriteSheet_EnemyShadow; +extern const struct SpriteTemplate gSpriteTemplate_EnemyShadow; +extern const struct SpritePalette sSpritePalettes_HealthBoxHealthBar[2]; +extern const struct UCoords8 sBattlerCoords[][MAX_BATTLERS_COUNT] ; +extern const struct MonCoords gCastformFrontSpriteCoords[NUM_CASTFORM_FORMS]; +extern const u8 sCastformElevations[NUM_CASTFORM_FORMS]; +extern const u8 sMonFrontAnimIdsTable[NUM_SPECIES - 1]; +static const u16 sBgColor[] = {RGB_WHITE}; + +static struct PokemonDebugMenu *GetStructPtr(u8 taskId) +{ + u8 *taskDataPtr = (u8*)(&gTasks[taskId].data[0]); + + return (struct PokemonDebugMenu*)(T1_READ_PTR(taskDataPtr)); +} + +//BgTemplates +static const struct BgTemplate sBgTemplates[] = +{ + { + .bg = 0, + .charBaseIndex = 0, + .mapBaseIndex = 24, + .screenSize = 2, + .paletteMode = 0, + .priority = 0, + .baseTile = 0 + }, + { + .bg = 1, + .charBaseIndex = 1, + .mapBaseIndex = 28, + .screenSize = 2, + .paletteMode = 0, + .priority = 0, + .baseTile = 0 + }, + { + .bg = 2, + .charBaseIndex = 1, + .mapBaseIndex = 30, + .screenSize = 1, + .paletteMode = 0, + .priority = 1, + .baseTile = 0 + }, + { + .bg = 3, + .charBaseIndex = 2, + .mapBaseIndex = 26, + .screenSize = 1, + .paletteMode = 0, + .priority = 3, + .baseTile = 0 + }, +}; + +//WindowTemplates +static const struct WindowTemplate sPokemonDebugWindowTemplate[] = +{ + [WIN_NAME_NUMBERS] = { + .bg = 0, + .tilemapLeft = 15, + .tilemapTop = 12, + .width = 15, + .height = 2, + .paletteNum = 0xF, + .baseBlock = 1 + }, + [WIN_INSTRUCTIONS] = { + .bg = 0, + .tilemapLeft = 0, + .tilemapTop = 0, + .width = 15, + .height = 4, + .paletteNum = 0xF, + .baseBlock = 1 + 30 + }, + [WIN_BOTTOM_LEFT] = { + .bg = 0, + .tilemapLeft = 1, + .tilemapTop = 14, + .width = 6, + .height = 6, + .paletteNum = 0xF, + .baseBlock = 1 + 30 + 60 + }, + [WIN_BOTTOM_RIGHT] = { + .bg = 0, + .tilemapLeft = 7, + .tilemapTop = 14, + .width = 24, + .height = 6, + .paletteNum = 0xF, + .baseBlock = 1 + 30 + 60 + 36 + }, + [WIN_FOOTPRINT] = + { + .bg = 0, + .tilemapLeft = 27, + .tilemapTop = 14, + .width = 2, + .height = 2, + .paletteNum = 0xF, + .baseBlock = 1 + 30 + 60 + 36 + 144, + }, + DUMMY_WIN_TEMPLATE, +}; + +//Lookup tables +const u8 gBackAnimNames[][23 + 1] = +{ + [BACK_ANIM_NONE] = _("NONE"), + [BACK_ANIM_H_VIBRATE] = _("H VIBRATE"), + [BACK_ANIM_H_SLIDE] = _("H SLIDE"), + [BACK_ANIM_H_SPRING] = _("H SPRING"), + [BACK_ANIM_H_SPRING_REPEATED] = _("H SPRING REPEATED"), + [BACK_ANIM_SHRINK_GROW] = _("SHRINK GROW"), + [BACK_ANIM_GROW] = _("GROW"), + [BACK_ANIM_CIRCLE_COUNTERCLOCKWISE] = _("CIRCLE COUNTERCLOCKWISE"), + [BACK_ANIM_H_SHAKE] = _("H SHAKE"), + [BACK_ANIM_V_SHAKE] = _("V SHAKE"), + [BACK_ANIM_V_SHAKE_H_SLIDE] = _("V SHAKE H SLIDE"), + [BACK_ANIM_V_STRETCH] = _("V STRETCH"), + [BACK_ANIM_H_STRETCH] = _("H STRETCH"), + [BACK_ANIM_GROW_STUTTER] = _("GROW STUTTER"), + [BACK_ANIM_V_SHAKE_LOW] = _("V SHAKE LOW"), + [BACK_ANIM_TRIANGLE_DOWN] = _("TRIANGLE DOWN"), + [BACK_ANIM_CONCAVE_ARC_LARGE] = _("CONCAVE ARC LARGE"), + [BACK_ANIM_CONVEX_DOUBLE_ARC] = _("CONVEX DOUBLE ARC"), + [BACK_ANIM_CONCAVE_ARC_SMALL] = _("CONCAVE ARC SMALL"), + [BACK_ANIM_DIP_RIGHT_SIDE] = _("DIP RIGHT SIDE"), + [BACK_ANIM_SHRINK_GROW_VIBRATE] = _("SHRINK GROW VIBRATE"), + [BACK_ANIM_JOLT_RIGHT] = _("JOLT RIGHT"), + [BACK_ANIM_SHAKE_FLASH_YELLOW] = _("SHAKE FLASH YELLOW"), + [BACK_ANIM_SHAKE_GLOW_RED] = _("SHAKE GLOW RED"), + [BACK_ANIM_SHAKE_GLOW_GREEN] = _("SHAKE GLOW GREEN"), + [BACK_ANIM_SHAKE_GLOW_BLUE] = _("SHAKE GLOW BLUE"), +}; +const u8 gFrontAnimNames[][34] = +{ + [ANIM_V_SQUISH_AND_BOUNCE] = _("V SQUISH AND BOUNCE"), + [ANIM_CIRCULAR_STRETCH_TWICE] = _("CIRCULAR STRETCH TWICE"), + [ANIM_H_VIBRATE] = _("H VIBRATE"), + [ANIM_H_SLIDE] = _("H SLIDE"), + [ANIM_V_SLIDE] = _("V SLIDE"), + [ANIM_BOUNCE_ROTATE_TO_SIDES] = _("BOUNCE ROTATE TO SIDES"), + [ANIM_V_JUMPS_H_JUMPS] = _("V JUMPS H JUMPS"), + [ANIM_ROTATE_TO_SIDES] = _("ROTATE TO SIDES"), + [ANIM_ROTATE_TO_SIDES_TWICE] = _("ROTATE TO SIDES TWICE"), + [ANIM_GROW_VIBRATE] = _("GROW VIBRATE"), + [ANIM_ZIGZAG_FAST] = _("ZIGZAG FAST"), + [ANIM_SWING_CONCAVE] = _("SWING CONCAVE"), + [ANIM_SWING_CONCAVE_FAST] = _("SWING CONCAVE FAST"), + [ANIM_SWING_CONVEX] = _("SWING CONVEX"), + [ANIM_SWING_CONVEX_FAST] = _("SWING CONVEX FAST"), + [ANIM_H_SHAKE] = _("H SHAKE"), + [ANIM_V_SHAKE] = _("V SHAKE"), + [ANIM_CIRCULAR_VIBRATE] = _("CIRCULAR VIBRATE"), + [ANIM_TWIST] = _("TWIST"), + [ANIM_SHRINK_GROW] = _("SHRINK GROW"), + [ANIM_CIRCLE_C_CLOCKWISE] = _("CIRCLE C CLOCKWISE"), + [ANIM_GLOW_BLACK] = _("GLOW BLACK"), + [ANIM_H_STRETCH] = _("H STRETCH"), + [ANIM_V_STRETCH] = _("V STRETCH"), + [ANIM_RISING_WOBBLE] = _("RISING WOBBLE"), + [ANIM_V_SHAKE_TWICE] = _("V SHAKE TWICE"), + [ANIM_TIP_MOVE_FORWARD] = _("TIP MOVE FORWARD"), + [ANIM_H_PIVOT] = _("H PIVOT"), + [ANIM_V_SLIDE_WOBBLE] = _("V SLIDE WOBBLE"), + [ANIM_H_SLIDE_WOBBLE] = _("H SLIDE WOBBLE"), + [ANIM_V_JUMPS_BIG] = _("V JUMPS BIG"), + [ANIM_SPIN_LONG] = _("SPIN LONG"), + [ANIM_GLOW_ORANGE] = _("GLOW ORANGE"), + [ANIM_GLOW_RED] = _("GLOW RED"), + [ANIM_GLOW_BLUE] = _("GLOW BLUE"), + [ANIM_GLOW_YELLOW] = _("GLOW YELLOW"), + [ANIM_GLOW_PURPLE] = _("GLOW PURPLE"), + [ANIM_BACK_AND_LUNGE] = _("BACK AND LUNGE"), + [ANIM_BACK_FLIP] = _("BACK FLIP"), + [ANIM_FLICKER] = _("FLICKER"), + [ANIM_BACK_FLIP_BIG] = _("BACK FLIP BIG"), + [ANIM_FRONT_FLIP] = _("FRONT FLIP"), + [ANIM_TUMBLING_FRONT_FLIP] = _("TUMBLING FRONT FLIP"), + [ANIM_FIGURE_8] = _("FIGURE 8"), + [ANIM_FLASH_YELLOW] = _("FLASH YELLOW"), + [ANIM_SWING_CONCAVE_FAST_SHORT] = _("SWING CONCAVE FAST SHORT"), + [ANIM_SWING_CONVEX_FAST_SHORT] = _("SWING CONVEX FAST SHORT"), + [ANIM_ROTATE_UP_SLAM_DOWN] = _("ROTATE UP SLAM DOWN"), + [ANIM_DEEP_V_SQUISH_AND_BOUNCE] = _("DEEP V SQUISH AND BOUNCE"), + [ANIM_H_JUMPS] = _("H JUMPS"), + [ANIM_H_JUMPS_V_STRETCH] = _("H JUMPS V STRETCH"), + [ANIM_ROTATE_TO_SIDES_FAST] = _("ROTATE TO SIDES FAST"), + [ANIM_ROTATE_UP_TO_SIDES] = _("ROTATE UP TO SIDES"), + [ANIM_FLICKER_INCREASING] = _("FLICKER INCREASING"), + [ANIM_TIP_HOP_FORWARD] = _("TIP HOP FORWARD"), + [ANIM_PIVOT_SHAKE] = _("PIVOT SHAKE"), + [ANIM_TIP_AND_SHAKE] = _("TIP AND SHAKE"), + [ANIM_VIBRATE_TO_CORNERS] = _("VIBRATE TO CORNERS"), + [ANIM_GROW_IN_STAGES] = _("GROW IN STAGES"), + [ANIM_V_SPRING] = _("V SPRING"), + [ANIM_V_REPEATED_SPRING] = _("V REPEATED SPRING"), + [ANIM_SPRING_RISING] = _("SPRING RISING"), + [ANIM_H_SPRING] = _("H SPRING"), + [ANIM_H_REPEATED_SPRING_SLOW] = _("H REPEATED SPRING SLOW"), + [ANIM_H_SLIDE_SHRINK] = _("H SLIDE SHRINK"), + [ANIM_LUNGE_GROW] = _("LUNGE GROW"), + [ANIM_CIRCLE_INTO_BG] = _("CIRCLE INTO BG"), + [ANIM_RAPID_H_HOPS] = _("RAPID H HOPS"), + [ANIM_FOUR_PETAL] = _("FOUR PETAL"), + [ANIM_V_SQUISH_AND_BOUNCE_SLOW] = _("V SQUISH AND BOUNCE SLOW"), + [ANIM_H_SLIDE_SLOW] = _("H SLIDE SLOW"), + [ANIM_V_SLIDE_SLOW] = _("V SLIDE SLOW"), + [ANIM_BOUNCE_ROTATE_TO_SIDES_SMALL] = _("BOUNCE ROTATE TO SIDES SMALL"), + [ANIM_BOUNCE_ROTATE_TO_SIDES_SLOW] = _("BOUNCE ROTATE TO SIDES SLOW"), + [ANIM_BOUNCE_ROTATE_TO_SIDES_SMALL_SLOW] = _("BOUNCE ROTATE TO SIDES SMALL SLOW"), + [ANIM_ZIGZAG_SLOW] = _("ZIGZAG SLOW"), + [ANIM_H_SHAKE_SLOW] = _("H SHAKE SLOW"), + [ANIM_V_SHAKE_SLOW] = _("V SHAKE SLOW"), + [ANIM_TWIST_TWICE] = _("TWIST TWICE"), + [ANIM_CIRCLE_C_CLOCKWISE_SLOW] = _("CIRCLE C CLOCKWISE SLOW"), + [ANIM_V_SHAKE_TWICE_SLOW] = _("V SHAKE TWICE SLOW"), + [ANIM_V_SLIDE_WOBBLE_SMALL] = _("V SLIDE WOBBLE SMALL"), + [ANIM_V_JUMPS_SMALL] = _("V JUMPS SMALL"), + [ANIM_SPIN] = _("SPIN"), + [ANIM_TUMBLING_FRONT_FLIP_TWICE] = _("TUMBLING FRONT FLIP TWICE"), + [ANIM_DEEP_V_SQUISH_AND_BOUNCE_TWICE] = _("DEEP V SQUISH AND BOUNCE TWICE"), + [ANIM_H_JUMPS_V_STRETCH_TWICE] = _("H JUMPS V STRETCH TWICE"), + [ANIM_V_SHAKE_BACK] = _("V SHAKE BACK"), + [ANIM_V_SHAKE_BACK_SLOW] = _("V SHAKE BACK SLOW"), + [ANIM_V_SHAKE_H_SLIDE_SLOW] = _("V SHAKE H SLIDE SLOW"), + [ANIM_V_STRETCH_BOTH_ENDS_SLOW] = _("V STRETCH BOTH ENDS SLOW"), + [ANIM_H_STRETCH_FAR_SLOW] = _("H STRETCH FAR SLOW"), + [ANIM_V_SHAKE_LOW_TWICE] = _("V SHAKE LOW TWICE"), + [ANIM_H_SHAKE_FAST] = _("H SHAKE FAST"), + [ANIM_H_SLIDE_FAST] = _("H SLIDE FAST"), + [ANIM_H_VIBRATE_FAST] = _("H VIBRATE FAST"), + [ANIM_H_VIBRATE_FASTEST] = _("H VIBRATE FASTEST"), + [ANIM_V_SHAKE_BACK_FAST] = _("V SHAKE BACK FAST"), + [ANIM_V_SHAKE_LOW_TWICE_SLOW] = _("V SHAKE LOW TWICE SLOW"), + [ANIM_V_SHAKE_LOW_TWICE_FAST] = _("V SHAKE LOW TWICE FAST"), + [ANIM_CIRCLE_C_CLOCKWISE_LONG] = _("CIRCLE C CLOCKWISE LONG"), + [ANIM_GROW_STUTTER_SLOW] = _("GROW STUTTER SLOW"), + [ANIM_V_SHAKE_H_SLIDE] = _("V SHAKE H SLIDE"), + [ANIM_V_SHAKE_H_SLIDE_FAST] = _("V SHAKE H SLIDE FAST"), + [ANIM_TRIANGLE_DOWN_SLOW] = _("TRIANGLE DOWN SLOW"), + [ANIM_TRIANGLE_DOWN] = _("TRIANGLE DOWN"), + [ANIM_TRIANGLE_DOWN_TWICE] = _("TRIANGLE DOWN TWICE"), + [ANIM_GROW] = _("GROW"), + [ANIM_GROW_TWICE] = _("GROW TWICE"), + [ANIM_H_SPRING_FAST] = _("H SPRING FAST"), + [ANIM_H_SPRING_SLOW] = _("H SPRING SLOW"), + [ANIM_H_REPEATED_SPRING_FAST] = _("H REPEATED SPRING FAST"), + [ANIM_H_REPEATED_SPRING] = _("H REPEATED SPRING"), + [ANIM_SHRINK_GROW_FAST] = _("SHRINK GROW FAST"), + [ANIM_SHRINK_GROW_SLOW] = _("SHRINK GROW SLOW"), + [ANIM_V_STRETCH_BOTH_ENDS] = _("V STRETCH BOTH ENDS"), + [ANIM_V_STRETCH_BOTH_ENDS_TWICE] = _("V STRETCH BOTH ENDS TWICE"), + [ANIM_H_STRETCH_FAR_TWICE] = _("H STRETCH FAR TWICE"), + [ANIM_H_STRETCH_FAR] = _("H STRETCH FAR"), + [ANIM_GROW_STUTTER_TWICE] = _("GROW STUTTER TWICE"), + [ANIM_GROW_STUTTER] = _("GROW STUTTER"), + [ANIM_CONCAVE_ARC_LARGE_SLOW] = _("CONCAVE ARC LARGE SLOW"), + [ANIM_CONCAVE_ARC_LARGE] = _("CONCAVE ARC LARGE"), + [ANIM_CONCAVE_ARC_LARGE_TWICE] = _("CONCAVE ARC LARGE TWICE"), + [ANIM_CONVEX_DOUBLE_ARC_SLOW] = _("CONVEX DOUBLE ARC SLOW"), + [ANIM_CONVEX_DOUBLE_ARC] = _("CONVEX DOUBLE ARC"), + [ANIM_CONVEX_DOUBLE_ARC_TWICE] = _("CONVEX DOUBLE ARC TWICE"), + [ANIM_CONCAVE_ARC_SMALL_SLOW] = _("CONCAVE ARC SMALL SLOW"), + [ANIM_CONCAVE_ARC_SMALL] = _("CONCAVE ARC SMALL"), + [ANIM_CONCAVE_ARC_SMALL_TWICE] = _("CONCAVE ARC SMALL TWICE"), + [ANIM_H_DIP] = _("H DIP"), + [ANIM_H_DIP_FAST] = _("H DIP FAST"), + [ANIM_H_DIP_TWICE] = _("H DIP TWICE"), + [ANIM_SHRINK_GROW_VIBRATE_FAST] = _("SHRINK GROW VIBRATE FAST"), + [ANIM_SHRINK_GROW_VIBRATE] = _("SHRINK GROW VIBRATE"), + [ANIM_SHRINK_GROW_VIBRATE_SLOW] = _("SHRINK GROW VIBRATE SLOW"), + [ANIM_JOLT_RIGHT_FAST] = _("JOLT RIGHT FAST"), + [ANIM_JOLT_RIGHT] = _("JOLT RIGHT"), + [ANIM_JOLT_RIGHT_SLOW] = _("JOLT RIGHT SLOW"), + [ANIM_SHAKE_FLASH_YELLOW_FAST] = _("SHAKE FLASH YELLOW FAST"), + [ANIM_SHAKE_FLASH_YELLOW] = _("SHAKE FLASH YELLOW"), + [ANIM_SHAKE_FLASH_YELLOW_SLOW] = _("SHAKE FLASH YELLOW SLOW"), + [ANIM_SHAKE_GLOW_RED_FAST] = _("SHAKE GLOW RED FAST"), + [ANIM_SHAKE_GLOW_RED] = _("SHAKE GLOW RED"), + [ANIM_SHAKE_GLOW_RED_SLOW] = _("SHAKE GLOW RED SLOW"), + [ANIM_SHAKE_GLOW_GREEN_FAST] = _("SHAKE GLOW GREEN FAST"), + [ANIM_SHAKE_GLOW_GREEN] = _("SHAKE GLOW GREEN"), + [ANIM_SHAKE_GLOW_GREEN_SLOW] = _("SHAKE GLOW GREEN SLOW"), + [ANIM_SHAKE_GLOW_BLUE_FAST] = _("SHAKE GLOW BLUE FAST"), + [ANIM_SHAKE_GLOW_BLUE] = _("SHAKE GLOW BLUE"), + [ANIM_SHAKE_GLOW_BLUE_SLOW] = _("SHAKE GLOW BLUE SLOW"), + [ANIM_SHAKE_GLOW_BLACK_SLOW] = _("SHAKE GLOW BLACK SLOW"), + [ANIM_SHAKE_GLOW_WHITE_SLOW] = _("SHAKE GLOW WHITE SLOW"), + [ANIM_SHAKE_GLOW_PURPLE_SLOW] = _("SHAKE GLOW PURPLE SLOW"), +}; +const u8 gBattleBackgroundNames[][30] = +{ + [MAP_BATTLE_SCENE_NORMAL] = _("NORMAL "), + [MAP_BATTLE_SCENE_GYM] = _("GYM "), + [MAP_BATTLE_SCENE_MAGMA] = _("MAGMA "), + [MAP_BATTLE_SCENE_AQUA] = _("AQUA "), + [MAP_BATTLE_SCENE_SIDNEY] = _("SIDNEY "), + [MAP_BATTLE_SCENE_PHOEBE] = _("PHOEBE "), + [MAP_BATTLE_SCENE_GLACIA] = _("GLACIA "), + [MAP_BATTLE_SCENE_DRAKE] = _("DRAKE "), + [MAP_BATTLE_SCENE_FRONTIER] = _("FRONTIER "), + [MAP_BATTLE_SCENE_LEADER] = _("LEADER "), + [MAP_BATTLE_SCENE_WALLACE] = _("WALLACE "), + [MAP_BATTLE_SCENE_GROUDON] = _("GROUDON "), + [MAP_BATTLE_SCENE_KYOGRE] = _("KYOGRE "), + [MAP_BATTLE_SCENE_RAYQUAZA] = _("RAYQUAZA "), +}; +const u8 gBattleBackgroundTerrainNames[][26] = +{ + [BATTLE_TERRAIN_GRASS] = _("NORMAL - GRASS "), + [BATTLE_TERRAIN_LONG_GRASS] = _("NORMAL - LONG GRASS "), + [BATTLE_TERRAIN_SAND] = _("NORMAL - SAND "), + [BATTLE_TERRAIN_UNDERWATER] = _("NORMAL - UNDERWATER "), + [BATTLE_TERRAIN_WATER] = _("NORMAL - WATER "), + [BATTLE_TERRAIN_POND] = _("NORMAL - POND "), + [BATTLE_TERRAIN_MOUNTAIN] = _("NORMAL - MOUNTAIN "), + [BATTLE_TERRAIN_CAVE] = _("NORMAL - CAVE "), + [BATTLE_TERRAIN_BUILDING] = _("NORMAL - BUILDING "), + [BATTLE_TERRAIN_PLAIN] = _("NORMAL - PLAIN "), +}; +//Function declarations +static void PrintDigitChars(struct PokemonDebugMenu *data); +static void SetUpModifyArrows(struct PokemonDebugMenu *data); +static void UpdateBattlerValue(struct PokemonDebugMenu *data); +static void ValueToCharDigits(u8 *charDigits, u32 newValue, u8 maxDigits); +static bool32 TryMoveDigit(struct PokemonDebugModifyArrows *modArrows, bool32 moveUp); +static void CB2_Debug_Runner(void); +static void ResetBGs_Debug_Menu(u16); +static void Handle_Input_Debug_Pokemon(u8); +static void ReloadPokemonSprites(struct PokemonDebugMenu *data); +static void Exit_Debug_Pokemon(u8); + +//Text handling functions +static void PadString(const u8 *src, u8 *dst) +{ + u32 i; + + for (i = 0; i < 17 && src[i] != EOS; i++) + dst[i] = src[i]; + + for (; i < 17; i++) + dst[i] = CHAR_SPACE; + + dst[i] = EOS; +} + +static void PrintInstructionsOnWindow(struct PokemonDebugMenu *data) +{ + u8 fontId = 0; + u8 x = 2; + u8 textInstructions[] = _("{START_BUTTON} Shiny\n{B_BUTTON} Exit {A_BUTTON} Submenu 1$"); + u8 textInstructionsGender[] = _("{START_BUTTON} Shiny {SELECT_BUTTON} Gender\n{B_BUTTON} Exit {A_BUTTON} Submenu 1$"); + u8 textInstructionsSubmenuOne[] = _("{START_BUTTON} Shiny\n{B_BUTTON} Back {A_BUTTON} Submenu 2$"); + u8 textInstructionsSubmenuOneGender[] = _("{START_BUTTON} Shiny {SELECT_BUTTON} Gender\n{B_BUTTON} Back {A_BUTTON} Submenu 2$"); + u8 textInstructionsSubmenuTwo[] = _("{START_BUTTON} Shiny\n{B_BUTTON} Back$"); + u8 textInstructionsSubmenuTwoGender[] = _("{START_BUTTON} Shiny {SELECT_BUTTON} Gender\n{B_BUTTON} Back$"); + + + u8 textBottom[] = _("BACK:\nFRONT:\nBG:$"); + u8 textBottomForms[] = _("BACK:\nFRONT:\nBG:\nFORMS:$"); + u8 textBottomSubmenuTwo[] = _("B coords:\nF coords:\nF elev:"); + u16 species = data->modifyArrows.currValue; + + u8 textL[] = _("{L_BUTTON}"); + u8 textR[] = _("{R_BUTTON}"); + + //Instruction window + FillWindowPixelBuffer(WIN_INSTRUCTIONS, 0x11); + if (data->currentSubmenu == 0) + { + if (SpeciesHasGenderDifference[species]) + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructionsGender, x, 0, 0, NULL); + else + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructions, x, 0, 0, NULL); + } + else if (data->currentSubmenu == 1) + { + if (SpeciesHasGenderDifference[species]) + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructionsSubmenuOneGender, x, 0, 0, NULL); + else + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructionsSubmenuOne, x, 0, 0, NULL); + } + else if (data->currentSubmenu == 2) + { + if (SpeciesHasGenderDifference[species]) + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructionsSubmenuTwoGender, x, 0, 0, NULL); + else + AddTextPrinterParameterized(WIN_INSTRUCTIONS, fontId, textInstructionsSubmenuTwo, x, 0, 0, NULL); + } + CopyWindowToVram(WIN_INSTRUCTIONS, 3); + + //Bottom left text + FillWindowPixelBuffer(WIN_BOTTOM_LEFT, PIXEL_FILL(0)); + if (data->currentSubmenu != 2) + { + AddTextPrinterParameterized(WIN_BOTTOM_LEFT, fontId, textL, 30, 0, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_LEFT, fontId, textR, 30, 12, 0, NULL); + if (gFormSpeciesIdTables[data->currentmonId] != NULL) + AddTextPrinterParameterized(WIN_BOTTOM_LEFT, fontId, textBottomForms, 0, 0, 0, NULL); + else + AddTextPrinterParameterized(WIN_BOTTOM_LEFT, fontId, textBottom, 0, 0, 0, NULL); + } + else + AddTextPrinterParameterized(WIN_BOTTOM_LEFT, fontId, textBottomSubmenuTwo, 0, 0, 0, NULL); +} + +static void VBlankCB(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +static void SetStructPtr(u8 taskId, void *ptr) +{ + u32 structPtr = (u32)(ptr); + u8 *taskDataPtr = (u8*)(&gTasks[taskId].data[0]); + + taskDataPtr[0] = structPtr >> 0; + taskDataPtr[1] = structPtr >> 8; + taskDataPtr[2] = structPtr >> 16; + taskDataPtr[3] = structPtr >> 24; +} + +//Digit and arrow functions +#define VAL_U16 0 +static void PrintDigitChars(struct PokemonDebugMenu *data) +{ + s32 i; + u16 species = data->modifyArrows.currValue; + u8 text[MODIFY_DIGITS_MAX + POKEMON_NAME_LENGTH + 8]; + + for (i = 0; i < data->modifyArrows.maxDigits; i++) + text[i] = data->modifyArrows.charDigits[i]; + + text[i++] = CHAR_SPACE; + text[i++] = CHAR_HYPHEN; + + if (SpeciesHasGenderDifference[species]) + { + if (data->isFemale) + text[i++] = CHAR_FEMALE; + else + text[i++] = CHAR_MALE; + text[i++] = CHAR_HYPHEN; + } + + text[i++] = CHAR_SPACE; + StringCopy(&text[i], gSpeciesNames[species]); + + FillWindowPixelBuffer(WIN_NAME_NUMBERS, 0x11); + AddTextPrinterParameterized(WIN_NAME_NUMBERS, 1, text, 6, 0, 0, NULL); +} + +static u32 CharDigitsToValue(u8 *charDigits, u8 maxDigits) +{ + s32 i; + u8 id = 0; + u32 newValue = 0; + u8 valueDigits[MODIFY_DIGITS_MAX]; + + for (i = 0; i < MODIFY_DIGITS_MAX; i++) + valueDigits[i] = charDigits[i] - CHAR_0; + + if (maxDigits >= MODIFY_DIGITS_MAX) + newValue += valueDigits[id++] * 1000; + if (maxDigits >= MODIFY_DIGITS_MAX - 1) + newValue += valueDigits[id++] * 100; + if (maxDigits >= MODIFY_DIGITS_MAX - 2) + newValue += valueDigits[id++] * 10; + if (maxDigits >= MODIFY_DIGITS_MAX - 3) + newValue += valueDigits[id++]; + + return newValue; +} + +static void ValueToCharDigits(u8 *charDigits, u32 newValue, u8 maxDigits) +{ + s32 i; + u8 valueDigits[MODIFY_DIGITS_MAX]; + u8 id = 0; + + if (maxDigits >= MODIFY_DIGITS_MAX) + valueDigits[id++] = newValue / 1000; + if (maxDigits >= MODIFY_DIGITS_MAX - 1) + valueDigits[id++] = (newValue % 1000) / 100; + if (maxDigits >= MODIFY_DIGITS_MAX - 2) + valueDigits[id++] = (newValue % 100) / 10; + if (maxDigits >= MODIFY_DIGITS_MAX - 3) + valueDigits[id++] = newValue % 10; + + for (i = 0; i < MODIFY_DIGITS_MAX; i++) + charDigits[i] = valueDigits[i] + CHAR_0; +} + +static void SetArrowInvisibility(struct PokemonDebugMenu *data) +{ + bool8 invisible = data->currentSubmenu; + switch (data->currentSubmenu) + { + case 0: + gSprites[data->modifyArrows.arrowSpriteId[0]].invisible = FALSE; + gSprites[data->modifyArrows.arrowSpriteId[1]].invisible = FALSE; + gSprites[data->optionArrows.arrowSpriteId[0]].invisible = TRUE; + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].invisible = TRUE; + break; + case 1: + gSprites[data->modifyArrows.arrowSpriteId[0]].invisible = TRUE; + gSprites[data->modifyArrows.arrowSpriteId[1]].invisible = TRUE; + gSprites[data->optionArrows.arrowSpriteId[0]].invisible = FALSE; + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].invisible = TRUE; + break; + case 2: + gSprites[data->modifyArrows.arrowSpriteId[0]].invisible = TRUE; + gSprites[data->modifyArrows.arrowSpriteId[1]].invisible = TRUE; + gSprites[data->optionArrows.arrowSpriteId[0]].invisible = TRUE; + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].invisible = FALSE; + break; + } +} + +static void SetUpModifyArrows(struct PokemonDebugMenu *data) +{ + LoadSpritePalette(&sSpritePalette_Arrow); + data->modifyArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, MODIFY_DIGITS_ARROW_X, MODIFY_DIGITS_ARROW1_Y, 0); + data->modifyArrows.arrowSpriteId[1] = CreateSprite(&sSpriteTemplate_Arrow, MODIFY_DIGITS_ARROW_X, MODIFY_DIGITS_ARROW2_Y, 0); + gSprites[data->modifyArrows.arrowSpriteId[1]].animNum = 1; + + data->modifyArrows.minValue = 1; + data->modifyArrows.maxValue = NUM_SPECIES - 1; + data->modifyArrows.maxDigits = 4; + data->modifyArrows.modifiedValPtr = &data->currentmonId; + data->modifyArrows.typeOfVal = VAL_U16; + data->modifyArrows.currValue = data->currentmonId; + + data->modifyArrows.currentDigit = 0; + ValueToCharDigits(data->modifyArrows.charDigits, data->modifyArrows.currValue, data->modifyArrows.maxDigits); +} + +static void SetUpOptionArrows(struct PokemonDebugMenu *data) +{ + LoadSpritePalette(&sSpritePalette_Arrow); + data->optionArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, OPTIONS_ARROW_1_X, OPTIONS_ARROW_Y, 0); + gSprites[data->optionArrows.arrowSpriteId[0]].animNum = 2; + + data->optionArrows.currentDigit = 0; + + gSprites[data->optionArrows.arrowSpriteId[0]].invisible = TRUE; +} + +static void SetUpYPosModifyArrows(struct PokemonDebugMenu *data) +{ + LoadSpritePalette(&sSpritePalette_Arrow); + data->yPosModifyArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, OPTIONS_ARROW_1_X, OPTIONS_ARROW_Y, 0); + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].animNum = 2; + + data->yPosModifyArrows.currentDigit = 0; + + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].invisible = TRUE; +} + +static bool32 TryMoveDigit(struct PokemonDebugModifyArrows *modArrows, bool32 moveUp) +{ + s32 i; + u8 charDigits[MODIFY_DIGITS_MAX]; + u32 newValue; + + for (i = 0; i < MODIFY_DIGITS_MAX; i++) + charDigits[i] = modArrows->charDigits[i]; + + if (moveUp) + { + if (charDigits[modArrows->currentDigit] == CHAR_9) + { + charDigits[modArrows->currentDigit] = CHAR_0; + for (i = modArrows->currentDigit - 1; i >= 0; i--) + { + if (charDigits[i] == CHAR_9) + charDigits[i] = CHAR_0; + else + { + charDigits[i]++; + break; + } + } + } + else + charDigits[modArrows->currentDigit]++; + } + else + { + if (charDigits[modArrows->currentDigit] == CHAR_0) + { + charDigits[modArrows->currentDigit] = CHAR_9; + + for (i = modArrows->currentDigit - 1; i >= 0; i--) + { + if (charDigits[i] == CHAR_0) + charDigits[i] = CHAR_9; + else + { + charDigits[i]--; + break; + } + } + } + + else + charDigits[modArrows->currentDigit]--; + } + + newValue = CharDigitsToValue(charDigits, modArrows->maxDigits); + if (newValue > modArrows->maxValue || newValue < modArrows->minValue) + { + return FALSE; + } + else + { + modArrows->currValue = newValue; + for (i = 0; i < MODIFY_DIGITS_MAX; i++) + modArrows->charDigits[i] = charDigits[i]; + return TRUE; + } +} + +static void UpdateBattlerValue(struct PokemonDebugMenu *data) +{ + u32 i; + switch (data->modifyArrows.typeOfVal) + { + case VAL_U16: + *(u16*)(data->modifyArrows.modifiedValPtr) = data->modifyArrows.currValue; + break; + } +} + +//Sprite functions +static const struct CompressedSpritePalette *GetMonSpritePalStructCustom(u16 species, bool8 isFemale, bool8 isShiny) +{ + if (isShiny) + { + if (SpeciesHasGenderDifference[species] && isFemale) + return &gMonShinyPaletteTableFemale[species]; + else + return &gMonShinyPaletteTable[species]; + } + else + { + if (SpeciesHasGenderDifference[species] && isFemale) + return &gMonPaletteTableFemale[species]; + else + return &gMonPaletteTable[species]; + } +} + +static void BattleLoadOpponentMonSpriteGfxCustom(u16 species, bool8 isFemale, bool8 isShiny, u8 battlerId) +{ + u16 paletteOffset; + const void *lzPaletteData; + const struct CompressedSpritePalette *palette; + + paletteOffset = 0x100 + battlerId * 16; + + palette = GetMonSpritePalStructCustom(species, isFemale, isShiny); + + if (isShiny) + { + if (SpeciesHasGenderDifference[species] && isFemale) + lzPaletteData = gMonShinyPaletteTableFemale[species].data; + else + lzPaletteData = gMonShinyPaletteTable[species].data; + } + else + { + if (SpeciesHasGenderDifference[species] && isFemale) + lzPaletteData = gMonPaletteTableFemale[species].data; + else + lzPaletteData = gMonPaletteTable[species].data; + } + + LZDecompressWram(lzPaletteData, gDecompressionBuffer); + LoadPalette(gDecompressionBuffer, paletteOffset, 0x20); + LoadPalette(gDecompressionBuffer, 0x80 + battlerId * 16, 0x20); +} + +static bool8 IsCastformForm(species) +{ + if (species == SPECIES_CASTFORM_SUNNY || species == SPECIES_CASTFORM_RAINY || species == SPECIES_CASTFORM_SNOWY) + return TRUE; + + return FALSE; +} + +static u8 GetCastformYCustom(species) +{ + u8 ret; + switch (species) + { + case SPECIES_CASTFORM: + ret = gCastformFrontSpriteCoords[CASTFORM_NORMAL].y_offset; + break; + case SPECIES_CASTFORM_SUNNY: + ret = gCastformFrontSpriteCoords[CASTFORM_FIRE].y_offset; + break; + case SPECIES_CASTFORM_RAINY: + ret = gCastformFrontSpriteCoords[CASTFORM_WATER].y_offset; + break; + case SPECIES_CASTFORM_SNOWY: + ret = gCastformFrontSpriteCoords[CASTFORM_ICE].y_offset; + break; + } + return ret; +} + +static u8 GetElevationValue(u16 species) +{ + u8 val; + if (species == SPECIES_CASTFORM) + val = sCastformElevations[0]; + else if (IsCastformForm(species)) + val = sCastformElevations[species - SPECIES_CASTFORM_SUNNY + 1]; + else + val = gEnemyMonElevation[species]; + + return val; +} + +static void SetConstSpriteValues(struct PokemonDebugMenu *data) +{ + u16 species = data->currentmonId; + data->constSpriteValues.frontPicCoords = gMonFrontPicCoords[species].y_offset; + data->constSpriteValues.frontElevation = GetElevationValue(species); + data->constSpriteValues.backPicCoords = gMonBackPicCoords[species].y_offset; +} + +static u8 GetBattlerSpriteFinal_YCustom(u16 species, s8 offset_picCoords, s8 offset_elevation) +{ + u16 offset; + u8 y; + + //FrontPicCoords + offset = gMonFrontPicCoords[species].y_offset + offset_picCoords; + + //Elevation + offset -= GetElevationValue(species) + offset_elevation; + + //Main position + y = offset + sBattlerCoords[0][1].y; + + if (y > DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8) + y = DISPLAY_HEIGHT - MON_PIC_HEIGHT + 8; + + return y; +} + +static void UpdateShadowSpriteInvisible(struct PokemonDebugMenu *data) +{ + if (data->constSpriteValues.frontElevation + data->offsetsSpriteValues.offset_front_elevation == 0) + gSprites[data->frontShadowSpriteId].invisible = TRUE; + else + gSprites[data->frontShadowSpriteId].invisible = FALSE; +} + +static void SpriteCB_EnemyShadowCustom(struct Sprite *shadowSprite) +{ + u8 frontSpriteId = shadowSprite->data[0]; + struct Sprite *battlerSprite = &gSprites[frontSpriteId]; + + shadowSprite->x = battlerSprite->x; + shadowSprite->x2 = battlerSprite->x2; +} + +static void LoadAndCreateEnemyShadowSpriteCustom(struct PokemonDebugMenu *data, u16 species) +{ + u8 x, y; + bool8 invisible = FALSE; + if (gEnemyMonElevation[species] == 0 && !IsCastformForm(species)) + invisible = TRUE; + LoadCompressedSpriteSheet(&gSpriteSheet_EnemyShadow); + LoadSpritePalette(&sSpritePalettes_HealthBoxHealthBar[0]); + x = sBattlerCoords[0][1].x; + y = sBattlerCoords[0][1].y; + + data->frontShadowSpriteId = CreateSprite(&gSpriteTemplate_EnemyShadow, x, y + 29, 0xC8); + gSprites[data->frontShadowSpriteId].data[0] = data->frontspriteId; + + gSprites[data->frontShadowSpriteId].callback = SpriteCB_EnemyShadowCustom; + gSprites[data->frontShadowSpriteId].oam.priority = 0; + gSprites[data->frontShadowSpriteId].invisible = invisible; +} + +//Tile functions (footprints) +static void DrawFootprintCustom(u8 windowId, u16 species) +{ + u8 footprint[32 * 4] = {0}; + const u8 * footprintGfx = gMonFootprintTable[species]; + u32 i, j, tileIdx = 0; + + if (footprintGfx != NULL) + { + for (i = 0; i < 32; i++) + { + u8 tile = footprintGfx[i]; + for (j = 0; j < 4; j++) + { + u8 value = ((tile >> (2 * j)) & 1 ? 2 : 0); + if (tile & (2 << (2 * j))) + value |= 0x20; + footprint[tileIdx] = value; + tileIdx++; + } + } + } + CopyToWindowPixelBuffer(windowId, footprint, sizeof(footprint), 0); +} + +//Battle background functions +static void LoadBattleBg(u8 battleBgType, u8 battleTerrain) +{ + switch (battleBgType) + { + default: + case MAP_BATTLE_SCENE_NORMAL: + LZDecompressVram(sBattleTerrainTable[battleTerrain].tileset, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(sBattleTerrainTable[battleTerrain].tilemap, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(sBattleTerrainTable[battleTerrain].palette, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_GYM: + LZDecompressVram(gBattleTerrainTiles_Building, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_BuildingGym, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_MAGMA: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumMagma, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_AQUA: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumAqua, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_SIDNEY: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumSidney, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_PHOEBE: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumPhoebe, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_GLACIA: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumGlacia, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_DRAKE: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumDrake, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_FRONTIER: + LZDecompressVram(gBattleTerrainTiles_Building, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_Frontier, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_LEADER: + LZDecompressVram(gBattleTerrainTiles_Building, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Building, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_BuildingLeader, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_WALLACE: + LZDecompressVram(gBattleTerrainTiles_Stadium, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Stadium, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_StadiumWallace, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_GROUDON: + LZDecompressVram(gBattleTerrainTiles_Cave, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Cave, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_Groudon, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_KYOGRE: + LZDecompressVram(gBattleTerrainTiles_Water, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Water, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_Kyogre, 0x20, 0x60); + break; + case MAP_BATTLE_SCENE_RAYQUAZA: + LZDecompressVram(gBattleTerrainTiles_Rayquaza, (void*)(BG_CHAR_ADDR(2))); + LZDecompressVram(gBattleTerrainTilemap_Rayquaza, (void*)(BG_SCREEN_ADDR(26))); + LoadCompressedPalette(gBattleTerrainPalette_Rayquaza, 0x20, 0x60); + break; + } +} +static void PrintBattleBgName(u8 taskId) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + u8 fontId = 0; + u8 text[30+1]; + + if (data->battleBgType == 0) + StringCopy(text, gBattleBackgroundTerrainNames[data->battleTerrain]); + else + StringCopy(text, gBattleBackgroundNames[data->battleBgType]); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, 0, 24, 0, NULL); +} +static void UpdateBattleBg(u8 taskId, bool8 increment) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + + if (data->battleBgType == MAP_BATTLE_SCENE_NORMAL) + { + if (increment) + { + if (data->battleTerrain == BATTLE_TERRAIN_PLAIN) + data->battleBgType += 1; + else + data->battleTerrain += 1; + } + else + { + if (data->battleTerrain == BATTLE_TERRAIN_GRASS) + data->battleBgType = MAP_BATTLE_SCENE_RAYQUAZA; + else + data->battleTerrain -= 1; + } + } + else if (data->battleBgType == MAP_BATTLE_SCENE_GYM) + { + if (increment) + data->battleBgType += 1; + else + { + data->battleBgType = MAP_BATTLE_SCENE_NORMAL; + data->battleTerrain = BATTLE_TERRAIN_PLAIN; + } + } + else if (data->battleBgType == MAP_BATTLE_SCENE_RAYQUAZA) + { + if (increment) + { + data->battleBgType = MAP_BATTLE_SCENE_NORMAL; + data->battleTerrain = BATTLE_TERRAIN_GRASS; + } + else + data->battleBgType -= 1; + } + else + { + if (increment) + data->battleBgType += 1; + else + data->battleBgType -= 1; + } + + PrintBattleBgName(taskId); + + LoadBattleBg(data->battleBgType, data->battleTerrain); +} + +// ******************************* +// Main functions +static void UpdateMonAnimNames(u8 taskId) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + u8 frontAnim = data->animIdFront; + u8 backAnim = data->animIdBack; + u8 text[34]; + u8 fontId = 0; + u8 textNum[4]; + + FillWindowPixelBuffer(WIN_BOTTOM_RIGHT, PIXEL_FILL(0)); + + //Back + StringCopy(text, gBackAnimNames[backAnim]); + ConvertIntToDecimalStringN(textNum, backAnim, STR_CONV_MODE_LEADING_ZEROS, 3); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textNum, 0, 0, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, 18, 0, 0, NULL); + //Front + StringCopy(text, gFrontAnimNames[frontAnim]); + ConvertIntToDecimalStringN(textNum, frontAnim, STR_CONV_MODE_LEADING_ZEROS, 3); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textNum, 0, 12, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, 18, 12, 0, NULL); + + PrintBattleBgName(taskId); +} + +static void UpdateYPosOffsetText(struct PokemonDebugMenu *data) +{ + u8 text[34]; + u8 fontId = 0; + u8 textConst[] = _("const val:"); + u8 textNew[] = _("new val:"); + u8 x_const_val = 50; + u8 x_new_text = 70; + u8 x_new_val = 110; + u8 y = 0; + + u8 backPicCoords = data->constSpriteValues.backPicCoords; + u8 frontPicCoords = data->constSpriteValues.frontPicCoords; + u8 frontElevation = data->constSpriteValues.frontElevation; + + s8 offset_back_picCoords = data->offsetsSpriteValues.offset_back_picCoords; + s8 offset_front_picCoords = data->offsetsSpriteValues.offset_front_picCoords; + s8 offset_front_elevation = data->offsetsSpriteValues.offset_front_elevation; + + u8 newBackPicCoords = backPicCoords + offset_back_picCoords; + u8 newFrontPicCoords = frontPicCoords + offset_front_picCoords; + u8 newFrontElevation = frontElevation + offset_front_elevation; + + FillWindowPixelBuffer(WIN_BOTTOM_RIGHT, PIXEL_FILL(0)); + + //Back + y = 0; + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textConst, 0, y, 0, NULL); + ConvertIntToDecimalStringN(text, backPicCoords , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_const_val, y, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textNew, x_new_text, y, 0, NULL); + ConvertIntToDecimalStringN(text, newBackPicCoords , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_new_val, y, 0, NULL); + //Front picCoords + y = 12; + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textConst, 0, y, 0, NULL); + ConvertIntToDecimalStringN(text, frontPicCoords , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_const_val, y, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textNew, x_new_text, y, 0, NULL); + ConvertIntToDecimalStringN(text, newFrontPicCoords , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_new_val, y, 0, NULL); + //Front elevation + y = 24; + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textConst, 0, y, 0, NULL); + ConvertIntToDecimalStringN(text, frontElevation , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_const_val, y, 0, NULL); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, textNew, x_new_text, y, 0, NULL); + ConvertIntToDecimalStringN(text, newFrontElevation , STR_CONV_MODE_LEFT_ALIGN, 2); + AddTextPrinterParameterized(WIN_BOTTOM_RIGHT, fontId, text, x_new_val, y, 0, NULL); +} + +static void ResetPokemonDebugWindows(void) +{ + u8 i; + + FreeAllWindowBuffers(); + InitWindows(sPokemonDebugWindowTemplate); + + for (i = 0; i < WIN_END + 1; i++) + { + FillWindowPixelBuffer(i, PIXEL_FILL(0)); + PutWindowTilemap(i); + CopyWindowToVram(i, 3); + } +} + +void CB2_Debug_Pokemon(void) +{ + u8 taskId; + const struct CompressedSpritePalette *palette; + struct PokemonDebugMenu *data; + u16 species; + s16 offset_y; + u8 front_x = sBattlerCoords[0][1].x; + u8 front_y; + + switch (gMain.state) + { + case 0: + default: + SetVBlankCallback(NULL); + FreeMonSpritesGfx(); + ResetBGs_Debug_Menu(0); + DmaFillLarge16(3, 0, (u8 *)VRAM, VRAM_SIZE, 0x1000) + DmaClear32(3, OAM, OAM_SIZE); + DmaClear16(3, PLTT, PLTT_SIZE); + gMain.state = 1; + break; + case 1: + ScanlineEffect_Stop(); + ResetTasks(); + ResetSpriteData(); + ResetPaletteFade(); + FreeAllSpritePalettes(); + gReservedSpritePaletteCount = 8; + ResetAllPicSprites(); + BlendPalettes(PALETTES_ALL, 16, RGB_BLACK); + LoadPalette(GetTextWindowPalette(0), 15*16, 0x40); + + FillBgTilemapBufferRect(0, 0, 0, 0, 32, 20, 15); + InitBgsFromTemplates(0, sBgTemplates, ARRAY_COUNT(sBgTemplates)); + data->battleBgType = 0; + data->battleTerrain = 0; + LoadBattleBg(data->battleBgType , data->battleTerrain); + + gMain.state++; + break; + case 2: + ResetPokemonDebugWindows(); + gMain.state++; + break; + case 3: + AllocateMonSpritesGfx(); + + LoadPalette(sBgColor, 0, 2); + LoadMonIconPalette(SPECIES_BULBASAUR); + + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP); + ShowBg(0); + ShowBg(1); + ShowBg(2); + ShowBg(3); + + //input task handler + taskId = CreateTask(Handle_Input_Debug_Pokemon, 0); + + data = AllocZeroed(sizeof(struct PokemonDebugMenu)); + SetStructPtr(taskId, data); + + data->currentmonId = SPECIES_BULBASAUR; + species = data->currentmonId; + + //Print instructions + PrintInstructionsOnWindow(data); + + //Palettes + palette = GetMonSpritePalStructCustom(species, data->isFemale, data->isShiny); + LoadCompressedSpritePalette(palette); + //Front + HandleLoadSpecialPokePicCustom(&gMonFrontPicTable[species], gMonSpritesGfxPtr->sprites.ptr[1], species, 0, data->isFemale); + data->isShiny = FALSE; + data->isFemale = FALSE; + BattleLoadOpponentMonSpriteGfxCustom(species, data->isFemale, data->isShiny, 1); + SetMultiuseSpriteTemplateToPokemon(species, 1); + gMultiuseSpriteTemplate.paletteTag = palette->tag; + front_y = GetBattlerSpriteFinal_YCustom(species, 0, 0); + data->frontspriteId = CreateSprite(&gMultiuseSpriteTemplate, front_x, front_y, 0); + gSprites[data->frontspriteId].oam.paletteNum = 1; + gSprites[data->frontspriteId].callback = SpriteCallbackDummy; + gSprites[data->frontspriteId].oam.priority = 0; + //Front Shadow + LoadAndCreateEnemyShadowSpriteCustom(data, species); + + //Back + HandleLoadSpecialPokePicCustom(&gMonBackPicTable[species], gMonSpritesGfxPtr->sprites.ptr[2], species, 0, data->isFemale); + BattleLoadOpponentMonSpriteGfxCustom(species, data->isFemale, data->isShiny, 4); + SetMultiuseSpriteTemplateToPokemon(species, 2); + offset_y = gMonBackPicCoords[species].y_offset; + data->backspriteId = CreateSprite(&gMultiuseSpriteTemplate, DEBUG_MON_BACK_X, DEBUG_MON_BACK_Y + offset_y, 0); + gSprites[data->backspriteId].oam.paletteNum = 4; + gSprites[data->backspriteId].callback = SpriteCallbackDummy; + gSprites[data->backspriteId].oam.priority = 0; + + //Icon Sprite + data->iconspriteId = CreateMonIconCustom(species, SpriteCB_MonIcon, DEBUG_ICON_X, DEBUG_ICON_Y, 4, data->isShiny, data->isFemale, data->isShiny); + gSprites[data->iconspriteId].oam.priority = 0; + + //Modify Arrows + SetUpModifyArrows(data); + PrintDigitChars(data); + + //Option Arrow + SetUpOptionArrows(data); + + //Modify Y Pos Arrow + SetUpYPosModifyArrows(data); + + //Anim names + data->animIdBack = GetSpeciesBackAnimSet(species) + 1; + data->animIdFront = sMonFrontAnimIdsTable[data->currentmonId - 1]; + UpdateMonAnimNames(taskId); + + //BattleNg Name + PrintBattleBgName(taskId); + + //Footprint + DrawFootprintCustom(WIN_FOOTPRINT, species); + CopyWindowToVram(WIN_FOOTPRINT, COPYWIN_GFX); + + gMain.state++; + break; + case 4: + EnableInterrupts(1); + SetVBlankCallback(VBlankCB); + SetMainCallback2(CB2_Debug_Runner); + m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 0x80); + break; + } +} + +static void CB2_Debug_Runner(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +static void ResetBGs_Debug_Menu(u16 a) +{ + if (!(a & DISPCNT_BG0_ON)) + { + ClearGpuRegBits(0, DISPCNT_BG0_ON); + SetGpuReg(REG_OFFSET_BG0CNT, 0); + SetGpuReg(REG_OFFSET_BG0HOFS, 0); + SetGpuReg(REG_OFFSET_BG0VOFS, 0); + } + if (!(a & DISPCNT_BG1_ON)) + { + ClearGpuRegBits(0, DISPCNT_BG1_ON); + SetGpuReg(REG_OFFSET_BG1CNT, 0); + SetGpuReg(REG_OFFSET_BG1HOFS, 0); + SetGpuReg(REG_OFFSET_BG1VOFS, 0); + } + if (!(a & DISPCNT_BG2_ON)) + { + ClearGpuRegBits(0, DISPCNT_BG2_ON); + SetGpuReg(REG_OFFSET_BG2CNT, 0); + SetGpuReg(REG_OFFSET_BG2HOFS, 0); + SetGpuReg(REG_OFFSET_BG2VOFS, 0); + } + if (!(a & DISPCNT_BG3_ON)) + { + ClearGpuRegBits(0, DISPCNT_BG3_ON); + SetGpuReg(REG_OFFSET_BG3CNT, 0); + SetGpuReg(REG_OFFSET_BG3HOFS, 0); + SetGpuReg(REG_OFFSET_BG3VOFS, 0); + } + if (!(a & DISPCNT_OBJ_ON)) + { + ClearGpuRegBits(0, DISPCNT_OBJ_ON); + ResetSpriteData(); + FreeAllSpritePalettes(); + gReservedSpritePaletteCount = 8; + } +} + +static void UpdateSubmenuOneOptionValue(u8 taskId, bool8 increment) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + u8 option = data->submenuYpos[1]; + + switch (option) + { + case 0: + if (increment) + { + if (data->animIdBack >= BACK_ANIM_SHAKE_GLOW_BLUE) + data->animIdBack = 1; + else + data->animIdBack += 1; + } + else + { + if (data->animIdBack <= 1) + data->animIdBack = BACK_ANIM_SHAKE_GLOW_BLUE; + else + data->animIdBack -= 1; + } + UpdateMonAnimNames(taskId); + break; + case 1: + if (increment) + { + if (data->animIdFront >= ANIM_SHAKE_GLOW_PURPLE_SLOW) + data->animIdFront = 0; + else + data->animIdFront += 1; + } + else + { + if (data->animIdFront <= 0) + data->animIdFront = ANIM_SHAKE_GLOW_PURPLE_SLOW; + else + data->animIdFront -= 1; + } + UpdateMonAnimNames(taskId); + break; + case 2: + UpdateBattleBg(taskId, increment); + break; + case 3: + if (gFormSpeciesIdTables[data->currentmonId] != NULL) + { + struct PokemonDebugModifyArrows *modArrows = &data->modifyArrows; + u8 formId = GetFormIdFromFormSpeciesId(data->currentmonId); + if (increment) + { + if (gFormSpeciesIdTables[data->currentmonId][formId + 1] != FORM_SPECIES_END) + modArrows->currValue = GetFormSpeciesId(data->currentmonId, formId + 1); + else + modArrows->currValue = gFormSpeciesIdTables[data->currentmonId][0]; + } + else + { + if (gFormSpeciesIdTables[data->currentmonId][formId] == gFormSpeciesIdTables[data->currentmonId][0]) + { + u8 lastForm; + for (lastForm = 0; gFormSpeciesIdTables[data->currentmonId][lastForm] != FORM_SPECIES_END; lastForm++) + { + if (gFormSpeciesIdTables[data->currentmonId][lastForm + 1] == FORM_SPECIES_END) + break; + } + modArrows->currValue = gFormSpeciesIdTables[data->currentmonId][lastForm]; + } + else + modArrows->currValue = GetFormSpeciesId(data->currentmonId, formId - 1); + } + data->animIdBack = GetSpeciesBackAnimSet(modArrows->currValue) + 1; + data->animIdFront = sMonFrontAnimIdsTable[modArrows->currValue - 1]; + UpdateMonAnimNames(taskId); + + UpdateBattlerValue(data); + ReloadPokemonSprites(data); + while (!(gMain.intrCheck & INTR_FLAG_VBLANK)); + PlaySE(SE_DEX_SCROLL); + } + break; + default: + break; + } +} + +static void UpdateSubmenuTwoOptionValue(u8 taskId, bool8 increment) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + u16 species = data->currentmonId; + u8 option = data->submenuYpos[2]; + s8 offset; + u8 y; + + switch (option) + { + case 0: //Back picCoords + offset = data->offsetsSpriteValues.offset_back_picCoords; + if (increment) + { + if (offset == MAX_Y_OFFSET) + offset = -data->constSpriteValues.backPicCoords; + else + offset += 1; + } + else + { + if (offset == -data->constSpriteValues.backPicCoords) + offset = MAX_Y_OFFSET; + else + offset -= 1; + } + data->offsetsSpriteValues.offset_back_picCoords = offset; + gSprites[data->backspriteId].y = DEBUG_MON_BACK_Y + gMonBackPicCoords[species].y_offset + offset; + break; + case 1: //Front picCoords + offset = data->offsetsSpriteValues.offset_front_picCoords; + if (increment) + { + if (offset == MAX_Y_OFFSET) + offset = -data->constSpriteValues.frontPicCoords; + else + offset += 1; + } + else + { + if (offset == -data->constSpriteValues.frontPicCoords) + offset = MAX_Y_OFFSET; + else + offset -= 1; + } + data->offsetsSpriteValues.offset_front_picCoords = offset; + y = GetBattlerSpriteFinal_YCustom(species, offset, data->offsetsSpriteValues.offset_front_elevation); + gSprites[data->frontspriteId].y = y; + break; + case 2: //Front elevation + offset = data->offsetsSpriteValues.offset_front_elevation; + if (increment) + { + if (offset == MAX_Y_OFFSET) + offset = -data->constSpriteValues.frontElevation; + else + offset += 1; + } + else + { + if (offset == -data->constSpriteValues.frontElevation) + offset = MAX_Y_OFFSET; + else + offset -= 1; + } + data->offsetsSpriteValues.offset_front_elevation = offset; + y = GetBattlerSpriteFinal_YCustom(species, data->offsetsSpriteValues.offset_front_picCoords, offset); + gSprites[data->frontspriteId].y = y; + UpdateShadowSpriteInvisible(data); + break; + } + + UpdateYPosOffsetText(data); +} + + +static void Handle_Input_Debug_Pokemon(u8 taskId) +{ + struct PokemonDebugMenu *data = GetStructPtr(taskId); + struct Sprite *Frontsprite = &gSprites[data->frontspriteId]; + struct Sprite *Backsprite = &gSprites[data->backspriteId]; + + if (JOY_NEW(L_BUTTON) && (Backsprite->callback == SpriteCallbackDummy)) + { + PlayCryInternal(data->currentmonId, 0, 120, 10, 0); + LaunchAnimationTaskForBackSprite(Backsprite, data->animIdBack-1); + } + + if (JOY_NEW(R_BUTTON) && (Frontsprite->callback == SpriteCallbackDummy)) + { + PlayCryInternal(data->currentmonId, 0, 120, 10, 0); + if (HasTwoFramesAnimation(data->currentmonId)) + StartSpriteAnim(Frontsprite, 1); + LaunchAnimationTaskForFrontSprite(Frontsprite, data->animIdFront); + } + if (JOY_NEW(START_BUTTON)) + { + data->isShiny = !data->isShiny; + + if(data->isShiny) + PlaySE(SE_SHINY); + + ReloadPokemonSprites(data); + + } + if (JOY_NEW(SELECT_BUTTON) && SpeciesHasGenderDifference[data->currentmonId]) + { + data->isFemale = !data->isFemale; + PrintDigitChars(data); + UpdateBattlerValue(data); + ReloadPokemonSprites(data); + while (!(gMain.intrCheck & INTR_FLAG_VBLANK)); + PlaySE(SE_DEX_SCROLL); + } + + if (data->currentSubmenu == 0) + { + if (JOY_NEW(A_BUTTON)) + { + data->currentSubmenu = 1; + SetArrowInvisibility(data); + SetConstSpriteValues(data); + PrintInstructionsOnWindow(data); + } + else if (JOY_NEW(B_BUTTON)) + { + BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); + gTasks[taskId].func = Exit_Debug_Pokemon; + PlaySE(SE_PC_OFF); + } + else if (JOY_NEW(DPAD_DOWN)) + { + if (TryMoveDigit(&data->modifyArrows, FALSE)) + { + data->isFemale = FALSE; + PrintDigitChars(data); + UpdateBattlerValue(data); + ReloadPokemonSprites(data); + data->animIdBack = GetSpeciesBackAnimSet(data->currentmonId) + 1; + data->animIdFront = sMonFrontAnimIdsTable[data->currentmonId - 1]; + UpdateMonAnimNames(taskId); + data->offsetsSpriteValues.offset_back_picCoords = 0; + data->offsetsSpriteValues.offset_front_picCoords = 0; + data->offsetsSpriteValues.offset_front_elevation = 0; + } + PlaySE(SE_DEX_SCROLL); + while (!(gMain.intrCheck & INTR_FLAG_VBLANK)); + } + else if (JOY_NEW(DPAD_UP)) + { + if (TryMoveDigit(&data->modifyArrows, TRUE)) + { + data->isFemale = FALSE; + PrintDigitChars(data); + UpdateBattlerValue(data); + ReloadPokemonSprites(data); + data->animIdBack = GetSpeciesBackAnimSet(data->currentmonId) + 1; + data->animIdFront = sMonFrontAnimIdsTable[data->currentmonId - 1]; + UpdateMonAnimNames(taskId); + data->offsetsSpriteValues.offset_back_picCoords = 0; + data->offsetsSpriteValues.offset_front_picCoords = 0; + data->offsetsSpriteValues.offset_front_elevation = 0; + } + + PlaySE(SE_DEX_SCROLL); + } + else if (JOY_NEW(DPAD_LEFT)) + { + if (data->modifyArrows.currentDigit != 0) + { + data->modifyArrows.currentDigit--; + gSprites[data->modifyArrows.arrowSpriteId[0]].x2 -= 6; + gSprites[data->modifyArrows.arrowSpriteId[1]].x2 -= 6; + } + } + else if (JOY_NEW(DPAD_RIGHT)) + { + if (data->modifyArrows.currentDigit != (data->modifyArrows.maxDigits - 1)) + { + data->modifyArrows.currentDigit++; + gSprites[data->modifyArrows.arrowSpriteId[0]].x2 += 6; + gSprites[data->modifyArrows.arrowSpriteId[1]].x2 += 6; + } + } + + } + else if (data->currentSubmenu == 1) //Submenu 1 + { + if (JOY_NEW(A_BUTTON)) + { + data->currentSubmenu = 2; + PrintInstructionsOnWindow(data); + SetArrowInvisibility(data); + UpdateYPosOffsetText(data); + } + else if (JOY_NEW(B_BUTTON)) + { + data->currentSubmenu = 0; + if (data->submenuYpos[1] == 3) + { + data->submenuYpos[1] = 2; + data->optionArrows.currentDigit = data->submenuYpos[1]; + gSprites[data->optionArrows.arrowSpriteId[0]].y = OPTIONS_ARROW_Y + data->optionArrows.currentDigit * 12; + } + SetArrowInvisibility(data); + PrintInstructionsOnWindow(data); + } + else if (JOY_NEW(DPAD_DOWN)) + { + data->submenuYpos[1] += 1; + if (data->submenuYpos[1] >= 3) + { + if ((gFormSpeciesIdTables[data->currentmonId] == NULL) || (data->submenuYpos[1] >= 4)) + data->submenuYpos[1] = 0; + } + data->optionArrows.currentDigit = data->submenuYpos[1]; + gSprites[data->optionArrows.arrowSpriteId[0]].y = OPTIONS_ARROW_Y + data->optionArrows.currentDigit * 12; + } + else if (JOY_NEW(DPAD_UP)) + { + if (data->submenuYpos[1] == 0) + { + if (gFormSpeciesIdTables[data->currentmonId] != NULL) + data->submenuYpos[1] = 3; + else + data->submenuYpos[1] = 2; + } + else + data->submenuYpos[1] -= 1; + + data->optionArrows.currentDigit = data->submenuYpos[1]; + gSprites[data->optionArrows.arrowSpriteId[0]].y = OPTIONS_ARROW_Y + data->optionArrows.currentDigit * 12; + } + else if (JOY_NEW(DPAD_LEFT)) + { + UpdateSubmenuOneOptionValue(taskId, FALSE); + } + else if (JOY_NEW(DPAD_RIGHT)) + { + UpdateSubmenuOneOptionValue(taskId, TRUE); + } + } + else if (data->currentSubmenu == 2) //Submenu 2 + { + if (JOY_NEW(B_BUTTON)) + { + data->currentSubmenu = 1; + + SetArrowInvisibility(data); + PrintInstructionsOnWindow(data); + UpdateMonAnimNames(taskId); + } + else if (JOY_NEW(DPAD_DOWN)) + { + data->submenuYpos[2] += 1; + if (data->submenuYpos[2] >= 3) + data->submenuYpos[2] = 0; + + data->yPosModifyArrows.currentDigit = data->submenuYpos[2]; + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].y = OPTIONS_ARROW_Y + data->yPosModifyArrows.currentDigit * 12; + } + else if (JOY_NEW(DPAD_UP)) + { + if (data->submenuYpos[2] == 0) + data->submenuYpos[2] = 2; + else + data->submenuYpos[2] -= 1; + + data->yPosModifyArrows.currentDigit = data->submenuYpos[2]; + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].y = OPTIONS_ARROW_Y + data->yPosModifyArrows.currentDigit * 12; + } + else if (JOY_NEW(DPAD_LEFT)) + { + UpdateSubmenuTwoOptionValue(taskId, FALSE); + } + else if (JOY_NEW(DPAD_RIGHT)) + { + UpdateSubmenuTwoOptionValue(taskId, TRUE); + } + } +} + +static void ReloadPokemonSprites(struct PokemonDebugMenu *data) +{ + const struct CompressedSpritePalette *palette; + u16 species = data->currentmonId; + s16 offset_y; + u8 front_x = sBattlerCoords[0][1].x; + u8 front_y; + + DestroySprite(&gSprites[data->frontspriteId]); + DestroySprite(&gSprites[data->backspriteId]); + DestroySprite(&gSprites[data->iconspriteId]); + + FreeMonSpritesGfx(); + ResetSpriteData(); + ResetPaletteFade(); + FreeAllSpritePalettes(); + ResetAllPicSprites(); + FreeMonIconPalettes(); + + AllocateMonSpritesGfx(); + LoadMonIconPalette(species); + + //Update instructions + PrintInstructionsOnWindow(data); + + //Palettes + palette = GetMonSpritePalStructCustom(species, data->isFemale, data->isShiny); + LoadCompressedSpritePalette(palette); + //Front + HandleLoadSpecialPokePicCustom(&gMonFrontPicTable[species], gMonSpritesGfxPtr->sprites.ptr[1], species, 0, data->isFemale); + BattleLoadOpponentMonSpriteGfxCustom(species, data->isFemale, data->isShiny, 1); + SetMultiuseSpriteTemplateToPokemon(species, 1); + gMultiuseSpriteTemplate.paletteTag = palette->tag; + front_y = GetBattlerSpriteFinal_YCustom(species, 0, 0); + data->frontspriteId = CreateSprite(&gMultiuseSpriteTemplate, front_x, front_y, 0); + gSprites[data->frontspriteId].oam.paletteNum = 1; + gSprites[data->frontspriteId].callback = SpriteCallbackDummy; + gSprites[data->frontspriteId].oam.priority = 0; + //Front Shadow + LoadAndCreateEnemyShadowSpriteCustom(data, species); + + //Back + HandleLoadSpecialPokePicCustom(&gMonBackPicTable[species], gMonSpritesGfxPtr->sprites.ptr[2], species, 0, data->isFemale); + BattleLoadOpponentMonSpriteGfxCustom(species, data->isFemale, data->isShiny, 5); + SetMultiuseSpriteTemplateToPokemon(species, 2); + offset_y = gMonBackPicCoords[species].y_offset; + data->backspriteId = CreateSprite(&gMultiuseSpriteTemplate, DEBUG_MON_BACK_X, DEBUG_MON_BACK_Y + offset_y, 0); + gSprites[data->backspriteId].oam.paletteNum = 5; + gSprites[data->backspriteId].callback = SpriteCallbackDummy; + gSprites[data->backspriteId].oam.priority = 0; + + //Icon Sprite + data->iconspriteId = CreateMonIconCustom(species, SpriteCB_MonIcon, DEBUG_ICON_X, DEBUG_ICON_Y, 4, data->isShiny, data->isFemale, data->isShiny); + gSprites[data->iconspriteId].oam.priority = 0; + + //Modify Arrows + LoadSpritePalette(&sSpritePalette_Arrow); + data->modifyArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, MODIFY_DIGITS_ARROW_X + (data->modifyArrows.currentDigit * 6), MODIFY_DIGITS_ARROW1_Y, 0); + data->modifyArrows.arrowSpriteId[1] = CreateSprite(&sSpriteTemplate_Arrow, MODIFY_DIGITS_ARROW_X + (data->modifyArrows.currentDigit * 6), MODIFY_DIGITS_ARROW2_Y, 0); + gSprites[data->modifyArrows.arrowSpriteId[1]].animNum = 1; + + //Option Arrow + LoadSpritePalette(&sSpritePalette_Arrow); + data->optionArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, OPTIONS_ARROW_1_X, OPTIONS_ARROW_Y + data->optionArrows.currentDigit * 12, 0); + gSprites[data->optionArrows.arrowSpriteId[0]].animNum = 2; + + //Y Pos Modify Arrow + LoadSpritePalette(&sSpritePalette_Arrow); + data->yPosModifyArrows.arrowSpriteId[0] = CreateSprite(&sSpriteTemplate_Arrow, OPTIONS_ARROW_1_X, OPTIONS_ARROW_Y + data->yPosModifyArrows.currentDigit * 12, 0); + gSprites[data->yPosModifyArrows.arrowSpriteId[0]].animNum = 2; + + //Arrow invisibility + SetArrowInvisibility(data); + + //Footprint + DrawFootprintCustom(WIN_FOOTPRINT, species); + CopyWindowToVram(WIN_FOOTPRINT, COPYWIN_GFX); +} + +static void Exit_Debug_Pokemon(u8 taskId) +{ + if (!gPaletteFade.active) + { + struct PokemonDebugMenu *data = GetStructPtr(taskId); + Free(data); + FreeMonSpritesGfx(); + DestroyTask(taskId); + SetMainCallback2(CB2_ReturnToFieldWithOpenMenu); + m4aMPlayVolumeControl(&gMPlayInfo_BGM, TRACKS_ALL, 0x100); + } +} + +#endif diff --git a/src/pokemon_icon.c b/src/pokemon_icon.c index c7d77d98ad..c140d90d08 100644 --- a/src/pokemon_icon.c +++ b/src/pokemon_icon.c @@ -2,6 +2,7 @@ #include "graphics.h" #include "mail.h" #include "palette.h" +#include "pokemon_debug.h" #include "pokemon_icon.h" #include "sprite.h" #include "data.h" @@ -22,6 +23,10 @@ struct MonIconSpriteTemplate static u8 CreateMonIconSprite(struct MonIconSpriteTemplate *, s16, s16, u8); static void FreeAndDestroyMonIconSprite_(struct Sprite *sprite); +#if P_ENABLE_DEBUG == TRUE +static const u8 *GetMonIconPtrCustom(u16 species, u32 personality, bool8 isFemale); +static const u8* GetMonIconTilesCustom(u16 species, bool8 isFemale); +#endif const u8 *const gMonIconTable[] = { @@ -2573,6 +2578,33 @@ u8 CreateMonIcon(u16 species, void (*callback)(struct Sprite *), s16 x, s16 y, u return spriteId; } +#if P_ENABLE_DEBUG == TRUE +u8 CreateMonIconCustom(u16 species, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority, u32 personality, bool8 isFemale, bool8 isShiny) +{ + u8 spriteId; + struct MonIconSpriteTemplate iconTemplate = + { + .oam = &sMonIconOamData, + .image = GetMonIconPtrCustom(species, personality, isFemale), + .anims = sMonIconAnims, + .affineAnims = sMonIconAffineAnims, + .callback = callback, + .paletteTag = POKE_ICON_BASE_PAL_TAG + gMonIconPaletteIndices[species], + }; + + if (species > NUM_SPECIES) + iconTemplate.paletteTag = POKE_ICON_BASE_PAL_TAG; + else if (SpeciesHasGenderDifference[species] && isFemale) + iconTemplate.paletteTag = POKE_ICON_BASE_PAL_TAG + gMonIconPaletteIndicesFemale[species]; + + spriteId = CreateMonIconSprite(&iconTemplate, x, y, subpriority); + + UpdateMonIconFrame(&gSprites[spriteId]); + + return spriteId; +} +#endif + u8 CreateMonIconNoPersonality(u16 species, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) { u8 spriteId; @@ -2644,6 +2676,13 @@ const u8 *GetMonIconPtr(u16 species, u32 personality) return GetMonIconTiles(GetIconSpecies(species, personality), personality); } +#if P_ENABLE_DEBUG == TRUE +static const u8 *GetMonIconPtrCustom(u16 species, u32 personality, bool8 isFemale) +{ + return GetMonIconTilesCustom(GetIconSpecies(species, personality), isFemale); +} +#endif + void FreeAndDestroyMonIconSprite(struct Sprite *sprite) { FreeAndDestroyMonIconSprite_(sprite); @@ -2712,6 +2751,17 @@ const u8* GetMonIconTiles(u16 species, u32 personality) } return iconSprite; } +#if P_ENABLE_DEBUG == TRUE +static const u8* GetMonIconTilesCustom(u16 species, bool8 isFemale) +{ + const u8* iconSprite = gMonIconTable[species]; + if (SpeciesHasGenderDifference[species] && isFemale) + { + iconSprite = gMonIconTableFemale[species]; + } + return iconSprite; +} +#endif void TryLoadAllMonIconPalettesAtOffset(u16 offset) { diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c index 406a6f8e0e..676fb5a45a 100644 --- a/src/pokemon_summary_screen.c +++ b/src/pokemon_summary_screen.c @@ -28,6 +28,7 @@ #include "palette.h" #include "pokeball.h" #include "pokemon.h" +#include "pokemon_debug.h" #include "pokemon_storage_system.h" #include "pokemon_summary_screen.h" #include "region_map.h" @@ -1555,6 +1556,15 @@ static void Task_HandleInput(u8 taskId) PlaySE(SE_SELECT); BeginCloseSummaryScreen(taskId); } + #if P_ENABLE_DEBUG == TRUE + else if (JOY_NEW(SELECT_BUTTON) && !gMain.inBattle) + { + sMonSummaryScreen->callback = CB2_Debug_Pokemon; + StopPokemonAnimations(); + PlaySE(SE_SELECT); + CloseSummaryScreen(taskId); + } + #endif } } diff --git a/src/reset_rtc_screen.c b/src/reset_rtc_screen.c index 25e3a73302..34c388969d 100644 --- a/src/reset_rtc_screen.c +++ b/src/reset_rtc_screen.c @@ -181,7 +181,7 @@ static const struct SpriteFrameImage sPicTable_Arrow[] = obj_frame_tiles(sArrowRight_Gfx) }; -static const struct SpritePalette sSpritePalette_Arrow = +const struct SpritePalette sSpritePalette_Arrow = { sArrow_Pal, PALTAG_ARROW }; @@ -217,7 +217,7 @@ static const union AnimCmd *const sAnims_Arrow[] = [ARROW_RIGHT] = sAnim_Arrow_Right, }; -static const struct SpriteTemplate sSpriteTemplate_Arrow = +const struct SpriteTemplate sSpriteTemplate_Arrow = { .tileTag = TAG_NONE, .paletteTag = PALTAG_ARROW,