Leahnaya/pokefirered
1
0
Fork 0
mirror of https://github.com/pret/pokefirered.git synced 2026-07-19 17:23:22 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Document Pokemon storage system

Browse Source
This commit is contained in:
cbt6 2022-09-03 23:27:56 +08:00
parent a30ea109c1
commit 859ca7994e
16 changed files with 3645 additions and 3581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/box_party_pokemon_dropdown.h
View File

@ -1,24 +1,12 @@
#ifndef GUARD_BOX_PARTY_POKEMON_DROPDOWN_H
#define GUARD_BOX_PARTY_POKEMON_DROPDOWN_H
enum
{
BPPD_MOVE_INNER_LEFT = 0,
BPPD_MOVE_OUTER_LEFT,
BPPD_MOVE_INNER_TOP,
BPPD_MOVE_OUTER_TOP,
BPPD_MOVE_INNER_X,
BPPD_MOVE_INNER_Y
};
void AllocBoxPartyPokemonDropdowns(u8 num);
void FreeBoxPartyPokemonDropdowns(void);
void CopyAllBoxPartyPokemonDropdownsToVram(void);
void SetBoxPartyPokemonDropdownMap2(u8 idx, u8 bgId, const void *src, u16 width, u16 height);
void SetBoxPartyPokemonDropdownMap1Tiles(u8 idx, const void *src);
void SetBoxPartyPokemonDropdownMap2Pos(u8 idx, u16 x, u16 y);
void SetBoxPartyPokemonDropdownMap2Rect(u8 idx, u16 x, u16 y, u16 width, u16 height);
void AdjustBoxPartyPokemonDropdownPos(u8 a0, u8 a1, s8 a2);
void CopyBoxPartyPokemonDropdownToBgTilemapBuffer(u8 idx);
void TilemapUtil_Init(u8 numTilemapIds);
void TilemapUtil_Free(void);
void TilemapUtil_SetTilemap(u8 tilemapId, u8 bg, const void *tilemap, u16 width, u16 height);
void TilemapUtil_SetPos(u8 tilemapId, u16 destX, u16 destY);
void TilemapUtil_SetRect(u8 tilemapId, u16 x, u16 y, u16 width, u16 height);
void TilemapUtil_Move(u8 tilemapId, u8 mode, s8 param);
void TilemapUtil_Update(u8 tilemapId);
#endif //GUARD_BOX_PARTY_POKEMON_DROPDOWN_H

10
include/graphics.h
View File

@ -4928,11 +4928,11 @@ extern const u16 gNamingScreenInputArrow_Gfx[];
extern const u16 gNamingScreenUnderscore_Gfx[];
// pokemon_storage_system
extern const u32 gPSSMenu_Gfx[];
extern const u32 gUnknown_8E9CAEC[];
extern const u16 gPSSMenu_Pal[];
extern const u16 gUnknown_8E9C3F8[];
extern const u16 gUnknown_8E9C418[];
extern const u32 gPokeStorageMenu_Gfx[];
extern const u32 gPokeStoragePartyMenu_Tilemap[];
extern const u16 gPokeStoragePartyMenu_Pal[];
extern const u16 gPokeStorageInterface_Pal[];
extern const u16 gPokeStorageInterface_NoDisplayMon_Pal[];
// pokedex_screen
extern const u16 gDexScreen_TopMenuIconPals_AtoZ[];

21
include/pokemon_storage_system.h
View File

@ -4,7 +4,18 @@
#include "global.h"
#define TOTAL_BOXES_COUNT 14
#define IN_BOX_COUNT 30
#define IN_BOX_ROWS 5 // Number of rows, 6 Pokémon per row
#define IN_BOX_COLUMNS 6 // Number of columns, 5 Pokémon per column
#define IN_BOX_COUNT (IN_BOX_ROWS * IN_BOX_COLUMNS)
/*
COLUMNS
ROWS 0 1 2 3 4 5
6 7 8 9 10 11
12 13 14 15 16 17
18 19 20 21 22 23
24 25 26 27 28 29
*/
enum
{
@ -20,10 +31,10 @@ enum
WALLPAPER_SEAFLOOR,
WALLPAPER_RIVER,
WALLPAPER_SKY,
WALLPAPER_POLKADOT,
WALLPAPER_STARS,
WALLPAPER_POKECENTER,
WALLPAPER_MACHINE,
WALLPAPER_PLAIN,
WALLPAPER_TILES,
WALLPAPER_SIMPLE,
WALLPAPER_COUNT
};
#define MAX_DEFAULT_WALLPAPER WALLPAPER_SAVANNA
@ -34,7 +45,7 @@ void SetBoxMonNickAt(u8 boxId, u8 monPosition, const u8 *newNick);
s16 CompactPartySlots(void);
u32 GetBoxMonDataAt(u8 boxId, u8 monPosition, s32 request);
void ZeroBoxMonAt(u8 boxId, u8 monPosition);
void Cb2_ReturnToPSS(void);
void CB2_ReturnToPokeStorage(void);
void ResetPokemonStorageSystem(void);
u8 StorageGetCurrentBox(void);
void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero2, u8 *buffer, s32 bytesToBuffer);

625
include/pokemon_storage_system_internal.h
View File

@ -4,9 +4,6 @@
#include "pokemon_storage_system.h"
#include "mon_markings.h"
#define IN_BOX_COLUMNS 5
#define IN_BOX_ROWS 6
// The maximum number of Pokémon icons that can appear on-screen.
// By default the limit is 40 (though in practice only 37 can be).
#define MAX_MON_ICONS (IN_BOX_COUNT + PARTY_SIZE + 1 >= 40 ? IN_BOX_COUNT + PARTY_SIZE + 1 : 40)
@ -16,13 +13,6 @@
// between 2 Pokémon with held items
#define MAX_ITEM_ICONS 3
enum
{
MODE_PARTY,
MODE_BOX,
MODE_2,
};
enum
{
OPTION_WITHDRAW,
@ -35,139 +25,200 @@ enum
enum
{
PC_TEXT_EXIT_BOX,
PC_TEXT_WHAT_YOU_DO,
PC_TEXT_PICK_A_THEME,
PC_TEXT_PICK_A_WALLPAPER,
PC_TEXT_IS_SELECTED,
PC_TEXT_JUMP_TO_WHICH_BOX,
PC_TEXT_DEPOSIT_IN_WHICH_BOX,
PC_TEXT_WAS_DEPOSITED,
PC_TEXT_BOX_IS_FULL,
PC_TEXT_RELEASE_POKE,
PC_TEXT_WAS_RELEASED,
PC_TEXT_BYE_BYE,
PC_TEXT_MARK_POKE,
PC_TEXT_LAST_POKE,
PC_TEXT_PARTY_FULL,
PC_TEXT_HOLDING_POKE,
PC_TEXT_WHICH_ONE_WILL_TAKE,
PC_TEXT_CANT_RELEASE_EGG,
PC_TEXT_CONTINUE_BOX,
PC_TEXT_CAME_BACK,
PC_TEXT_WORRIED,
PC_TEXT_SURPRISE,
PC_TEXT_PLEASE_REMOVE_MAIL,
PC_TEXT_IS_SELECTED2,
PC_TEXT_GIVE_TO_MON,
PC_TEXT_PLACED_IN_BAG,
PC_TEXT_BAG_FULL,
PC_TEXT_PUT_IN_BAG,
PC_TEXT_ITEM_IS_HELD,
PC_TEXT_CHANGED_TO_ITEM,
PC_TEXT_CANT_STORE_MAIL,
MENU_TEXT_CANCEL,
MENU_TEXT_STORE,
MENU_TEXT_WITHDRAW,
MENU_TEXT_MOVE,
MENU_TEXT_SHIFT,
MENU_TEXT_PLACE,
MENU_TEXT_SUMMARY,
MENU_TEXT_RELEASE,
MENU_TEXT_MARK,
MENU_TEXT_JUMP,
MENU_TEXT_WALLPAPER,
MENU_TEXT_NAME,
MENU_TEXT_TAKE,
MENU_TEXT_GIVE,
MENU_TEXT_GIVE2,
MENU_TEXT_SWITCH,
MENU_TEXT_BAG,
MENU_TEXT_INFO,
MENU_TEXT_SCENERY_1,
MENU_TEXT_SCENERY_2,
MENU_TEXT_SCENERY_3,
MENU_TEXT_ETCETERA,
MENU_TEXT_FOREST,
MENU_TEXT_CITY,
MENU_TEXT_DESERT,
MENU_TEXT_SAVANNA,
MENU_TEXT_CRAG,
MENU_TEXT_VOLCANO,
MENU_TEXT_SNOW,
MENU_TEXT_CAVE,
MENU_TEXT_BEACH,
MENU_TEXT_SEAFLOOR,
MENU_TEXT_RIVER,
MENU_TEXT_SKY,
MENU_TEXT_POLKADOT,
MENU_TEXT_POKECENTER,
MENU_TEXT_MACHINE,
MENU_TEXT_SIMPLE,
};
// Return IDs for input handlers
enum {
INPUT_NONE,
INPUT_MOVE_CURSOR,
INPUT_2, // Unused
INPUT_3, // Unused
INPUT_CLOSE_BOX,
INPUT_SHOW_PARTY,
INPUT_HIDE_PARTY,
INPUT_BOX_OPTIONS,
INPUT_IN_MENU,
INPUT_SCROLL_RIGHT,
INPUT_SCROLL_LEFT,
INPUT_DEPOSIT,
INPUT_WITHDRAW,
INPUT_MOVE_MON,
INPUT_SHIFT_MON,
INPUT_PLACE_MON,
INPUT_TAKE_ITEM,
INPUT_GIVE_ITEM,
INPUT_SWITCH_ITEMS,
INPUT_PRESSED_B,
INPUT_MULTIMOVE_START,
INPUT_MULTIMOVE_CHANGE_SELECTION,
INPUT_MULTIMOVE_SINGLE,
INPUT_MULTIMOVE_GRAB_SELECTION,
INPUT_MULTIMOVE_UNABLE,
INPUT_MULTIMOVE_MOVE_MONS,
INPUT_MULTIMOVE_PLACE_MONS,
};
enum
{
PC_TEXT_FMT_NORMAL,
PC_TEXT_FMT_MON_NAME_1,
PC_TEXT_FMT_MON_NAME_2,
PC_TEXT_FMT_MON_NAME_3,
PC_TEXT_FMT_MON_NAME_4,
PC_TEXT_FMT_MON_NAME_5,
PC_TEXT_FMT_MON_NAME_6,
PC_TEXT_FMT_ITEM_NAME,
RELEASE_MON_NOT_ALLOWED,
RELEASE_MON_ALLOWED,
RELEASE_MON_UNDETERMINED = -1,
};
enum
{
PC_TEXT_CANCEL,
PC_TEXT_STORE,
PC_TEXT_WITHDRAW,
PC_TEXT_MOVE,
PC_TEXT_SHIFT,
PC_TEXT_PLACE,
PC_TEXT_SUMMARY,
PC_TEXT_RELEASE,
PC_TEXT_MARK,
PC_TEXT_JUMP,
PC_TEXT_WALLPAPER,
PC_TEXT_NAME,
PC_TEXT_TAKE,
PC_TEXT_GIVE,
PC_TEXT_GIVE2,
PC_TEXT_SWITCH,
PC_TEXT_BAG,
PC_TEXT_INFO,
PC_TEXT_SCENERY1,
PC_TEXT_SCENERY2,
PC_TEXT_SCENERY3,
PC_TEXT_ETCETERA,
PC_TEXT_FOREST,
PC_TEXT_CITY,
PC_TEXT_DESERT,
PC_TEXT_SAVANNA,
PC_TEXT_CRAG,
PC_TEXT_VOLCANO,
PC_TEXT_SNOW,
PC_TEXT_CAVE,
PC_TEXT_BEACH,
PC_TEXT_SEAFLOOR,
PC_TEXT_RIVER,
PC_TEXT_SKY,
PC_TEXT_POLKADOT,
PC_TEXT_POKECENTER,
PC_TEXT_MACHINE,
PC_TEXT_SIMPLE,
MODE_PARTY,
MODE_BOX,
MODE_MOVE,
};
enum
{
CURSOR_AREA_IN_BOX,
CURSOR_AREA_IN_PARTY,
CURSOR_AREA_BOX,
CURSOR_AREA_BOX_TITLE,
CURSOR_AREA_BUTTONS, // Party Pokemon and Close Box
};
#define CURSOR_AREA_IN_HAND CURSOR_AREA_BOX_TITLE // Alt name for cursor area used by Move Items
// IDs for InitMonPlaceChange
enum
{
CHANGE_GRAB,
CHANGE_PLACE,
CHANGE_SHIFT,
};
// IDs for the main functions for moving multiple Pokémon.
// Given as arguments to MultiMove_SetFunction
enum
{
MULTIMOVE_START,
MULTIMOVE_SINGLE,
MULTIMOVE_CHANGE_SELECTION,
MULTIMOVE_GRAB_SELECTION,
MULTIMOVE_MOVE_MONS,
MULTIMOVE_PLACE_MONS,
};
enum
{
SCREEN_CHANGE_EXIT_BOX,
SCREEN_CHANGE_SUMMARY_SCREEN,
SCREEN_CHANGE_NAME_BOX,
SCREEN_CHANGE_ITEM_FROM_BAG,
PALTAG_MON_ICON_0 = 56000,
PALTAG_MON_ICON_1, // Used implicitly in CreateMonIconSprite
PALTAG_MON_ICON_2, // Used implicitly in CreateMonIconSprite
PALTAG_3, // Unused
PALTAG_4, // Unused
PALTAG_5, // Unused
PALTAG_DISPLAY_MON,
PALTAG_MISC_1, // Used by cursor in multimove mode, choose box menu popup
PALTAG_MARKING_COMBO,
PALTAG_BOX_TITLE,
PALTAG_MISC_2, // Used by waveforms, cursor in normal mode, cursor shadow, box scroll arrows
PALTAG_ITEM_ICON_0,
PALTAG_ITEM_ICON_1, // Used implicitly in CreateItemIconSprites
PALTAG_ITEM_ICON_2, // Used implicitly in CreateItemIconSprites
PALTAG_MARKING_MENU,
};
#define TAG_PAL_WAVEFORM 0xDACA
#define TAG_PAL_DAC8 0xDAC8
#define TAG_PAL_DAC6 0xDAC6
#define TAG_PAL_DACE 0xDACE
#define TAG_PAL_DAC7 0xDAC7
#define TAG_PAL_DAC9 0xDAC9
#define TAG_PAL_DAC0 0xDAC0
#define TAG_PAL_DACB 0xDACB
enum
{
GFXTAG_CURSOR,
GFXTAG_CURSOR_SHADOW,
GFXTAG_DISPLAY_MON,
GFXTAG_BOX_TITLE,
GFXTAG_BOX_TITLE_ALT,
GFXTAG_WAVEFORM,
GFXTAG_BOX_SCROLL_ARROW,
GFXTAG_ITEM_ICON_0,
GFXTAG_ITEM_ICON_1, // Used implicitly in CreateItemIconSprites
GFXTAG_ITEM_ICON_2, // Used implicitly in CreateItemIconSprites
GFXTAG_CHOOSE_BOX_MENU_CENTER,
GFXTAG_CHOOSE_BOX_MENU_CORNERS, // Used implicitly in LoadChooseBoxMenuGfx
GFXTAG_12, // Unused
GFXTAG_MARKING_MENU,
GFXTAG_14, // Unused
GFXTAG_15, // Unused
GFXTAG_MARKING_COMBO,
GFXTAG_17, // Unused
GFXTAG_MON_ICON,
};
#define TAG_TILE_WAVEFORM 0x5
#define TAG_TILE_10 0x10
#define TAG_TILE_2 0x2
#define TAG_TILE_D 0xD
#define TAG_TILE_A 0xA
#define TAG_TILE_3 0x3
#define TAG_TILE_4 0x4
#define TAG_TILE_12 0x12
#define TAG_TILE_7 0x7
#define TAG_TILE_0 0x0
#define TAG_TILE_1 0x1
#define TAG_TILE_6 0x6
// Special box ids for the choose box menu
#define BOXID_NONE_CHOSEN 200
#define BOXID_CANCELED 201
struct WallpaperTable
enum {
CURSOR_ANIM_BOUNCE,
CURSOR_ANIM_STILL,
CURSOR_ANIM_OPEN,
CURSOR_ANIM_FIST,
};
enum
{
RELEASE_ANIM_RELEASE,
RELEASE_ANIM_COME_BACK,
};
// IDs for the item icons affine anims
enum
{
ITEM_ANIM_NONE,
ITEM_ANIM_APPEAR,
ITEM_ANIM_DISAPPEAR,
ITEM_ANIM_PICK_UP,
ITEM_ANIM_PUT_DOWN,
ITEM_ANIM_PUT_AWAY,
ITEM_ANIM_LARGE,
};
struct Wallpaper
{
const u32 *tiles;
const u32 *tileMap;
const u16 *palettes;
};
struct StorageAction
struct StorageMessage
{
const u8 *text;
u8 format;
@ -176,7 +227,7 @@ struct StorageAction
struct ChooseBoxMenu
{
struct Sprite *menuSprite;
struct Sprite *menuSideSprites[4];
struct Sprite *menuCornerSprites[4];
u32 unused1[3];
struct Sprite *arrowSprites[2];
u8 buffer[0x200]; // passed but not used
@ -212,7 +263,7 @@ struct UnkUtil
u8 max;
};
struct PSS_ItemIconSprite
struct PokeStorageItemIcon
{
struct Sprite *sprite;
u8 *tiles;
@ -222,12 +273,12 @@ struct PSS_ItemIconSprite
u8 active;
};
struct PssQuestLogBuffer
struct PokeStorageQuestLogData
{
u16 species;
u16 species1;
u16 species2;
u8 fromBox;
u8 toBox;
u8 box1;
u8 box2;
};
struct PokemonStorageSystemData
@ -235,7 +286,7 @@ struct PokemonStorageSystemData
u8 state;
u8 boxOption;
u8 screenChangeType;
bool8 isReshowingPSS;
bool8 isReopening;
u8 taskId;
struct UnkUtil unkUtil;
struct UnkUtilData unkUtilData[8];
@ -262,8 +313,8 @@ struct PokemonStorageSystemData
u16 scrollUnused5; // Never read
u16 scrollUnused6; // Never read
u8 filler1[22];
u8 field_2F8[512];
u8 field_4F8[512];
u8 boxTitleTiles[512];
u8 boxTitleUnused[512];
u8 boxTitleCycleId;
u8 wallpaperLoadState; // Written to, but never read.
u8 wallpaperLoadBoxId;
@ -276,7 +327,7 @@ struct PokemonStorageSystemData
struct Sprite *arrowSprites[2];
u32 wallpaperPalBits;
u8 filler2[80]; // Unused
u16 unkUnused1; // Never read.
u16 unusedField1; // Never read.
s16 wallpaperSetId;
s16 wallpaperId;
u16 wallpaperTilemap[360];
@ -285,112 +336,114 @@ struct PokemonStorageSystemData
u8 scrollToBoxId;
s8 scrollDirection;
// u8 *wallpaperTiles; // used only in Emerald for Walda
/* 0a68 */ struct Sprite *movingMonSprite;
/* 0a6c */ struct Sprite *partySprites[PARTY_SIZE];
/* 0a84 */ struct Sprite *boxMonsSprites[IN_BOX_COUNT];
/* 0afc */ struct Sprite **shiftMonSpritePtr;
/* 0b00 */ struct Sprite **releaseMonSpritePtr;
/* 0b04 */ u16 numIconsPerSpecies[MAX_MON_ICONS];
/* 0b54 */ u16 iconSpeciesList[MAX_MON_ICONS];
/* 0ba4 */ u16 boxSpecies[IN_BOX_COUNT];
/* 0be0 */ u32 boxPersonalities[IN_BOX_COUNT];
/* 0c58 */ u8 incomingBoxId;
/* 0c59 */ u8 shiftTimer;
/* 0c5a */ u8 numPartyToCompact;
/* 0c5c */ u16 iconScrollDistance;
/* 0c5e */ s16 iconScrollPos;
/* 0c60 */ s16 iconScrollSpeed;
/* 0c62 */ u16 iconScrollNumIncoming;
/* 0c64 */ u8 iconScrollCurColumn;
/* 0c65 */ s8 iconScrollDirection; // Unnecessary duplicate of scrollDirection
/* 0c66 */ u8 iconScrollState;
/* 0c67 */ u8 iconScrollToBoxId; // Unused duplicate of scrollToBoxId
/* 0c68 */ struct WindowTemplate menuWindow;
/* 0c70 */ struct StorageMenu menuItems[7];
/* 0ca8 */ u8 menuItemsCount;
/* 0ca9 */ u8 menuWidth;
/* 0caa */ u8 menuUnusedField; // Never read.
/* 0cac */ u16 menuWindowId;
/* 0cb0 */ struct Sprite *cursorSprite;
/* 0cb4 */ struct Sprite *cursorShadowSprite;
/* 0cb8 */ s32 cursorNewX;
/* 0cbc */ s32 cursorNewY;
/* 0cc0 */ u32 cursorSpeedX;
/* 0cc4 */ u32 cursorSpeedY;
/* 0cc8 */ s16 cursorTargetX;
/* 0cca */ s16 cursorTargetY;
/* 0ccc */ u16 cursorMoveSteps;
/* 0cce */ s8 cursorVerticalWrap;
/* 0ccf */ s8 cursorHorizontalWrap;
/* 0cd0 */ u8 newCursorArea;
/* 0cd1 */ u8 newCursorPosition;
/* 0cd2 */ u8 cursorPrevHorizPos;
/* 0cd3 */ u8 cursorFlipTimer;
/* 0cd4 */ u8 cursorPalNums[2];
/* 0cd8 */ const u32 *displayMonPalette;
/* 0cdc */ u32 displayMonPersonality;
/* 0ce0 */ u16 displayMonSpecies;
/* 0ce2 */ u16 displayMonItemId;
/* 0ce4 */ u16 displayUnusedVar;
/* 0ce6 */ bool8 setMosaic;
/* 0ce7 */ u8 displayMonMarkings;
/* 0ce8 */ u8 displayMonLevel;
/* 0ce9 */ bool8 displayMonIsEgg;
/* 0cea */ u8 displayMonName[POKEMON_NAME_LENGTH + 1];
/* 0cf5 */ u8 displayMonTexts[4][36];
/* 0d88 */ bool8 (*monPlaceChangeFunc)(void);
/* 0d8c */ u8 monPlaceChangeState;
/* 0d8d */ u8 shiftBoxId;
/* 0d90 */ struct Sprite *markingComboSprite;
/* 0d94 */ struct Sprite *waveformSprites[2];
/* 0d9c */ u16 *markingComboTilesPtr;
/* 0da0 */ struct MonMarkingsMenu markMenu;
/* 1e58 */ struct ChooseBoxMenu field_1E5C;
/* 20a0 */ struct Pokemon movingMon;
/* 2104 */ struct Pokemon field_2108;
/* 2168 */ u8 field_216C;
/* 2169 */ u8 field_216D;
/* 216c */ bool8 isSurfMon;
/* 216d */ bool8 isDiveMon;
/* 216a */ s8 field_216E;
/* 216b */ s8 field_216F;
/* 216e */ s8 field_2170;
/* 216f */ s8 field_2171;
/* 2170 */ u16 field_2172;
/* 2172 */ u16 field_2176[3];
/* 2178 */ u8 field_2186;
/* 2179 */ u8 field_2187;
/* 217a */ u8 summaryScreenMode;
/* 217c */ union
struct Sprite *movingMonSprite;
struct Sprite *partySprites[PARTY_SIZE];
struct Sprite *boxMonsSprites[IN_BOX_COUNT];
struct Sprite **shiftMonSpritePtr;
struct Sprite **releaseMonSpritePtr;
u16 numIconsPerSpecies[MAX_MON_ICONS];
u16 iconSpeciesList[MAX_MON_ICONS];
u16 boxSpecies[IN_BOX_COUNT];
u32 boxPersonalities[IN_BOX_COUNT];
u8 incomingBoxId;
u8 shiftTimer;
u8 numPartySpritesToCompact;
u16 iconScrollDistance;
s16 iconScrollPos;
s16 iconScrollSpeed;
u16 iconScrollNumIncoming;
u8 iconScrollCurColumn;
s8 iconScrollDirection; // Unnecessary duplicate of scrollDirection
u8 iconScrollState;
u8 iconScrollToBoxId; // Unused duplicate of scrollToBoxId
struct WindowTemplate menuWindow;
struct StorageMenu menuItems[7];
u8 menuItemsCount;
u8 menuWidth;
u8 menuUnusedField; // Never read.
u16 menuWindowId;
struct Sprite *cursorSprite;
struct Sprite *cursorShadowSprite;
s32 cursorNewX;
s32 cursorNewY;
u32 cursorSpeedX;
u32 cursorSpeedY;
s16 cursorTargetX;
s16 cursorTargetY;
u16 cursorMoveSteps;
s8 cursorVerticalWrap;
s8 cursorHorizontalWrap;
u8 newCursorArea;
u8 newCursorPosition;
u8 cursorPrevPartyPos;
u8 cursorFlipTimer;
u8 cursorPalNums[2];
const u32 *displayMonPalette;
u32 displayMonPersonality;
u16 displayMonSpecies;
u16 displayMonItemId;
u16 displayUnusedVar;
bool8 setMosaic;
u8 displayMonMarkings;
u8 displayMonLevel;
bool8 displayMonIsEgg;
u8 displayMonNickname[POKEMON_NAME_LENGTH + 1];
u8 displayMonTexts[4][36]; // nickname, species name, gender and level, item name
bool8 (*monPlaceChangeFunc)(void);
u8 monPlaceChangeState;
u8 shiftBoxId;
struct Sprite *markingComboSprite;
struct Sprite *waveformSprites[2];
u16 *markingComboTilesPtr;
struct MonMarkingsMenu markMenu;
struct ChooseBoxMenu chooseBoxMenu;
struct Pokemon movingMon;
struct Pokemon tempMon;
s8 releaseMonStatus;
bool8 releaseMonStatusResolved;
bool8 isSurfMon;
bool8 isDiveMon;
s8 releaseCheckBoxId;
s8 releaseCheckBoxPos;
s8 releaseBoxId;
s8 releaseBoxPos;
u16 releaseCheckState;
u16 restrictedMoveList[3];
u8 summaryLastIndex;
u8 summaryCursorPos;
u8 summaryScreenMode;
union
{
struct Pokemon *mon;
struct BoxPokemon *box;
} field_218C;
/* 2180 */ u8 field_2190[40];
/* 21a8 */ u8 field_21B8[40];
/* 21d0 */ u8 field_21E0[POKEMON_NAME_LENGTH + 1];
/* 21db */ u8 itemName[20];
/* 21ef */ u8 inBoxMovingMode;
/* 21f0 */ u16 field_2200;
/* 21f4 */ struct PSS_ItemIconSprite itemIcons[MAX_ITEM_ICONS];
/* 2224 */ u16 movingItemId;
/* 2226 */ u16 itemInfoWindowOffset;
/* 2228 */ struct PssQuestLogBuffer qlogBuffer;
/* 2230 */ u16 field_2238;
/* 2232 */ u16 field_223A;
/* 2234 */ u16 *field_223C;
/* 2238 */ struct Sprite *cursorMonSprite;
/* 223c */ u16 field_2244[0x40];
/* 22bc */ u8 field_22C4[0x800];
/* 2abc */ u8 field_2AC4[0x1800];
/* 42bc */ u8 itemIconBuffer[0x800];
/* 4abc */ u8 field_4AC4[0x1000];
/* 5abc */ u8 field_5AC4[0x800];
}; // size=62bc
} summaryMonPtr;
u8 actionText[40];
u8 boxTitleText[40];
u8 releaseMonName[POKEMON_NAME_LENGTH + 1];
u8 itemName[20];
u8 inBoxMovingMode;
u16 multiMoveWindowId;
struct PokeStorageItemIcon itemIcons[MAX_ITEM_ICONS];
u16 movingItemId;
u16 itemInfoWindowOffset;
struct PokeStorageQuestLogData pokeStorageQuestLogData;
u16 unusedField2;
u16 displayMonPalOffset;
u16 *displayMonTilePtr;
struct Sprite *displayMonSprite;
u16 displayMonPalBuffer[0x20];
u8 unusedBuffer1[0x40];
u8 tileBuffer[0x800];
u8 unusedBuffer2[0x1800];
u8 itemIconBuffer[0x200];
u8 unusedBuffer3[0x600];
u8 wallpaperBgTilemapBuffer[0x1000];
u8 menuTilemapBuffer[0x800];
};
extern struct PokemonStorageSystemData *gPSSData;
extern struct PokemonStorageSystemData *gStorage;
void Cb2_EnterPSS(u8 a0);
void EnterPokeStorage(u8 boxOption);
u8 GetCurrentBoxOption(void);
struct Sprite *CreateChooseBoxArrows(u16 x, u16 y, u8 animId, u8 priority, u8 subpriority);
void SetBoxWallpaper(u8 boxId, u8 wallpaperId);
@ -400,46 +453,46 @@ void SetBoxMonAt(u8 boxId, u8 boxPosition, struct BoxPokemon * src);
void CB2_ExitPokeStorage(void);
void FreeBoxSelectionPopupSpriteGfx(void);
void sub_808C940(u8 curBox);
void sub_808C950(void);
void CreateChooseBoxMenuSprites(u8 curBox);
void DestroyChooseBoxMenuSprites(void);
u8 HandleBoxChooseSelectionInput(void);
void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *a0, u16 tileTag, u16 palTag, u8 a3, bool32 loadPal);
void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *menu, u16 tileTag, u16 palTag, u8 subpriority, bool32 loadPal);
void SetCurrentBoxMonData(u8 boxPosition, s32 request, const void *value);
u32 GetCurrentBoxMonData(u8 boxPosition, s32 request);
u32 GetAndCopyBoxMonDataAt(u8 boxId, u8 boxPosition, s32 request, void *dst);
void sub_80922C0(void);
void sub_8092340(void);
bool8 sub_80924A8(void);
void sub_8092AE4(void);
void sub_8092B3C(u8 a0);
void sub_8092B50(void);
void sub_8092B5C(void);
u8 sub_8092B70(void);
void sub_8092F54(void);
void sub_8093174(void);
void sub_8093194(void);
bool8 sub_80931EC(void);
void sub_8093264(void);
void sub_8093630(void);
void sub_8093660(void);
void sub_80936B8(void);
void sub_80937B4(void);
void sub_8094D14(u8 a0);
u8 sub_8094D34(void);
void sub_8094D60(void);
void sub_8094D84(void);
bool8 sub_8094F90(void);
s16 sub_8094F94(void);
void sub_8095024(void);
bool8 sub_8095050(void);
void sub_80950A4(void);
void sub_80950BC(u8 a0);
bool8 sub_80950D0(void);
void InitCursor(void);
void InitCursorOnReopen(void);
bool8 UpdateCursorPos(void);
void SetCursorInParty(void);
void SetCursorBoxPosition(u8 cursorBoxPosition);
void ClearSavedCursorPos(void);
void SaveCursorPos(void);
u8 GetSavedCursorPos(void);
void DoTrySetDisplayMonData(void);
void ResetSelectionAfterDeposit(void);
void InitReleaseMon(void);
bool8 TryHideReleaseMon(void);
void TrySetCursorFistAnim(void);
void SaveMovingMon(void);
void LoadSavedMovingMon(void);
void InitSummaryScreenData(void);
void SetSelectionAfterSummaryScreen(void);
void StartCursorAnim(u8 animNum);
u8 GetMovingMonOriginalBoxId(void);
void TryHideItemAtCursor(void);
void TryShowItemAtCursor(void);
bool8 IsMenuLoading(void);
s16 HandleMenuInput(void);
void RemoveMenu(void);
bool8 MultiMove_Init(void);
void MultiMove_Free(void);
void MultiMove_SetFunction(u8 funcId);
bool8 MultiMove_RunFunction(void);
void CreateItemIconSprites(void);
void sub_8096088(void);
void sub_80960C0(void);
bool8 sub_809610C(void);
void MoveItemFromCursorToBag(void);
void MoveHeldItemWithPartyMenu(void);
bool8 IsItemIconAnimActive(void);
const u8 *GetMovingItemName(void);
void InitItemInfoWindow(void);
bool8 UpdateItemInfoWindowSlideIn(void);
@ -455,7 +508,7 @@ u8 GetBoxCursorPosition(void);
u16 GetMovingItem(void);
u8 HandleInput(void);
void InitCanReleaseMonVars(void);
void InitMonPlaceChange(u8 a0);
void InitMonPlaceChange(u8 type);
bool8 IsActiveItemMoving(void);
bool8 IsCursorOnCloseBox(void);
bool8 IsMonBeingMoved(void);
@ -474,47 +527,47 @@ void SetWallpaperForCurrentBox(u8 wallpaper);
bool8 TryStorePartyMonInBox(u8 boxId);
void InitMenu(void);
void SetMenuText(u8 textId);
void sub_8095C84(u8 cursorArea, u8 cursorPos);
void sub_8095E2C(u16 itemId);
void TryLoadItemIconAtPos(u8 cursorArea, u8 cursorPos);
void InitItemIconInCursor(u16 itemId);
u8 GetBoxWallpaper(u8 boxId);
bool8 IsCursorOnBoxTitle(void);
bool8 IsCursorInBox(void);
void sub_808FFAC(void);
void InitMonIconFields(void);
struct Sprite *CreateMonIconSprite(u16 species, u32 pid, s16 x, s16 y, u8 priority, u8 subpriority);
void CreatePartyMonsSprites(bool8 species);
void sub_80909F4(void);
bool8 sub_8090A60(void);
void sub_8090B98(s16 yDelta);
void CompactPartySprites(void);
u8 GetNumPartySpritesCompacting(void);
void MovePartySprites(s16 yDelta);
void DestroyAllPartyMonIcons(void);
void sub_8091114(void);
bool8 sub_8091150(void);
void sub_80913DC(u8 box);
bool8 sub_809140C(void);
void DoReleaseMonComeBackAnim(void);
bool8 ResetReleaseMonSpritePtr(void);
void CreateInitBoxTask(u8 boxId);
bool8 IsInitBoxActive(void);
void AnimateBoxScrollArrows(bool8 species);
void CreateMovingMonIcon(void);
void sub_8090E08(u8 boxId, u8 cursorPos);
bool8 sub_8090E74(void);
void sub_8090CC0(u8 cursorArea, u8 cursorPos);
void sub_8090D58(u8 cursorArea, u8 cursorPos);
void SetShiftMonSpritePtr(u8 boxId, u8 position);
bool8 ShiftMons(void);
void SetMovingMonSprite(u8 cursorArea, u8 cursorPos);
void SetPlacedMonSprite(u8 cursorArea, u8 cursorPos);
void DestroyPartyMonIcon(u8 partyId);
void DestroyMovingMonIcon(void);
s16 GetFirstFreeBoxSpot(u8 boxId);
void sub_80901EC(u8 boxPosition);
void sub_8090FC4(u8 mode, u8 position);
bool8 sub_8091084(void);
void sub_80910CC(void);
void CreateBoxMonIconAtPos(u8 boxPosition);
void DoReleaseMonAnim(u8 mode, u8 position);
bool8 TryHideReleaseMonSprite(void);
void DestroyReleaseMonIcon(void);
u8 CountPartyMons(void);
u8 CountPartyAliveNonEggMonsExcept(u8 slotToIgnore);
s8 sub_8094E50(u8 a0);
bool8 sub_8095474(u8 action);
u8 sub_8095AA0(void);
bool8 sub_8095ABC(void);
void sub_8095D44(u8 cursorArea, u8 cursorPos);
void sub_8094CD4(u8 *arg0, u8 *arg1);
void sub_8094D40(void);
void sub_8092BAC(bool8 arg0);
s8 GetMenuItemTextId(u8 menuIndex);
bool8 MultiMove_TryMoveGroup(u8 dir);
u8 MultiMove_GetOriginPosition(void);
bool8 MultiMove_CanPlaceSelection(void);
void TryHideItemIconAtPos(u8 cursorArea, u8 cursorPos);
void GetCursorBoxColumnAndRow(u8 *column, u8 *row);
void SetCursorPriorityTo1(void);
void InitMultiMonPlaceChange(bool8 moveCursorUp);
void DestroyBoxMonIconAtPosition(u8 boxPosition);
void SetBoxMonIconObjMode(u8 cursorPos, u8 objMode);
void SetPartyMonIconObjMode(u8 cursorPos, u8 objMode);

2
src/berry_pouch.c
View File

@ -1258,7 +1258,7 @@ static void Task_ContextMenu_FromPartyGiveMenu(u8 taskId)
static void Task_ContextMenu_FromPokemonPC(u8 taskId)
{
sResources->exitCallback = Cb2_ReturnToPSS;
sResources->exitCallback = CB2_ReturnToPokeStorage;
gTasks[taskId].func = BerryPouch_StartFadeToExitCallback;
}

268
src/box_party_pokemon_dropdown.c
View File

@ -3,210 +3,236 @@
#include "box_party_pokemon_dropdown.h"
#include "malloc.h"
struct BPPD_MapRect
// Handles 3 particular tilemaps ("PKMN Data" text, party menu, close box
// button) used for Pokémon Storage System in a somewhat unusual way.
// For example, while the cursor is on the Close Box button it flashes between
// two states alternately. Both these states are their own part of the same
// tilemap that's always present. The utility shifts the tilemap up and down
// to show/hide the states, and limits the view with a rectangle that only
// reveals one at a time.
struct TilemapUtil_RectData
{
s16 x;
s16 y;
u16 width;
u16 height;
s16 destX;
s16 destY;
};
struct TilemapUtil
{
struct TilemapUtil_RectData prev; // Only read in unused function
struct TilemapUtil_RectData cur;
const void *savedTilemap; // Only written in unused function
const void *tilemap;
u16 altWidth; // Never read
u16 altHeight; // Never read
u16 width;
u16 height;
s16 destX2;
s16 destY2;
u16 rowSize; // Never read
u8 tileSize;
u8 bg;
bool8 active; // Only read in unused function
};
struct BPPD_Struct
{
struct BPPD_MapRect map1Rect;
struct BPPD_MapRect map2Rect;
const void *src1;
const void *src2;
u16 src1Height;
u16 src1Width;
u16 src2Width;
u16 src2Height;
u16 bytesPerRow;
u8 mapSize;
u8 bgId;
bool8 bgUpdateScheduled;
};
static EWRAM_DATA struct TilemapUtil *sTilemapUtil = NULL;
static EWRAM_DATA u16 sNumTilemapUtilIds = 0;
static EWRAM_DATA struct BPPD_Struct * sBoxPartyPokemonDropdownPtr = NULL;
static EWRAM_DATA u16 sBoxPartyPokemonDropdownCount = 0;
static void PushMap1(u8 idx);
static void PushMap2(u8 idx);
static void TilemapUtil_DrawPrev(u8 tilemapId);
static void TilemapUtil_Draw(u8 tilemapId);
static const struct {
u16 height;
u16 width;
} sBGdims[2][4] = {
u16 height;
} sTilemapDimensions[2][4] = {
{
{0x0100, 0x0100},
{0x0200, 0x0100},
{0x0100, 0x0200},
{0x0200, 0x0200}
{ 256, 256},
{ 512, 256},
{ 256, 512},
{ 512, 512}
}, {
{0x0080, 0x0080},
{0x0100, 0x0100},
{0x0200, 0x0200},
{0x0400, 0x0400}
{ 128, 128},
{ 256, 256},
{ 512, 512},
{1024, 1024}
}
};
void AllocBoxPartyPokemonDropdowns(u8 num)
void TilemapUtil_Init(u8 numTilemapIds)
{
u16 i;
sBoxPartyPokemonDropdownPtr = Alloc(num * sizeof(struct BPPD_Struct));
sBoxPartyPokemonDropdownCount = sBoxPartyPokemonDropdownPtr == NULL ? 0 : num;
for (i = 0; i < sBoxPartyPokemonDropdownCount; i++)
sTilemapUtil = Alloc(numTilemapIds * sizeof(struct TilemapUtil));
sNumTilemapUtilIds = sTilemapUtil == NULL ? 0 : numTilemapIds;
for (i = 0; i < sNumTilemapUtilIds; i++)
{
sBoxPartyPokemonDropdownPtr[i].src1 = NULL;
sBoxPartyPokemonDropdownPtr[i].bgUpdateScheduled = FALSE;
sTilemapUtil[i].savedTilemap = NULL;
sTilemapUtil[i].active = FALSE;
}
}
void FreeBoxPartyPokemonDropdowns(void)
void TilemapUtil_Free(void)
{
Free(sBoxPartyPokemonDropdownPtr);
Free(sTilemapUtil);
}
void CopyAllBoxPartyPokemonDropdownsToVram(void)
// Unused
void TilemapUtil_UpdateAll(void)
{
int i;
for (i = 0; i < sBoxPartyPokemonDropdownCount; i++)
for (i = 0; i < sNumTilemapUtilIds; i++)
{
if (sBoxPartyPokemonDropdownPtr[i].bgUpdateScheduled == TRUE)
CopyBoxPartyPokemonDropdownToBgTilemapBuffer(i);
if (sTilemapUtil[i].active == TRUE)
TilemapUtil_Update(i);
}
}
void SetBoxPartyPokemonDropdownMap2(u8 idx, u8 bgId, const void *src, u16 width, u16 height)
void TilemapUtil_SetTilemap(u8 tilemapId, u8 bg, const void *tilemap, u16 width, u16 height)
{
u16 screenSize;
u16 bgType;
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
sBoxPartyPokemonDropdownPtr[idx].src1 = NULL;
sBoxPartyPokemonDropdownPtr[idx].src2 = src;
sBoxPartyPokemonDropdownPtr[idx].bgId = bgId;
sBoxPartyPokemonDropdownPtr[idx].src2Width = width;
sBoxPartyPokemonDropdownPtr[idx].src2Height = height;
screenSize = GetBgAttribute(bgId, BG_ATTR_SCREENSIZE);
bgType = GetBgAttribute(bgId, BG_ATTR_BGTYPE);
sBoxPartyPokemonDropdownPtr[idx].src1Height = sBGdims[bgType][screenSize].height;
sBoxPartyPokemonDropdownPtr[idx].src1Width = sBGdims[bgType][screenSize].width;
sTilemapUtil[tilemapId].savedTilemap = NULL;
sTilemapUtil[tilemapId].tilemap = tilemap;
sTilemapUtil[tilemapId].bg = bg;
sTilemapUtil[tilemapId].width = width;
sTilemapUtil[tilemapId].height = height;
screenSize = GetBgAttribute(bg, BG_ATTR_SCREENSIZE);
bgType = GetBgAttribute(bg, BG_ATTR_BGTYPE);
sTilemapUtil[tilemapId].altWidth = sTilemapDimensions[bgType][screenSize].width;
sTilemapUtil[tilemapId].altHeight = sTilemapDimensions[bgType][screenSize].height;
if (bgType != 0)
sBoxPartyPokemonDropdownPtr[idx].mapSize = 1;
sTilemapUtil[tilemapId].tileSize = 1;
else
sBoxPartyPokemonDropdownPtr[idx].mapSize = 2;
sBoxPartyPokemonDropdownPtr[idx].bytesPerRow = width * sBoxPartyPokemonDropdownPtr[idx].mapSize;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.width = width;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.height = height;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX = 0;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY = 0;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 = 0;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 = 0;
sBoxPartyPokemonDropdownPtr[idx].map1Rect = sBoxPartyPokemonDropdownPtr[idx].map2Rect;
sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
sTilemapUtil[tilemapId].tileSize = 2;
sTilemapUtil[tilemapId].rowSize = width * sTilemapUtil[tilemapId].tileSize;
sTilemapUtil[tilemapId].cur.width = width;
sTilemapUtil[tilemapId].cur.height = height;
sTilemapUtil[tilemapId].cur.x = 0;
sTilemapUtil[tilemapId].cur.y = 0;
sTilemapUtil[tilemapId].cur.destX = 0;
sTilemapUtil[tilemapId].cur.destY = 0;
sTilemapUtil[tilemapId].prev = sTilemapUtil[tilemapId].cur;
sTilemapUtil[tilemapId].active = TRUE;
}
}
void SetBoxPartyPokemonDropdownMap1Tiles(u8 idx, const void *src)
// Unused
void TilemapUtil_SetSavedMap(u8 tilemapId, const void *tilemap)
{
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
sBoxPartyPokemonDropdownPtr[idx].src1 = src;
sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
sTilemapUtil[tilemapId].savedTilemap = tilemap;
sTilemapUtil[tilemapId].active = TRUE;
}
}
void SetBoxPartyPokemonDropdownMap2Pos(u8 idx, u16 x, u16 y)
void TilemapUtil_SetPos(u8 tilemapId, u16 destX, u16 destY)
{
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 = x;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 = y;
sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
sTilemapUtil[tilemapId].cur.destX = destX;
sTilemapUtil[tilemapId].cur.destY = destY;
sTilemapUtil[tilemapId].active = TRUE;
}
}
void SetBoxPartyPokemonDropdownMap2Rect(u8 idx, u16 x, u16 y, u16 width, u16 height)
void TilemapUtil_SetRect(u8 tilemapId, u16 x, u16 y, u16 width, u16 height)
{
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX = x;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY = y;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.width = width;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.height = height;
sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
sTilemapUtil[tilemapId].cur.x = x;
sTilemapUtil[tilemapId].cur.y = y;
sTilemapUtil[tilemapId].cur.width = width;
sTilemapUtil[tilemapId].cur.height = height;
sTilemapUtil[tilemapId].active = TRUE;
}
}
void AdjustBoxPartyPokemonDropdownPos(u8 idx, u8 op, s8 param)
void TilemapUtil_Move(u8 tilemapId, u8 mode, s8 param)
{
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
switch (op)
switch (mode)
{
case BPPD_MOVE_INNER_LEFT:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 += param;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.width -= param;
case 0:
sTilemapUtil[tilemapId].cur.destX += param;
sTilemapUtil[tilemapId].cur.width -= param;
break;
case BPPD_MOVE_OUTER_LEFT:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX += param;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.width += param;
case 1:
sTilemapUtil[tilemapId].cur.x += param;
sTilemapUtil[tilemapId].cur.width += param;
break;
case BPPD_MOVE_INNER_TOP:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 += param;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.height -= param;
case 2:
sTilemapUtil[tilemapId].cur.destY += param;
sTilemapUtil[tilemapId].cur.height -= param;
break;
case BPPD_MOVE_OUTER_TOP:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY -= param;
sBoxPartyPokemonDropdownPtr[idx].map2Rect.height += param;
case 3: // this is the only mode ever used
sTilemapUtil[tilemapId].cur.y -= param;
sTilemapUtil[tilemapId].cur.height += param;
break;
case BPPD_MOVE_INNER_X:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2 += param;
case 4:
sTilemapUtil[tilemapId].cur.destX += param;
break;
case BPPD_MOVE_INNER_Y:
sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 += param;
case 5:
sTilemapUtil[tilemapId].cur.destY += param;
break;
}
sBoxPartyPokemonDropdownPtr[idx].bgUpdateScheduled = TRUE;
sTilemapUtil[tilemapId].active = TRUE;
}
}
void CopyBoxPartyPokemonDropdownToBgTilemapBuffer(u8 idx)
void TilemapUtil_Update(u8 tilemapId)
{
if (idx < sBoxPartyPokemonDropdownCount)
if (tilemapId < sNumTilemapUtilIds)
{
if (sBoxPartyPokemonDropdownPtr[idx].src1 != NULL)
PushMap1(idx);
PushMap2(idx);
sBoxPartyPokemonDropdownPtr[idx].map1Rect = sBoxPartyPokemonDropdownPtr[idx].map2Rect;
if (sTilemapUtil[tilemapId].savedTilemap != NULL) // Always false
TilemapUtil_DrawPrev(tilemapId);
TilemapUtil_Draw(tilemapId);
sTilemapUtil[tilemapId].prev = sTilemapUtil[tilemapId].cur;
}
}
static void PushMap1(u8 idx)
// Never called, see TilemapUtil_Update
static void TilemapUtil_DrawPrev(u8 tilemapId)
{
int i;
int run = sBoxPartyPokemonDropdownPtr[idx].mapSize * sBoxPartyPokemonDropdownPtr[idx].src1Height;
const void *addr = sBoxPartyPokemonDropdownPtr[idx].src1 + run * sBoxPartyPokemonDropdownPtr[idx].map1Rect.destY2 + sBoxPartyPokemonDropdownPtr[idx].map1Rect.destX2 * sBoxPartyPokemonDropdownPtr[idx].mapSize;
for (i = 0; i < sBoxPartyPokemonDropdownPtr[idx].map1Rect.height; i++)
int rowSize = sTilemapUtil[tilemapId].tileSize * sTilemapUtil[tilemapId].altWidth;
const void *tiles = sTilemapUtil[tilemapId].savedTilemap
+ rowSize * sTilemapUtil[tilemapId].prev.destY
+ sTilemapUtil[tilemapId].prev.destX * sTilemapUtil[tilemapId].tileSize;
for (i = 0; i < sTilemapUtil[tilemapId].prev.height; i++)
{
CopyToBgTilemapBufferRect(sBoxPartyPokemonDropdownPtr[idx].bgId, addr, sBoxPartyPokemonDropdownPtr[idx].map1Rect.destX2, sBoxPartyPokemonDropdownPtr[idx].map1Rect.destY2 + i, sBoxPartyPokemonDropdownPtr[idx].map1Rect.width, 1);
addr += run;
CopyToBgTilemapBufferRect(sTilemapUtil[tilemapId].bg,
tiles,
sTilemapUtil[tilemapId].prev.destX,
sTilemapUtil[tilemapId].prev.destY + i,
sTilemapUtil[tilemapId].prev.width,
1);
tiles += rowSize;
}
}
static void PushMap2(u8 idx)
static void TilemapUtil_Draw(u8 tilemapId)
{
int i;
int run = sBoxPartyPokemonDropdownPtr[idx].mapSize * sBoxPartyPokemonDropdownPtr[idx].src2Width;
const void *addr = sBoxPartyPokemonDropdownPtr[idx].src2 + run * sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY + sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX * sBoxPartyPokemonDropdownPtr[idx].mapSize;
for (i = 0; i < sBoxPartyPokemonDropdownPtr[idx].map2Rect.height; i++)
int rowSize = sTilemapUtil[tilemapId].tileSize * sTilemapUtil[tilemapId].width;
const void *tiles = sTilemapUtil[tilemapId].tilemap
+ rowSize * sTilemapUtil[tilemapId].cur.y
+ sTilemapUtil[tilemapId].cur.x * sTilemapUtil[tilemapId].tileSize;
for (i = 0; i < sTilemapUtil[tilemapId].cur.height; i++)
{
CopyToBgTilemapBufferRect(sBoxPartyPokemonDropdownPtr[idx].bgId, addr, sBoxPartyPokemonDropdownPtr[idx].map2Rect.destX2, sBoxPartyPokemonDropdownPtr[idx].map2Rect.destY2 + i, sBoxPartyPokemonDropdownPtr[idx].map2Rect.width, 1);
addr += run;
CopyToBgTilemapBufferRect(sTilemapUtil[tilemapId].bg,
tiles,
sTilemapUtil[tilemapId].cur.destX,
sTilemapUtil[tilemapId].cur.destY + i,
sTilemapUtil[tilemapId].cur.width,
1);
tiles += rowSize;
}
}

12
src/graphics.c
View File

@ -1251,13 +1251,11 @@ const u32 gPokeSummary_StatusAilmentIconTiles[] = INCBIN_U32("graphics/interface
const u16 gDexScreen_TopMenuIconPals_AtoZ[] = INCBIN_U16("graphics/pokedex/cat_icon_abc.gbapal");
const u32 gDexScreen_TopMenuIconTiles_AtoZ[] = INCBIN_U32("graphics/pokedex/cat_icon_abc.4bpp.lz");
const u16 gPSSMenu_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal1.gbapal");
const u16 gUnknown_8E9C3F8[] = INCBIN_U16("graphics/interface/box_tiles_pal2.gbapal");
const u16 gUnknown_8E9C418[] = INCBIN_U16("graphics/interface/box_tiles_pal3.gbapal");
const u32 gPSSMenu_Gfx[] = INCBIN_U32("graphics/interface/box_tiles.4bpp.lz");
const u32 gUnknown_8E9CAEC[] = INCBIN_U32("graphics/unknown/unknown_E9CAEC.bin.lz");
const u16 gPokeStoragePartyMenu_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal1.gbapal");
const u16 gPokeStorageInterface_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal2.gbapal");
const u16 gPokeStorageInterface_NoDisplayMon_Pal[] = INCBIN_U16("graphics/interface/box_tiles_pal3.gbapal");
const u32 gPokeStorageMenu_Gfx[] = INCBIN_U32("graphics/interface/box_tiles.4bpp.lz");
const u32 gPokeStoragePartyMenu_Tilemap[] = INCBIN_U32("graphics/unknown/unknown_E9CAEC.bin.lz");
const u16 gMonMarkingsMenu_Pal[] = INCBIN_U16("graphics/misc/markings2.gbapal");
const u16 gMonMarkingsMenu_Gfx[] = INCBIN_U16("graphics/misc/markings2.4bpp");

2
src/item_menu.c
View File

@ -1784,7 +1784,7 @@ static void GoToBerryPouch_PCBox(void)
static void ReturnToBagMenuFromSubmenu_PCBox(void)
{
GoToBagMenu(ITEMMENULOCATION_PCBOX, OPEN_BAG_LAST, Cb2_ReturnToPSS);
GoToBagMenu(ITEMMENULOCATION_PCBOX, OPEN_BAG_LAST, CB2_ReturnToPokeStorage);
}
static void Task_ItemContext_Sell(u8 taskId)

290
src/pokemon_storage_system_2.c
View File

@ -16,22 +16,20 @@
#include "constants/help_system.h"
static EWRAM_DATA u8 sPreviousBoxOption = 0;
static EWRAM_DATA struct ChooseBoxMenu *sBoxSelectionPopupSpriteManager = NULL;
static EWRAM_DATA struct ChooseBoxMenu *sChooseBoxMenu = NULL;
static void PSS_CreatePCMenu(u8 whichMenu, s16 *windowIdPtr);
static void CreatePCMainMenu(u8 whichMenu, s16 *windowIdPtr);
static void ChooseBoxMenu_CreateSprites(u8 curBox);
static void sub_808CBA4(void);
static void UpdateBoxNameAndCountSprite_WraparoundRight(void);
static void UpdateBoxNameAndCountSprite_WraparoundLeft(void);
static void PrintBoxNameAndCountToSprite(void);
static void PrintToSpriteWithTagUnk0240(const u8 *a0, u16 x, u16 y);
static void sub_808CD64(struct Sprite *sprite);
static void ChooseBoxMenu_DestroySprites(void);
static void ChooseBoxMenu_MoveRight(void);
static void ChooseBoxMenu_MoveLeft(void);
static void ChooseBoxMenu_PrintBoxNameAndCount(void);
static void ChooseBoxMenu_PrintTextToSprite(const u8 *a0, u16 x, u16 y);
static void SpriteCB_ChooseBoxArrow(struct Sprite *sprite);
// Forward declarations
static const u16 sBoxSelectionPopupPalette[];
static const u16 sBoxSelectionPopupCenterTiles[];
static const u16 sBoxSelectionPopupSidesTiles[];
static const u16 sChooseBoxMenu_Pal[];
static const u8 sChooseBoxMenuCenter_Gfx[];
static const u8 sChooseBoxMenuCorners_Gfx[];
struct {
const u8 *text;
@ -44,7 +42,7 @@ struct {
[OPTION_EXIT] = {gText_SeeYa, gText_SeeYaDescription}
};
void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero2, u8 *buffer, s32 bytesToBuffer)
void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero2, u8 *unused, s32 bytesToBuffer)
{
s32 i, tileBytesToBuffer, remainingBytes;
u16 windowId;
@ -90,7 +88,7 @@ void DrawTextWindowAndBufferTiles(const u8 *string, void *dst, u8 zero1, u8 zero
RemoveWindow(windowId);
}
static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 rise, u8 bgClr, u8 fgClr, u8 shClr, u8 *buffer)
static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 offset, u8 bgColor, u8 fgColor, u8 shadowColor, u8 *unused)
{
u32 var;
u8 windowId;
@ -102,15 +100,15 @@ static void PrintStringToBufferCopyNow(const u8 *string, void *dst, u16 rise, u8
winTemplate.height = 2;
var = winTemplate.width * 32;
windowId = AddWindow(&winTemplate);
FillWindowPixelBuffer(windowId, PIXEL_FILL(bgClr));
FillWindowPixelBuffer(windowId, PIXEL_FILL(bgColor));
tileData1 = (u8 *)GetWindowAttribute(windowId, WINDOW_TILE_DATA);
tileData2 = (winTemplate.width * 32) + tileData1;
txtColor[0] = bgClr;
txtColor[1] = fgClr;
txtColor[2] = shClr;
txtColor[0] = bgColor;
txtColor[1] = fgColor;
txtColor[2] = shadowColor;
AddTextPrinterParameterized4(windowId, FONT_1, 0, 2, 0, 0, txtColor, -1, string);
CpuCopy16(tileData1, dst, var);
CpuCopy16(tileData2, dst + rise, var);
CpuCopy16(tileData2, dst + offset, var);
RemoveWindow(windowId);
}
@ -147,10 +145,8 @@ u8 CountPartyNonEggMons(void)
for (i = 0, count = 0; i < PARTY_SIZE; i++)
{
if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
&& !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
{
&& !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG))
count++;
}
}
return count;
@ -163,12 +159,10 @@ u8 CountPartyAliveNonEggMonsExcept(u8 slotToIgnore)
for (i = 0, count = 0; i < PARTY_SIZE; i++)
{
if (i != slotToIgnore
&& GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
&& !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
&& GetMonData(&gPlayerParty[i], MON_DATA_HP) != 0)
{
&& GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE
&& !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG)
&& GetMonData(&gPlayerParty[i], MON_DATA_HP) != 0)
count++;
}
}
return count;
@ -186,9 +180,7 @@ u8 CountPartyMons(void)
for (i = 0, count = 0; i < PARTY_SIZE; i++)
{
if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES) != SPECIES_NONE)
{
count++;
}
}
return count;
@ -205,7 +197,8 @@ static u8 *StringCopyAndFillWithSpaces(u8 *dst, const u8 *src, u16 n)
return str;
}
static void sub_808C25C(u16 *dest, u16 dest_left, u16 dest_top, const u16 *src, u16 src_left, u16 src_top, u16 dest_width, u16 dest_height, u16 src_width)
// Unused
static void UnusedWriteRectCpu(u16 *dest, u16 dest_left, u16 dest_top, const u16 *src, u16 src_left, u16 src_top, u16 dest_width, u16 dest_height, u16 src_width)
{
u16 i;
@ -231,16 +224,6 @@ static void UnusedWriteRectDma(u16 *dest, u16 dest_left, u16 dest_top, u16 width
Dma3FillLarge16_(0, dest, width);
}
//------------------------------------------------------------------------------
// SECTION: Main menu
//
// The below functions generally handle the PC main menu where the main
// options can be selected (Withdraw, Deposit, etc.), as well as exiting
// Pokémon Storage back to this menu.
//------------------------------------------------------------------------------
enum {
STATE_LOAD,
STATE_FADE_IN,
@ -263,7 +246,7 @@ static void Task_PCMainMenu(u8 taskId)
{
case STATE_LOAD:
SetHelpContext(HELPCONTEXT_BILLS_PC);
PSS_CreatePCMenu(task->tSelectedOption, &task->tWindowId);
CreatePCMainMenu(task->tSelectedOption, &task->tWindowId);
LoadStdWindowFrameGfx();
DrawDialogueFrame(0, FALSE);
FillWindowPixelBuffer(0, PIXEL_FILL(1));
@ -274,9 +257,8 @@ static void Task_PCMainMenu(u8 taskId)
break;
case STATE_FADE_IN:
if (IsWeatherNotFadingIn())
{
task->tState++;
}
break;
case STATE_HANDLE_INPUT:
task->tInput = Menu_ProcessInput();
@ -305,14 +287,14 @@ static void Task_PCMainMenu(u8 taskId)
DestroyTask(taskId);
break;
default:
if (task->tInput == 0 && CountPartyMons() == PARTY_SIZE)
if (task->tInput == OPTION_WITHDRAW && CountPartyMons() == PARTY_SIZE)
{
// Can't withdraw
FillWindowPixelBuffer(0, PIXEL_FILL(1));
AddTextPrinterParameterized2(0, FONT_2, gText_PartyFull, 0, NULL, TEXT_COLOR_DARK_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_LIGHT_GRAY);
task->tState = 3;
task->tState = STATE_ERROR_MSG;
}
else if (task->tInput == 1 && CountPartyMons() == 1)
else if (task->tInput == OPTION_DEPOSIT && CountPartyMons() == 1)
{
// Can't deposit
FillWindowPixelBuffer(0, PIXEL_FILL(1));
@ -362,7 +344,7 @@ static void Task_PCMainMenu(u8 taskId)
if (!gPaletteFade.active)
{
CleanupOverworldWindowsAndTilemaps();
Cb2_EnterPSS(task->tInput);
EnterPokeStorage(task->tInput);
DestroyTask(taskId);
}
break;
@ -372,7 +354,7 @@ static void Task_PCMainMenu(u8 taskId)
void ShowPokemonStorageSystemPC(void)
{
u8 taskId = CreateTask(Task_PCMainMenu, 80);
gTasks[taskId].tState = 0;
gTasks[taskId].tState = STATE_LOAD;
gTasks[taskId].tSelectedOption = 0;
LockPlayerFieldControls();
}
@ -384,14 +366,14 @@ static void FieldTask_ReturnToPcMenu(void)
SetVBlankCallback(NULL);
taskId = CreateTask(Task_PCMainMenu, 80);
gTasks[taskId].tState = 0;
gTasks[taskId].tState = STATE_LOAD;
gTasks[taskId].tSelectedOption = sPreviousBoxOption;
Task_PCMainMenu(taskId);
SetVBlankCallback(vblankCb);
FadeInFromBlack();
}
static const struct WindowTemplate sUnknown_83CDA48 = {
static const struct WindowTemplate sWindowTemplate_MainMenu = {
.bg = 0,
.tilemapLeft = 1,
.tilemapTop = 1,
@ -401,14 +383,13 @@ static const struct WindowTemplate sUnknown_83CDA48 = {
.baseBlock = 0x001
};
static void PSS_CreatePCMenu(u8 whichMenu, s16 *windowIdPtr)
static void CreatePCMainMenu(u8 whichMenu, s16 *windowIdPtr)
{
s16 windowId;
windowId = AddWindow(&sUnknown_83CDA48);
s16 windowId = AddWindow(&sWindowTemplate_MainMenu);
DrawStdWindowFrame(windowId, FALSE);
PrintTextArray(windowId, FONT_2, GetMenuCursorDimensionByFont(FONT_2, 0), 2, 16, NELEMS(sMainMenuTexts), (void *)sMainMenuTexts);
Menu_InitCursor(windowId, FONT_2, 0, 2, 16, NELEMS(sMainMenuTexts), whichMenu);
PrintTextArray(windowId, FONT_2, GetMenuCursorDimensionByFont(FONT_2, 0), 2, 16, ARRAY_COUNT(sMainMenuTexts), (void *)sMainMenuTexts);
Menu_InitCursor(windowId, FONT_2, 0, 2, 16, ARRAY_COUNT(sMainMenuTexts), whichMenu);
*windowIdPtr = windowId;
}
@ -439,54 +420,44 @@ void ResetPokemonStorageSystem(void)
SetBoxWallpaper(boxId, boxId % (MAX_DEFAULT_WALLPAPER + 1));
}
//------------------------------------------------------------------------------
// SECTION: Choose Box menu
//
// The below functions handle the popup menu that allows the player to cycle
// through the boxes and select one. Used when storing Pokémon in Deposit mode
// and for the Jump feature.
//------------------------------------------------------------------------------
void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *a0, u16 tileTag, u16 palTag, u8 a3, bool32 loadPal)
void LoadChooseBoxMenuGfx(struct ChooseBoxMenu *menu, u16 tileTag, u16 palTag, u8 subpriority, bool32 loadPal)
{
struct SpritePalette palette = {
sBoxSelectionPopupPalette, palTag
sChooseBoxMenu_Pal, palTag
};
struct SpriteSheet sheets[] = {
{sBoxSelectionPopupCenterTiles, 0x800, tileTag},
{sBoxSelectionPopupSidesTiles, 0x180, tileTag + 1},
{sChooseBoxMenuCenter_Gfx, 0x800, tileTag},
{sChooseBoxMenuCorners_Gfx, 0x180, tileTag + 1},
{}
};
if (loadPal)
if (loadPal) // Always false
LoadSpritePalette(&palette);
LoadSpriteSheets(sheets);
sBoxSelectionPopupSpriteManager = a0;
a0->tileTag = tileTag;
a0->paletteTag = palTag;
a0->subpriority = a3;
a0->loadedPalette = loadPal;
sChooseBoxMenu = menu;
menu->tileTag = tileTag;
menu->paletteTag = palTag;
menu->subpriority = subpriority;
menu->loadedPalette = loadPal;
}
void FreeBoxSelectionPopupSpriteGfx(void)
{
if (sBoxSelectionPopupSpriteManager->loadedPalette)
FreeSpritePaletteByTag(sBoxSelectionPopupSpriteManager->paletteTag);
FreeSpriteTilesByTag(sBoxSelectionPopupSpriteManager->tileTag);
FreeSpriteTilesByTag(sBoxSelectionPopupSpriteManager->tileTag + 1);
if (sChooseBoxMenu->loadedPalette)
FreeSpritePaletteByTag(sChooseBoxMenu->paletteTag);
FreeSpriteTilesByTag(sChooseBoxMenu->tileTag);
FreeSpriteTilesByTag(sChooseBoxMenu->tileTag + 1);
}
void sub_808C940(u8 curBox)
void CreateChooseBoxMenuSprites(u8 curBox)
{
ChooseBoxMenu_CreateSprites(curBox);
}
void sub_808C950(void)
void DestroyChooseBoxMenuSprites(void)
{
sub_808CBA4();
ChooseBoxMenu_DestroySprites();
}
u8 HandleBoxChooseSelectionInput(void)
@ -494,60 +465,61 @@ u8 HandleBoxChooseSelectionInput(void)
if (JOY_NEW(B_BUTTON))
{
PlaySE(SE_SELECT);
return 201;
return BOXID_CANCELED;
}
if (JOY_NEW(A_BUTTON))
{
PlaySE(SE_SELECT);
return sBoxSelectionPopupSpriteManager->curBox;
return sChooseBoxMenu->curBox;
}
if (JOY_NEW(DPAD_LEFT))
{
PlaySE(SE_SELECT);
UpdateBoxNameAndCountSprite_WraparoundLeft();
ChooseBoxMenu_MoveLeft();
}
else if (JOY_NEW(DPAD_RIGHT))
{
PlaySE(SE_SELECT);
UpdateBoxNameAndCountSprite_WraparoundRight();
ChooseBoxMenu_MoveRight();
}
return 200;
return BOXID_NONE_CHOSEN;
}
static const union AnimCmd gUnknown_83CDA50[] = {
static const union AnimCmd sAnim_ChooseBoxMenu_TopLeft[] = {
ANIMCMD_FRAME( 0, 5),
ANIMCMD_END
};
static const union AnimCmd gUnknown_83CDA58[] = {
static const union AnimCmd sAnim_ChooseBoxMenu_BottomLeft[] = {
ANIMCMD_FRAME( 4, 5),
ANIMCMD_END
};
static const union AnimCmd gUnknown_83CDA60[] = {
static const union AnimCmd sAnim_ChooseBoxMenu_TopRight[] = {
ANIMCMD_FRAME( 6, 5),
ANIMCMD_END
};
static const union AnimCmd gUnknown_83CDA68[] = {
static const union AnimCmd sAnim_ChooseBoxMenu_BottomRight[] = {
ANIMCMD_FRAME(10, 5),
ANIMCMD_END
};
static const union AnimCmd *const gUnknown_83CDA70[] = {
gUnknown_83CDA50,
gUnknown_83CDA58,
gUnknown_83CDA60,
gUnknown_83CDA68
static const union AnimCmd *const sAnims_ChooseBoxMenu[] = {
sAnim_ChooseBoxMenu_TopLeft,
sAnim_ChooseBoxMenu_BottomLeft,
sAnim_ChooseBoxMenu_TopRight,
sAnim_ChooseBoxMenu_BottomRight,
};
static const union AffineAnimCmd gUnknown_83CDA80[] = {
static const union AffineAnimCmd sAffineAnim_ChooseBoxMenu[] = {
AFFINEANIMCMD_FRAME(224, 224, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const gUnknown_83CDA90[] = {
gUnknown_83CDA80
// Unused
static const union AffineAnimCmd *const sAffineAnims_ChooseBoxMenu[] = {
sAffineAnim_ChooseBoxMenu
};
static void ChooseBoxMenu_CreateSprites(u8 curBox)
@ -562,112 +534,112 @@ static void ChooseBoxMenu_CreateSprites(u8 curBox)
0, 0, &oamData, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy
};
{
const u8 gUnknown_83CDA94[] = _("/30");
const u8 sText_OutOf30[] = _("/30");
sBoxSelectionPopupSpriteManager->curBox = curBox;
template.tileTag = sBoxSelectionPopupSpriteManager->tileTag;
template.paletteTag = sBoxSelectionPopupSpriteManager->paletteTag;
sChooseBoxMenu->curBox = curBox;
template.tileTag = sChooseBoxMenu->tileTag;
template.paletteTag = sChooseBoxMenu->paletteTag;
spriteId = CreateSprite(&template, 160, 96, 0);
sBoxSelectionPopupSpriteManager->menuSprite = gSprites + spriteId;
sChooseBoxMenu->menuSprite = gSprites + spriteId;
// Manual subsprites
oamData.shape = SPRITE_SHAPE(8x32);
oamData.size = SPRITE_SIZE(8x32);
template.tileTag = sBoxSelectionPopupSpriteManager->tileTag + 1;
template.anims = gUnknown_83CDA70;
for (i = 0; i < 4; i++)
template.tileTag = sChooseBoxMenu->tileTag + 1;
template.anims = sAnims_ChooseBoxMenu;
for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->menuCornerSprites); i++)
{
u16 r5;
spriteId = CreateSprite(&template, 124, 80, sBoxSelectionPopupSpriteManager->subpriority);
sBoxSelectionPopupSpriteManager->menuSideSprites[i] = gSprites + spriteId;
r5 = 0;
// corner sprites are created in order of top left, bottom left, top right, bottom right
u16 animNum;
spriteId = CreateSprite(&template, 124, 80, sChooseBoxMenu->subpriority); // place at top left
sChooseBoxMenu->menuCornerSprites[i] = &gSprites[spriteId];
animNum = 0;
if (i & 2)
{
sBoxSelectionPopupSpriteManager->menuSideSprites[i]->x = 196;
r5 = 2;
sChooseBoxMenu->menuCornerSprites[i]->x = 196; // move to bottom
animNum = 2;
}
if (i & 1)
{
sBoxSelectionPopupSpriteManager->menuSideSprites[i]->y = 112;
sBoxSelectionPopupSpriteManager->menuSideSprites[i]->oam.size = SPRITE_SIZE(8x16);
r5++;
sChooseBoxMenu->menuCornerSprites[i]->y = 112; // move to right
sChooseBoxMenu->menuCornerSprites[i]->oam.size = SPRITE_SIZE(8x16);
animNum++;
}
StartSpriteAnim(sBoxSelectionPopupSpriteManager->menuSideSprites[i], r5);
StartSpriteAnim(sChooseBoxMenu->menuCornerSprites[i], animNum);
}
for (i = 0; i < 2; i++)
for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->arrowSprites); i++)
{
sBoxSelectionPopupSpriteManager->arrowSprites[i] = CreateChooseBoxArrows(72 * i + 0x7c, 0x58, i, 0, sBoxSelectionPopupSpriteManager->subpriority);
if (sBoxSelectionPopupSpriteManager->arrowSprites[i])
sChooseBoxMenu->arrowSprites[i] = CreateChooseBoxArrows(72 * i + 124, 88, i, 0, sChooseBoxMenu->subpriority);
if (sChooseBoxMenu->arrowSprites[i])
{
sBoxSelectionPopupSpriteManager->arrowSprites[i]->data[0] = (i == 0 ? -1 : 1);
sBoxSelectionPopupSpriteManager->arrowSprites[i]->callback = sub_808CD64;
sChooseBoxMenu->arrowSprites[i]->data[0] = (i == 0 ? -1 : 1);
sChooseBoxMenu->arrowSprites[i]->callback = SpriteCB_ChooseBoxArrow;
}
}
PrintBoxNameAndCountToSprite();
PrintToSpriteWithTagUnk0240(gUnknown_83CDA94, 5, 3);
ChooseBoxMenu_PrintBoxNameAndCount();
ChooseBoxMenu_PrintTextToSprite(sText_OutOf30, 5, 3);
}
}
static void sub_808CBA4(void)
static void ChooseBoxMenu_DestroySprites(void)
{
u16 i;
if (sBoxSelectionPopupSpriteManager->menuSprite)
if (sChooseBoxMenu->menuSprite)
{
DestroySprite(sBoxSelectionPopupSpriteManager->menuSprite);
sBoxSelectionPopupSpriteManager->menuSprite = NULL;
DestroySprite(sChooseBoxMenu->menuSprite);
sChooseBoxMenu->menuSprite = NULL;
}
for (i = 0; i < 4; i++)
for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->menuCornerSprites); i++)
{
if (sBoxSelectionPopupSpriteManager->menuSideSprites[i])
if (sChooseBoxMenu->menuCornerSprites[i])
{
DestroySprite(sBoxSelectionPopupSpriteManager->menuSideSprites[i]);
sBoxSelectionPopupSpriteManager->menuSideSprites[i] = NULL;
DestroySprite(sChooseBoxMenu->menuCornerSprites[i]);
sChooseBoxMenu->menuCornerSprites[i] = NULL;
}
}
for (i = 0; i < 2; i++)
for (i = 0; i < ARRAY_COUNT(sChooseBoxMenu->arrowSprites); i++)
{
if (sBoxSelectionPopupSpriteManager->arrowSprites[i])
DestroySprite(sBoxSelectionPopupSpriteManager->arrowSprites[i]);
if (sChooseBoxMenu->arrowSprites[i])
DestroySprite(sChooseBoxMenu->arrowSprites[i]);
}
}
static void UpdateBoxNameAndCountSprite_WraparoundRight(void)
static void ChooseBoxMenu_MoveRight(void)
{
if (++sBoxSelectionPopupSpriteManager->curBox >= TOTAL_BOXES_COUNT)
sBoxSelectionPopupSpriteManager->curBox = 0;
PrintBoxNameAndCountToSprite();
if (++sChooseBoxMenu->curBox >= TOTAL_BOXES_COUNT)
sChooseBoxMenu->curBox = 0;
ChooseBoxMenu_PrintBoxNameAndCount();
}
static void UpdateBoxNameAndCountSprite_WraparoundLeft(void)
static void ChooseBoxMenu_MoveLeft(void)
{
sBoxSelectionPopupSpriteManager->curBox = (sBoxSelectionPopupSpriteManager->curBox == 0 ? TOTAL_BOXES_COUNT - 1 : sBoxSelectionPopupSpriteManager->curBox - 1);
PrintBoxNameAndCountToSprite();
sChooseBoxMenu->curBox = (sChooseBoxMenu->curBox == 0 ? TOTAL_BOXES_COUNT - 1 : sChooseBoxMenu->curBox - 1);
ChooseBoxMenu_PrintBoxNameAndCount();
}
static void PrintBoxNameAndCountToSprite(void)
static void ChooseBoxMenu_PrintBoxNameAndCount(void)
{
u8 nPokemonInBox = CountMonsInBox(sBoxSelectionPopupSpriteManager->curBox);
u8 *boxName = StringCopy(sBoxSelectionPopupSpriteManager->strbuf, GetBoxNamePtr(sBoxSelectionPopupSpriteManager->curBox));
u8 numMonInBox = CountMonsInBox(sChooseBoxMenu->curBox);
u8 *boxName = StringCopy(sChooseBoxMenu->strbuf, GetBoxNamePtr(sChooseBoxMenu->curBox));
while (boxName < sBoxSelectionPopupSpriteManager->strbuf + BOX_NAME_LENGTH)
while (boxName < sChooseBoxMenu->strbuf + BOX_NAME_LENGTH)
*boxName++ = CHAR_SPACE;
*boxName = EOS;
PrintToSpriteWithTagUnk0240(sBoxSelectionPopupSpriteManager->strbuf, 0, 1);
ChooseBoxMenu_PrintTextToSprite(sChooseBoxMenu->strbuf, 0, 1);
ConvertIntToDecimalStringN(sBoxSelectionPopupSpriteManager->strbuf, nPokemonInBox, STR_CONV_MODE_RIGHT_ALIGN, 2);
ConvertIntToDecimalStringN(sChooseBoxMenu->strbuf, numMonInBox, STR_CONV_MODE_RIGHT_ALIGN, 2);
PrintToSpriteWithTagUnk0240(sBoxSelectionPopupSpriteManager->strbuf, 3, 3);
ChooseBoxMenu_PrintTextToSprite(sChooseBoxMenu->strbuf, 3, 3);
}
static void PrintToSpriteWithTagUnk0240(const u8 *str, u16 x, u16 y)
static void ChooseBoxMenu_PrintTextToSprite(const u8 *str, u16 x, u16 y)
{
u16 tileStart = GetSpriteTileStartByTag(sBoxSelectionPopupSpriteManager->tileTag);
PrintStringToBufferCopyNow(str, (void *)(OBJ_VRAM0 + tileStart * 32 + 256 * y + 32 * x), 0x100, TEXT_COLOR_RED, TEXT_DYNAMIC_COLOR_6, TEXT_DYNAMIC_COLOR_5, sBoxSelectionPopupSpriteManager->buffer);
void *dst = (void *)(OBJ_VRAM0 + GetSpriteTileStartByTag(sChooseBoxMenu->tileTag) * 32 + 256 * y + 32 * x);
PrintStringToBufferCopyNow(str, dst, 0x100, TEXT_COLOR_RED, TEXT_DYNAMIC_COLOR_6, TEXT_DYNAMIC_COLOR_5, sChooseBoxMenu->buffer);
}
static void sub_808CD64(struct Sprite *sprite)
static void SpriteCB_ChooseBoxArrow(struct Sprite *sprite)
{
if (++sprite->data[1] > 3)
{
@ -681,8 +653,8 @@ static void sub_808CD64(struct Sprite *sprite)
}
}
// Forward-declared rodata
// Unused, since LoadChooseBoxMenuGfx is always called with `loadPal` as false
static const u16 sChooseBoxMenu_Pal[] = INCBIN_U16("graphics/interface/pss_unk_83CDA98.gbapal");
static const u16 sBoxSelectionPopupPalette[] = INCBIN_U16("graphics/interface/pss_unk_83CDA98.gbapal");
static const u16 sBoxSelectionPopupCenterTiles[] = INCBIN_U16("graphics/interface/pss_unk_83CDAB8.4bpp");
static const u16 sBoxSelectionPopupSidesTiles[] = INCBIN_U16("graphics/interface/pss_unk_83CE2B8.4bpp");
static const u8 sChooseBoxMenuCenter_Gfx[] = INCBIN_U8("graphics/interface/pss_unk_83CDAB8.4bpp");
static const u8 sChooseBoxMenuCorners_Gfx[] = INCBIN_U8("graphics/interface/pss_unk_83CE2B8.4bpp");

2123
src/pokemon_storage_system_3.c
View File

File diff suppressed because it is too large Load Diff

1266
src/pokemon_storage_system_4.c
View File

File diff suppressed because it is too large Load Diff

1576
src/pokemon_storage_system_5.c
View File

File diff suppressed because it is too large Load Diff

154
src/pokemon_storage_system_6.c
View File

@ -8,115 +8,115 @@
void InitMenu(void)
{
gPSSData->menuItemsCount = 0;
gPSSData->menuWidth = 0;
gPSSData->menuWindow.bg = 0;
gPSSData->menuWindow.paletteNum = 15;
gPSSData->menuWindow.baseBlock = 92;
gStorage->menuItemsCount = 0;
gStorage->menuWidth = 0;
gStorage->menuWindow.bg = 0;
gStorage->menuWindow.paletteNum = 15;
gStorage->menuWindow.baseBlock = 92;
}
static const u8 *const sMenuTexts[] = {
[PC_TEXT_CANCEL] = gPCText_Cancel,
[PC_TEXT_STORE] = gPCText_Store,
[PC_TEXT_WITHDRAW] = gPCText_Withdraw,
[PC_TEXT_MOVE] = gPCText_Move,
[PC_TEXT_SHIFT] = gPCText_Shift,
[PC_TEXT_PLACE] = gPCText_Place,
[PC_TEXT_SUMMARY] = gPCText_Summary,
[PC_TEXT_RELEASE] = gPCText_Release,
[PC_TEXT_MARK] = gPCText_Mark,
[PC_TEXT_JUMP] = gPCText_Jump,
[PC_TEXT_WALLPAPER] = gPCText_Wallpaper,
[PC_TEXT_NAME] = gPCText_Name,
[PC_TEXT_TAKE] = gPCText_Take,
[PC_TEXT_GIVE] = gPCText_Give,
[PC_TEXT_GIVE2] = gPCText_Give,
[PC_TEXT_SWITCH] = gPCText_Switch,
[PC_TEXT_BAG] = gPCText_Bag,
[PC_TEXT_INFO] = gPCText_Info,
[PC_TEXT_SCENERY1] = gPCText_Scenery1,
[PC_TEXT_SCENERY2] = gPCText_Scenery2,
[PC_TEXT_SCENERY3] = gPCText_Scenery3,
[PC_TEXT_ETCETERA] = gPCText_Etcetera,
[PC_TEXT_FOREST] = gPCText_Forest,
[PC_TEXT_CITY] = gPCText_City,
[PC_TEXT_DESERT] = gPCText_Desert,
[PC_TEXT_SAVANNA] = gPCText_Savanna,
[PC_TEXT_CRAG] = gPCText_Crag,
[PC_TEXT_VOLCANO] = gPCText_Volcano,
[PC_TEXT_SNOW] = gPCText_Snow,
[PC_TEXT_CAVE] = gPCText_Cave,
[PC_TEXT_BEACH] = gPCText_Beach,
[PC_TEXT_SEAFLOOR] = gPCText_Seafloor,
[PC_TEXT_RIVER] = gPCText_River,
[PC_TEXT_SKY] = gPCText_Sky,
[PC_TEXT_POLKADOT] = gPCText_PolkaDot,
[PC_TEXT_POKECENTER] = gPCText_Pokecenter,
[PC_TEXT_MACHINE] = gPCText_Machine,
[PC_TEXT_SIMPLE] = gPCText_Simple,
[MENU_TEXT_CANCEL] = gPCText_Cancel,
[MENU_TEXT_STORE] = gPCText_Store,
[MENU_TEXT_WITHDRAW] = gPCText_Withdraw,
[MENU_TEXT_MOVE] = gPCText_Move,
[MENU_TEXT_SHIFT] = gPCText_Shift,
[MENU_TEXT_PLACE] = gPCText_Place,
[MENU_TEXT_SUMMARY] = gPCText_Summary,
[MENU_TEXT_RELEASE] = gPCText_Release,
[MENU_TEXT_MARK] = gPCText_Mark,
[MENU_TEXT_JUMP] = gPCText_Jump,
[MENU_TEXT_WALLPAPER] = gPCText_Wallpaper,
[MENU_TEXT_NAME] = gPCText_Name,
[MENU_TEXT_TAKE] = gPCText_Take,
[MENU_TEXT_GIVE] = gPCText_Give,
[MENU_TEXT_GIVE2] = gPCText_Give,
[MENU_TEXT_SWITCH] = gPCText_Switch,
[MENU_TEXT_BAG] = gPCText_Bag,
[MENU_TEXT_INFO] = gPCText_Info,
[MENU_TEXT_SCENERY_1] = gPCText_Scenery1,
[MENU_TEXT_SCENERY_2] = gPCText_Scenery2,
[MENU_TEXT_SCENERY_3] = gPCText_Scenery3,
[MENU_TEXT_ETCETERA] = gPCText_Etcetera,
[MENU_TEXT_FOREST] = gPCText_Forest,
[MENU_TEXT_CITY] = gPCText_City,
[MENU_TEXT_DESERT] = gPCText_Desert,
[MENU_TEXT_SAVANNA] = gPCText_Savanna,
[MENU_TEXT_CRAG] = gPCText_Crag,
[MENU_TEXT_VOLCANO] = gPCText_Volcano,
[MENU_TEXT_SNOW] = gPCText_Snow,
[MENU_TEXT_CAVE] = gPCText_Cave,
[MENU_TEXT_BEACH] = gPCText_Beach,
[MENU_TEXT_SEAFLOOR] = gPCText_Seafloor,
[MENU_TEXT_RIVER] = gPCText_River,
[MENU_TEXT_SKY] = gPCText_Sky,
[MENU_TEXT_POLKADOT] = gPCText_PolkaDot,
[MENU_TEXT_POKECENTER] = gPCText_Pokecenter,
[MENU_TEXT_MACHINE] = gPCText_Machine,
[MENU_TEXT_SIMPLE] = gPCText_Simple,
};
void SetMenuText(u8 textId)
{
if (gPSSData->menuItemsCount < ARRAY_COUNT(gPSSData->menuItems))
if (gStorage->menuItemsCount < ARRAY_COUNT(gStorage->menuItems))
{
u8 len;
struct StorageMenu *menu = &gPSSData->menuItems[gPSSData->menuItemsCount];
struct StorageMenu *menu = &gStorage->menuItems[gStorage->menuItemsCount];
menu->text = sMenuTexts[textId];
menu->textId = textId;
len = StringLength(menu->text);
if (len > gPSSData->menuWidth)
gPSSData->menuWidth = len;
if (len > gStorage->menuWidth)
gStorage->menuWidth = len;
gPSSData->menuItemsCount++;
gStorage->menuItemsCount++;
}
}
s8 sub_8094E50(u8 arg0)
s8 GetMenuItemTextId(u8 menuIndex)
{
if (arg0 >= gPSSData->menuItemsCount)
return -1;
if (menuIndex >= gStorage->menuItemsCount)
return MENU_B_PRESSED;
else
return gPSSData->menuItems[arg0].textId;
return gStorage->menuItems[menuIndex].textId;
}
void AddMenu(void)
{
gPSSData->menuWindow.width = gPSSData->menuWidth + 2;
gPSSData->menuWindow.height = 2 * gPSSData->menuItemsCount;
gPSSData->menuWindow.tilemapLeft = 29 - gPSSData->menuWindow.width;
gPSSData->menuWindow.tilemapTop = 15 - gPSSData->menuWindow.height;
gPSSData->menuWindowId = AddWindow(&gPSSData->menuWindow);
ClearWindowTilemap(gPSSData->menuWindowId);
DrawStdFrameWithCustomTileAndPalette(gPSSData->menuWindowId, FALSE, 0x00b, 14);
PrintTextArray(gPSSData->menuWindowId, FONT_1, 8, 2, 16, gPSSData->menuItemsCount, (void *)gPSSData->menuItems);
Menu_InitCursor(gPSSData->menuWindowId, FONT_1, 0, 2, 16, gPSSData->menuItemsCount, 0);
gStorage->menuWindow.width = gStorage->menuWidth + 2;
gStorage->menuWindow.height = 2 * gStorage->menuItemsCount;
gStorage->menuWindow.tilemapLeft = 29 - gStorage->menuWindow.width;
gStorage->menuWindow.tilemapTop = 15 - gStorage->menuWindow.height;
gStorage->menuWindowId = AddWindow(&gStorage->menuWindow);
ClearWindowTilemap(gStorage->menuWindowId);
DrawStdFrameWithCustomTileAndPalette(gStorage->menuWindowId, FALSE, 11, 14);
PrintTextArray(gStorage->menuWindowId, FONT_1, 8, 2, 16, gStorage->menuItemsCount, (void *)gStorage->menuItems);
Menu_InitCursor(gStorage->menuWindowId, FONT_1, 0, 2, 16, gStorage->menuItemsCount, 0);
ScheduleBgCopyTilemapToVram(0);
gPSSData->menuUnusedField = 0;
gStorage->menuUnusedField = 0;
}
bool8 sub_8094F90(void)
bool8 IsMenuLoading(void)
{
// Some debug flag?
// Possibly stubbed out debug code?
return FALSE;
}
s16 sub_8094F94(void)
s16 HandleMenuInput(void)
{
s32 textId = -2;
s32 input = MENU_NOTHING_CHOSEN;
do
{
if (JOY_NEW(A_BUTTON))
{
textId = Menu_GetCursorPos();
input = Menu_GetCursorPos();
break;
}
else if (JOY_NEW(B_BUTTON))
{
PlaySE(SE_SELECT);
textId = -1;
input = MENU_B_PRESSED;
}
if (JOY_NEW(DPAD_UP))
@ -129,19 +129,19 @@ s16 sub_8094F94(void)
PlaySE(SE_SELECT);
Menu_MoveCursor(1);
}
} while (0);
} while (FALSE);
if (textId != -2)
sub_8095024();
if (input != MENU_NOTHING_CHOSEN)
RemoveMenu();
if (textId >= 0)
textId = gPSSData->menuItems[textId].textId;
if (input >= 0)
input = gStorage->menuItems[input].textId;
return textId;
return input;
}
void sub_8095024(void)
void RemoveMenu(void)
{
ClearStdWindowAndFrameToTransparent(gPSSData->menuWindowId, TRUE);
RemoveWindow(gPSSData->menuWindowId);
ClearStdWindowAndFrameToTransparent(gStorage->menuWindowId, TRUE);
RemoveWindow(gStorage->menuWindowId);
}

500
src/pokemon_storage_system_7.c
View File

@ -5,50 +5,48 @@
#include "pokemon_storage_system_internal.h"
#include "text_window.h"
struct MoveMons
static EWRAM_DATA struct
{
u8 field_0;
u8 funcId;
u8 state;
u8 fromRow;
u8 fromColumn;
u8 toRow;
u8 fromRow;
u8 toColumn;
u8 field_6;
u8 field_7;
u8 minRow;
u8 toRow;
u8 cursorColumn;
u8 cursorRow;
u8 minColumn;
u8 minRow;
u8 columnsTotal;
u8 rowsTotal;
u8 columsTotal;
u16 bgX;
u16 bgY;
u16 field_10;
u16 bgMoveSteps;
struct BoxPokemon boxMons[IN_BOX_COUNT];
};
} *sMultiMove = NULL;
static EWRAM_DATA struct MoveMons *sMoveMonsPtr = NULL;
static bool8 MultiMove_Function_Start(void);
static bool8 MultiMove_Function_Single(void);
static bool8 MultiMove_Function_ChangeSelection(void);
static bool8 MultiMove_Function_GrabSelection(void);
static bool8 MultiMove_Function_MoveMons(void);
static bool8 MultiMove_Function_PlaceMons(void);
static void MultiMove_UpdateSelectedIcons(void);
static void MultiMove_SelectColumn(u8 column, u8 minRow, u8 maxRow);
static void MultiMove_SelectRow(u8 row, u8 minColumn, u8 maxColumn);
static void MultiMove_DeselectColumn(u8 arg0, u8 minRow, u8 maxRow);
static void MultiMove_DeselectRow(u8 row, u8 minColumn, u8 maxColumn);
static void MultiMove_SetIconToBg(u8 x, u8 y);
static void MultiMove_ClearIconFromBg(u8 x, u8 y);
static void MultiMove_InitBg(u16 bgX, u16 bgY, u16 duration);
static u8 MultiMove_UpdateBg(void);
static void MultiMove_GetMonsFromSelection(void);
static void MultiMove_RemoveMonsFromBox(void);
static void MultiMove_CreatePlacedMonIcons(void);
static void MultiMove_SetPlacedMonData(void);
static void MultiMove_ResetBg(void);
static bool8 sub_8095138(void);
static bool8 sub_8095234(void);
static bool8 sub_80952A0(void);
static bool8 sub_8095314(void);
static bool8 sub_8095394(void);
static bool8 sub_80953BC(void);
static void sub_8095520(void);
static void sub_80955C4(u8 arg0, u8 arg1, u8 arg2);
static void sub_80955FC(u8 arg0, u8 arg1, u8 arg2);
static void sub_8095634(u8 arg0, u8 arg1, u8 arg2);
static void sub_809566C(u8 arg0, u8 arg1, u8 arg2);
static void sub_80956A4(u8 x, u8 y);
static void sub_809572C(u8 x, u8 y);
static void sub_8095780(u16 bgX, u16 bgY, u16 duration);
static u8 sub_8095790(void);
static void sub_80957C8(void);
static void sub_80958A0(void);
static void sub_8095918(void);
static void sub_80959A8(void);
static void sub_8095A58(void);
static const struct WindowTemplate gUnknown_83D35D4 = {
static const struct WindowTemplate sWindowTemplate_MultiMove = {
.bg = 0,
.tilemapLeft = 10,
.tilemapTop = 3,
@ -58,15 +56,15 @@ static const struct WindowTemplate gUnknown_83D35D4 = {
.baseBlock = 0x00a
};
bool8 sub_8095050(void)
bool8 MultiMove_Init(void)
{
sMoveMonsPtr = Alloc(sizeof(*sMoveMonsPtr));
if (sMoveMonsPtr != NULL)
sMultiMove = Alloc(sizeof(*sMultiMove));
if (sMultiMove != NULL)
{
gPSSData->field_2200 = AddWindow8Bit(&gUnknown_83D35D4);
if (gPSSData->field_2200 != 0xFF)
gStorage->multiMoveWindowId = AddWindow8Bit(&sWindowTemplate_MultiMove);
if (gStorage->multiMoveWindowId != WINDOW_NONE)
{
FillWindowPixelBuffer(gPSSData->field_2200, PIXEL_FILL(0));
FillWindowPixelBuffer(gStorage->multiMoveWindowId, PIXEL_FILL(0));
return TRUE;
}
}
@ -74,64 +72,64 @@ bool8 sub_8095050(void)
return FALSE;
}
void sub_80950A4(void)
void MultiMove_Free(void)
{
if (sMoveMonsPtr != NULL)
Free(sMoveMonsPtr);
if (sMultiMove != NULL)
Free(sMultiMove);
}
void sub_80950BC(u8 arg0)
void MultiMove_SetFunction(u8 funcId)
{
sMoveMonsPtr->field_0 = arg0;
sMoveMonsPtr->state = 0;
sMultiMove->funcId = funcId;
sMultiMove->state = 0;
}
bool8 sub_80950D0(void)
bool8 MultiMove_RunFunction(void)
{
switch (sMoveMonsPtr->field_0)
switch (sMultiMove->funcId)
{
case 0:
return sub_8095138();
case 1:
return sub_8095234();
case 2:
return sub_80952A0();
case 3:
return sub_8095314();
case 4:
return sub_8095394();
case 5:
return sub_80953BC();
case MULTIMOVE_START:
return MultiMove_Function_Start();
case MULTIMOVE_SINGLE:
return MultiMove_Function_Single();
case MULTIMOVE_CHANGE_SELECTION:
return MultiMove_Function_ChangeSelection();
case MULTIMOVE_GRAB_SELECTION:
return MultiMove_Function_GrabSelection();
case MULTIMOVE_MOVE_MONS:
return MultiMove_Function_MoveMons();
case MULTIMOVE_PLACE_MONS:
return MultiMove_Function_PlaceMons();
}
return FALSE;
}
static bool8 sub_8095138(void)
static bool8 MultiMove_Function_Start(void)
{
switch (sMoveMonsPtr->state)
switch (sMultiMove->state)
{
case 0:
HideBg(0);
LoadMonIconPalettesAt(0x80);
sMoveMonsPtr->state++;
sMultiMove->state++;
break;
case 1:
sub_8094CD4(&sMoveMonsPtr->fromRow, &sMoveMonsPtr->fromColumn);
sMoveMonsPtr->toRow = sMoveMonsPtr->fromRow;
sMoveMonsPtr->toColumn = sMoveMonsPtr->fromColumn;
ChangeBgX(0, -1024, 0);
ChangeBgY(0, -1024, 0);
FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
FillWindowPixelBuffer8Bit(gPSSData->field_2200, PIXEL_FILL(0));
sub_80956A4(sMoveMonsPtr->fromRow, sMoveMonsPtr->fromColumn);
GetCursorBoxColumnAndRow(&sMultiMove->fromColumn, &sMultiMove->fromRow);
sMultiMove->toColumn = sMultiMove->fromColumn;
sMultiMove->toRow = sMultiMove->fromRow;
ChangeBgX(0, -1024, BG_COORD_SET);
ChangeBgY(0, -1024, BG_COORD_SET);
FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
FillWindowPixelBuffer8Bit(gStorage->multiMoveWindowId, PIXEL_FILL(0));
MultiMove_SetIconToBg(sMultiMove->fromColumn, sMultiMove->fromRow);
SetBgAttribute(0, BG_ATTR_PALETTEMODE, 1);
PutWindowTilemap(gPSSData->field_2200);
CopyWindowToVram8Bit(gPSSData->field_2200, COPYWIN_FULL);
PutWindowTilemap(gStorage->multiMoveWindowId);
CopyWindowToVram8Bit(gStorage->multiMoveWindowId, COPYWIN_FULL);
BlendPalettes(0x3F00, 8, RGB_WHITE);
sub_8094D14(2);
StartCursorAnim(CURSOR_ANIM_OPEN);
SetGpuRegBits(REG_OFFSET_BG0CNT, BGCNT_256COLOR);
sMoveMonsPtr->state++;
sMultiMove->state++;
break;
case 2:
if (!IsDma3ManagerBusyWithBgCopy())
@ -145,23 +143,23 @@ static bool8 sub_8095138(void)
return TRUE;
}
static bool8 sub_8095234(void)
static bool8 MultiMove_Function_Single(void)
{
switch (sMoveMonsPtr->state)
switch (sMultiMove->state)
{
case 0:
HideBg(0);
sMoveMonsPtr->state++;
sMultiMove->state++;
break;
case 1:
sub_8095A58();
sub_8094D14(0);
sMoveMonsPtr->state++;
MultiMove_ResetBg();
StartCursorAnim(CURSOR_ANIM_BOUNCE);
sMultiMove->state++;
break;
case 2:
if (!IsDma3ManagerBusyWithBgCopy())
{
sub_8094D40();
SetCursorPriorityTo1();
LoadPalette(stdpal_get(3), 0xD0, 0x20);
ShowBg(0);
return FALSE;
@ -172,19 +170,19 @@ static bool8 sub_8095234(void)
return TRUE;
}
static bool8 sub_80952A0(void)
static bool8 MultiMove_Function_ChangeSelection(void)
{
switch (sMoveMonsPtr->state)
switch (sMultiMove->state)
{
case 0:
if (!sub_80924A8())
if (!UpdateCursorPos())
{
sub_8094CD4(&sMoveMonsPtr->field_6, &sMoveMonsPtr->field_7);
sub_8095520();
sMoveMonsPtr->toRow = sMoveMonsPtr->field_6;
sMoveMonsPtr->toColumn = sMoveMonsPtr->field_7;
CopyWindowToVram8Bit(gPSSData->field_2200, COPYWIN_GFX);
sMoveMonsPtr->state++;
GetCursorBoxColumnAndRow(&sMultiMove->cursorColumn, &sMultiMove->cursorRow);
MultiMove_UpdateSelectedIcons();
sMultiMove->toColumn = sMultiMove->cursorColumn;
sMultiMove->toRow = sMultiMove->cursorRow;
CopyWindowToVram8Bit(gStorage->multiMoveWindowId, COPYWIN_GFX);
sMultiMove->state++;
}
break;
case 1:
@ -194,31 +192,31 @@ static bool8 sub_80952A0(void)
return TRUE;
}
static bool8 sub_8095314(void)
static bool8 MultiMove_Function_GrabSelection(void)
{
u8 var1, var2;
u8 movingBg, movingMon;
switch (sMoveMonsPtr->state)
switch (sMultiMove->state)
{
case 0:
sub_80957C8();
sub_80958A0();
sub_8092BAC(FALSE);
sMoveMonsPtr->state++;
MultiMove_GetMonsFromSelection();
MultiMove_RemoveMonsFromBox();
InitMultiMonPlaceChange(FALSE);
sMultiMove->state++;
break;
case 1:
if (!DoMonPlaceChange())
{
sub_8094D14(3);
sub_8095780(0, 256, 8);
sub_8092BAC(TRUE);
sMoveMonsPtr->state++;
StartCursorAnim(CURSOR_ANIM_FIST);
MultiMove_InitBg(0, 256, 8);
InitMultiMonPlaceChange(TRUE);
sMultiMove->state++;
}
break;
case 2:
var1 = sub_8095790();
var2 = DoMonPlaceChange();
if (!var1 && !var2)
movingBg = MultiMove_UpdateBg();
movingMon = DoMonPlaceChange();
if (!movingBg && !movingMon)
return FALSE;
break;
}
@ -226,50 +224,50 @@ static bool8 sub_8095314(void)
return TRUE;
}
static bool8 sub_8095394(void)
static bool8 MultiMove_Function_MoveMons(void)
{
u8 var1 = sub_80924A8();
u8 var2 = sub_8095790();
u8 movingCursor = UpdateCursorPos();
u8 movingBg = MultiMove_UpdateBg();
if (!var1 && !var2)
if (!movingCursor && !movingBg)
return FALSE;
else
return TRUE;
}
static bool8 sub_80953BC(void)
static bool8 MultiMove_Function_PlaceMons(void)
{
switch (sMoveMonsPtr->state)
switch (sMultiMove->state)
{
case 0:
sub_80959A8();
sub_8095780(0, -256, 8);
sub_8092BAC(FALSE);
sMoveMonsPtr->state++;
MultiMove_SetPlacedMonData();
MultiMove_InitBg(0, -256, 8);
InitMultiMonPlaceChange(FALSE);
sMultiMove->state++;
break;
case 1:
if (!DoMonPlaceChange() && !sub_8095790())
if (!DoMonPlaceChange() && !MultiMove_UpdateBg())
{
sub_8095918();
sub_8094D14(2);
sub_8092BAC(TRUE);
MultiMove_CreatePlacedMonIcons();
StartCursorAnim(CURSOR_ANIM_OPEN);
InitMultiMonPlaceChange(TRUE);
HideBg(0);
sMoveMonsPtr->state++;
sMultiMove->state++;
}
break;
case 2:
if (!DoMonPlaceChange())
{
sub_8094D14(0);
sub_8095A58();
sMoveMonsPtr->state++;
StartCursorAnim(CURSOR_ANIM_BOUNCE);
MultiMove_ResetBg();
sMultiMove->state++;
}
break;
case 3:
if (!IsDma3ManagerBusyWithBgCopy())
{
LoadPalette(stdpal_get(3), 0xD0, 0x20);
sub_8094D40();
SetCursorPriorityTo1();
ShowBg(0);
return FALSE;
}
@ -279,206 +277,188 @@ static bool8 sub_80953BC(void)
return TRUE;
}
bool8 sub_8095474(u8 arg0)
bool8 MultiMove_TryMoveGroup(u8 dir)
{
switch (arg0)
switch (dir)
{
case 0: // up
if (sMoveMonsPtr->minColumn == 0)
if (sMultiMove->minRow == 0)
return FALSE;
sMoveMonsPtr->minColumn--;
sub_8095780(0, 1024, 6);
sMultiMove->minRow--;
MultiMove_InitBg(0, 1024, 6);
break;
case 1: // down
if (sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal >= 5)
if (sMultiMove->minRow + sMultiMove->rowsTotal >= 5)
return FALSE;
sMoveMonsPtr->minColumn++;
sub_8095780(0, -1024, 6);
sMultiMove->minRow++;
MultiMove_InitBg(0, -1024, 6);
break;
case 2: // left
if (sMoveMonsPtr->minRow == 0)
if (sMultiMove->minColumn == 0)
return FALSE;
sMoveMonsPtr->minRow--;
sub_8095780(1024, 0, 6);
sMultiMove->minColumn--;
MultiMove_InitBg(1024, 0, 6);
break;
case 3: // right
if (sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal > 5)
if (sMultiMove->minColumn + sMultiMove->columnsTotal > 5)
return FALSE;
sMoveMonsPtr->minRow++;
sub_8095780(-1024, 0, 6);
sMultiMove->minColumn++;
MultiMove_InitBg(-1024, 0, 6);
break;
}
return TRUE;
}
static void sub_8095520(void)
static void MultiMove_UpdateSelectedIcons(void)
{
s16 var = (abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->field_6)) - (abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->toRow));
s16 var2 = (abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->field_7)) - (abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->toColumn));
s16 columnChange = (abs(sMultiMove->fromColumn - sMultiMove->cursorColumn)) - (abs(sMultiMove->fromColumn - sMultiMove->toColumn));
s16 rowChange = (abs(sMultiMove->fromRow - sMultiMove->cursorRow)) - (abs(sMultiMove->fromRow - sMultiMove->toRow));
if (var > 0)
sub_80955C4(sMoveMonsPtr->field_6, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
if (columnChange > 0)
MultiMove_SelectColumn(sMultiMove->cursorColumn, sMultiMove->fromRow, sMultiMove->toRow);
if (var < 0)
if (columnChange < 0)
{
sub_8095634(sMoveMonsPtr->toRow, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
sub_80955C4(sMoveMonsPtr->field_6, sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
MultiMove_DeselectColumn(sMultiMove->toColumn, sMultiMove->fromRow, sMultiMove->toRow);
MultiMove_SelectColumn(sMultiMove->cursorColumn, sMultiMove->fromRow, sMultiMove->toRow);
}
if (var2 > 0)
sub_80955FC(sMoveMonsPtr->field_7, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
if (rowChange > 0)
MultiMove_SelectRow(sMultiMove->cursorRow, sMultiMove->fromColumn, sMultiMove->toColumn);
if (var2 < 0)
if (rowChange < 0)
{
sub_809566C(sMoveMonsPtr->toColumn, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
sub_80955FC(sMoveMonsPtr->field_7, sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
MultiMove_DeselectRow(sMultiMove->toRow, sMultiMove->fromColumn, sMultiMove->toColumn);
MultiMove_SelectRow(sMultiMove->cursorRow, sMultiMove->fromColumn, sMultiMove->toColumn);
}
}
static void sub_80955C4(u8 arg0, u8 arg1, u8 arg2)
static void MultiMove_SelectColumn(u8 column, u8 minRow, u8 maxRow)
{
u8 var1 = arg1;
u8 tmp = minRow;
if (arg1 > arg2)
if (minRow > maxRow)
{
arg1 = arg2;
arg2 = var1;
minRow = maxRow;
maxRow = tmp;
}
while (arg1 <= arg2)
sub_80956A4(arg0, arg1++);
while (minRow <= maxRow)
MultiMove_SetIconToBg(column, minRow++);
}
static void sub_80955FC(u8 arg0, u8 arg1, u8 arg2)
static void MultiMove_SelectRow(u8 row, u8 minColumn, u8 maxColumn)
{
u8 var1 = arg1;
u8 tmp = minColumn;
if (arg1 > arg2)
if (minColumn > maxColumn)
{
arg1 = arg2;
arg2 = var1;
minColumn = maxColumn;
maxColumn = tmp;
}
while (arg1 <= arg2)
sub_80956A4(arg1++, arg0);
while (minColumn <= maxColumn)
MultiMove_SetIconToBg(minColumn++, row);
}
static void sub_8095634(u8 arg0, u8 arg1, u8 arg2)
static void MultiMove_DeselectColumn(u8 column, u8 minRow, u8 maxRow)
{
u8 var1 = arg1;
u8 tmp = minRow;
if (arg1 > arg2)
if (minRow > maxRow)
{
arg1 = arg2;
arg2 = var1;
minRow = maxRow;
maxRow = tmp;
}
while (arg1 <= arg2)
sub_809572C(arg0, arg1++);
while (minRow <= maxRow)
MultiMove_ClearIconFromBg(column, minRow++);
}
static void sub_809566C(u8 arg0, u8 arg1, u8 arg2)
static void MultiMove_DeselectRow(u8 row, u8 minColumn, u8 maxColumn)
{
u8 var1 = arg1;
u8 tmp = minColumn;
if (arg1 > arg2)
if (minColumn > maxColumn)
{
arg1 = arg2;
arg2 = var1;
minColumn = maxColumn;
maxColumn = tmp;
}
while (arg1 <= arg2)
sub_809572C(arg1++, arg0);
while (minColumn <= maxColumn)
MultiMove_ClearIconFromBg(minColumn++, row);
}
static void sub_80956A4(u8 x, u8 y)
static void MultiMove_SetIconToBg(u8 x, u8 y)
{
u8 position = x + (IN_BOX_ROWS * y);
u8 position = x + (IN_BOX_COLUMNS * y);
u16 species = GetCurrentBoxMonData(position, MON_DATA_SPECIES2);
u32 personality = GetCurrentBoxMonData(position, MON_DATA_PERSONALITY);
if (species != SPECIES_NONE)
{
const u8 *iconGfx = GetMonIconPtr(species, personality, 1);
u8 index = GetValidMonIconPalIndex(species) + 8;
BlitBitmapRectToWindow4BitTo8Bit(gPSSData->field_2200,
iconGfx,
0,
0,
32,
32,
24 * x,
24 * y,
32,
32,
index);
u8 palNum = GetValidMonIconPalIndex(species) + 8;
BlitBitmapRectToWindow4BitTo8Bit(gStorage->multiMoveWindowId, iconGfx, 0, 0, 32, 32, 24 * x, 24 * y, 32, 32, palNum);
}
}
static void sub_809572C(u8 x, u8 y)
static void MultiMove_ClearIconFromBg(u8 x, u8 y)
{
u8 position = x + (IN_BOX_ROWS * y);
u8 position = x + (IN_BOX_COLUMNS * y);
u16 species = GetCurrentBoxMonData(position, MON_DATA_SPECIES2);
if (species != SPECIES_NONE)
{
FillWindowPixelRect8Bit(gPSSData->field_2200,
PIXEL_FILL(0),
24 * x,
24 * y,
32,
32);
}
FillWindowPixelRect8Bit(gStorage->multiMoveWindowId, PIXEL_FILL(0), 24 * x, 24 * y, 32, 32);
}
static void sub_8095780(u16 bgX, u16 bgY, u16 duration)
static void MultiMove_InitBg(u16 bgX, u16 bgY, u16 duration)
{
sMoveMonsPtr->bgX = bgX;
sMoveMonsPtr->bgY = bgY;
sMoveMonsPtr->field_10 = duration;
sMultiMove->bgX = bgX;
sMultiMove->bgY = bgY;
sMultiMove->bgMoveSteps = duration;
}
static u8 sub_8095790(void)
static u8 MultiMove_UpdateBg(void)
{
if (sMoveMonsPtr->field_10 != 0)
if (sMultiMove->bgMoveSteps != 0)
{
ChangeBgX(0, sMoveMonsPtr->bgX, 1);
ChangeBgY(0, sMoveMonsPtr->bgY, 1);
sMoveMonsPtr->field_10--;
ChangeBgX(0, sMultiMove->bgX, BG_COORD_ADD);
ChangeBgY(0, sMultiMove->bgY, BG_COORD_ADD);
sMultiMove->bgMoveSteps--;
}
return sMoveMonsPtr->field_10;
return sMultiMove->bgMoveSteps;
}
static void sub_80957C8(void)
static void MultiMove_GetMonsFromSelection(void)
{
s32 i, j;
s32 rowCount, columnCount;
s32 columnCount, rowCount;
u8 boxId;
u8 monArrayId;
sMoveMonsPtr->minRow = min(sMoveMonsPtr->fromRow, sMoveMonsPtr->toRow);
sMoveMonsPtr->minColumn = min(sMoveMonsPtr->fromColumn, sMoveMonsPtr->toColumn);
sMoveMonsPtr->rowsTotal = abs(sMoveMonsPtr->fromRow - sMoveMonsPtr->toRow) + 1;
sMoveMonsPtr->columsTotal = abs(sMoveMonsPtr->fromColumn - sMoveMonsPtr->toColumn) + 1;
sMultiMove->minColumn = min(sMultiMove->fromColumn, sMultiMove->toColumn);
sMultiMove->minRow = min(sMultiMove->fromRow, sMultiMove->toRow);
sMultiMove->columnsTotal = abs(sMultiMove->fromColumn - sMultiMove->toColumn) + 1;
sMultiMove->rowsTotal = abs(sMultiMove->fromRow - sMultiMove->toRow) + 1;
boxId = StorageGetCurrentBox();
monArrayId = 0;
rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
for (i = sMultiMove->minRow; i < rowCount; i++)
{
u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
for (j = sMultiMove->minColumn; j < columnCount; j++)
{
struct BoxPokemon *boxMon = GetBoxedMonPtr(boxId, boxPosition);
// UB: possible null dereference
#ifdef UBFIX
if (boxMon != NULL)
sMoveMonsPtr->boxMons[monArrayId] = *boxMon;
sMultiMove->boxMons[monArrayId] = *boxMon;
#else
sMoveMonsPtr->boxMons[monArrayId] = *boxMon;
sMultiMove->boxMons[monArrayId] = *boxMon;
#endif
monArrayId++;
boxPosition++;
@ -486,17 +466,17 @@ static void sub_80957C8(void)
}
}
static void sub_80958A0(void)
static void MultiMove_RemoveMonsFromBox(void)
{
s32 i, j;
s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
u8 boxId = StorageGetCurrentBox();
for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
for (i = sMultiMove->minRow; i < rowCount; i++)
{
u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
for (j = sMultiMove->minColumn; j < columnCount; j++)
{
DestroyBoxMonIconAtPosition(boxPosition);
ZeroBoxMonAt(boxId, boxPosition);
@ -505,75 +485,75 @@ static void sub_80958A0(void)
}
}
static void sub_8095918(void)
static void MultiMove_CreatePlacedMonIcons(void)
{
s32 i, j;
s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
u8 monArrayId = 0;
for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
for (i = sMultiMove->minRow; i < rowCount; i++)
{
u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
for (j = sMultiMove->minColumn; j < columnCount; j++)
{
if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
sub_80901EC(boxPosition);
if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
CreateBoxMonIconAtPos(boxPosition);
monArrayId++;
boxPosition++;
}
}
}
static void sub_80959A8(void)
static void MultiMove_SetPlacedMonData(void)
{
s32 i, j;
s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
u8 boxId = StorageGetCurrentBox();
u8 monArrayId = 0;
for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
for (i = sMultiMove->minRow; i < rowCount; i++)
{
u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
for (j = sMultiMove->minColumn; j < columnCount; j++)
{
if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
SetBoxMonAt(boxId, boxPosition, &sMoveMonsPtr->boxMons[monArrayId]);
if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES))
SetBoxMonAt(boxId, boxPosition, &sMultiMove->boxMons[monArrayId]);
boxPosition++;
monArrayId++;
}
}
}
static void sub_8095A58(void)
static void MultiMove_ResetBg(void)
{
ChangeBgX(0, 0, 0);
ChangeBgY(0, 0, 0);
ChangeBgX(0, 0, BG_COORD_SET);
ChangeBgY(0, 0, BG_COORD_SET);
SetBgAttribute(0, BG_ATTR_PALETTEMODE, 0);
ClearGpuRegBits(REG_OFFSET_BG0CNT, BGCNT_256COLOR);
FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32);
CopyBgTilemapBufferToVram(0);
}
u8 sub_8095AA0(void)
u8 MultiMove_GetOriginPosition(void)
{
return (IN_BOX_ROWS * sMoveMonsPtr->fromColumn) + sMoveMonsPtr->fromRow;
return (IN_BOX_COLUMNS * sMultiMove->fromRow) + sMultiMove->fromColumn;
}
bool8 sub_8095ABC(void)
bool8 MultiMove_CanPlaceSelection(void)
{
s32 i, j;
s32 rowCount = sMoveMonsPtr->minRow + sMoveMonsPtr->rowsTotal;
s32 columnCount = sMoveMonsPtr->minColumn + sMoveMonsPtr->columsTotal;
s32 columnCount = sMultiMove->minColumn + sMultiMove->columnsTotal;
s32 rowCount = sMultiMove->minRow + sMultiMove->rowsTotal;
u8 monArrayId = 0;
for (i = sMoveMonsPtr->minColumn; i < columnCount; i++)
for (i = sMultiMove->minRow; i < rowCount; i++)
{
u8 boxPosition = (IN_BOX_ROWS * i) + sMoveMonsPtr->minRow;
for (j = sMoveMonsPtr->minRow; j < rowCount; j++)
u8 boxPosition = (IN_BOX_COLUMNS * i) + sMultiMove->minColumn;
for (j = sMultiMove->minColumn; j < columnCount; j++)
{
if (GetBoxMonData(&sMoveMonsPtr->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES)
if (GetBoxMonData(&sMultiMove->boxMons[monArrayId], MON_DATA_SANITY_HAS_SPECIES)
&& GetCurrentBoxMonData(boxPosition, MON_DATA_SANITY_HAS_SPECIES))
return FALSE;

349
src/pokemon_storage_system_8.c
View File

@ -42,7 +42,7 @@ static void SpriteCB_ItemIcon_HideParty(struct Sprite *sprite);
static const u32 sItemInfoFrame_Gfx[] = INCBIN_U32("graphics/interface/pss_unk_83D35DC.4bpp");
static const struct OamData gUnknown_83D365C = {
static const struct OamData sOamData_ItemIcon = {
.y = 0,
.affineMode = ST_OAM_AFFINE_NORMAL,
.objMode = ST_OAM_OBJ_NORMAL,
@ -58,65 +58,65 @@ static const struct OamData gUnknown_83D365C = {
.affineParam = 0
};
static const union AffineAnimCmd gUnknown_83D3664[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_Small[] = {
AFFINEANIMCMD_FRAME(128, 128, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D3674[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_Appear[] = {
AFFINEANIMCMD_FRAME(88, 88, 0, 0),
AFFINEANIMCMD_FRAME(5, 5, 0, 8),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D368C[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_Disappear[] = {
AFFINEANIMCMD_FRAME(128, 128, 0, 0),
AFFINEANIMCMD_FRAME(-5, -5, 0, 8),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D36A4[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_PickUp[] = {
AFFINEANIMCMD_FRAME(128, 128, 0, 0),
AFFINEANIMCMD_FRAME(10, 10, 0, 12),
AFFINEANIMCMD_FRAME(256, 256, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D36C4[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_PutDown[] = {
AFFINEANIMCMD_FRAME(256, 256, 0, 0),
AFFINEANIMCMD_FRAME(-10, -10, 0, 12),
AFFINEANIMCMD_FRAME(128, 128, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D36E4[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_PutAway[] = {
AFFINEANIMCMD_FRAME(256, 256, 0, 0),
AFFINEANIMCMD_FRAME(-5, -5, 0, 16),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd gUnknown_83D36FC[] = {
static const union AffineAnimCmd sAffineAnim_ItemIcon_Large[] = {
AFFINEANIMCMD_FRAME(256, 256, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const gUnknown_83D370C[] = {
gUnknown_83D3664,
gUnknown_83D3674,
gUnknown_83D368C,
gUnknown_83D36A4,
gUnknown_83D36C4,
gUnknown_83D36E4,
gUnknown_83D36FC
static const union AffineAnimCmd *const sAffineAnims_ItemIcon[] = {
[ITEM_ANIM_NONE] = sAffineAnim_ItemIcon_Small,
[ITEM_ANIM_APPEAR] = sAffineAnim_ItemIcon_Appear,
[ITEM_ANIM_DISAPPEAR] = sAffineAnim_ItemIcon_Disappear,
[ITEM_ANIM_PICK_UP] = sAffineAnim_ItemIcon_PickUp,
[ITEM_ANIM_PUT_DOWN] = sAffineAnim_ItemIcon_PutDown,
[ITEM_ANIM_PUT_AWAY] = sAffineAnim_ItemIcon_PutAway,
[ITEM_ANIM_LARGE] = sAffineAnim_ItemIcon_Large,
};
static const struct SpriteTemplate sSpriteTemplate_ItemIcon = {
.tileTag = TAG_TILE_7,
.paletteTag = TAG_PAL_DACB,
.oam = &gUnknown_83D365C,
.tileTag = GFXTAG_ITEM_ICON_0,
.paletteTag = PALTAG_ITEM_ICON_0,
.oam = &sOamData_ItemIcon,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gUnknown_83D370C,
.affineAnims = sAffineAnims_ItemIcon,
.callback = SpriteCallbackDummy,
};
@ -128,7 +128,7 @@ void CreateItemIconSprites(void)
struct SpriteTemplate spriteTemplate;
static u32 sItemIconGfxBuffer[0x61];
if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
if (gStorage->boxOption == OPTION_MOVE_ITEMS)
{
spriteSheet.data = sItemIconGfxBuffer;
spriteSheet.size = 0x200;
@ -136,30 +136,28 @@ void CreateItemIconSprites(void)
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
spriteSheet.tag = TAG_TILE_7 + i;
spriteSheet.tag = GFXTAG_ITEM_ICON_0 + i;
LoadCompressedSpriteSheet(&spriteSheet);
gPSSData->itemIcons[i].tiles = GetSpriteTileStartByTag(spriteSheet.tag) * TILE_SIZE_4BPP + (void *)(OBJ_VRAM0);
gPSSData->itemIcons[i].palIndex = AllocSpritePalette(TAG_PAL_DACB + i);
gPSSData->itemIcons[i].palIndex *= 16;
gPSSData->itemIcons[i].palIndex += 0x100;
spriteTemplate.tileTag = TAG_TILE_7 + i;
spriteTemplate.paletteTag = TAG_PAL_DACB + i;
gStorage->itemIcons[i].tiles = GetSpriteTileStartByTag(spriteSheet.tag) * TILE_SIZE_4BPP + (void *)(OBJ_VRAM0);
gStorage->itemIcons[i].palIndex = AllocSpritePalette(PALTAG_ITEM_ICON_0 + i);
gStorage->itemIcons[i].palIndex *= 16;
gStorage->itemIcons[i].palIndex += 0x100;
spriteTemplate.tileTag = GFXTAG_ITEM_ICON_0 + i;
spriteTemplate.paletteTag = PALTAG_ITEM_ICON_0 + i;
spriteId = CreateSprite(&spriteTemplate, 0, 0, 11);
gPSSData->itemIcons[i].sprite = &gSprites[spriteId];
gPSSData->itemIcons[i].sprite->invisible = TRUE;
gPSSData->itemIcons[i].active = FALSE;
gStorage->itemIcons[i].sprite = &gSprites[spriteId];
gStorage->itemIcons[i].sprite->invisible = TRUE;
gStorage->itemIcons[i].active = FALSE;
}
}
gPSSData->movingItemId = ITEM_NONE;
gStorage->movingItemId = ITEM_NONE;
}
void sub_8095C84(u8 cursorArea, u8 cursorPos)
void TryLoadItemIconAtPos(u8 cursorArea, u8 cursorPos)
{
u16 heldItem;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
return;
if (IsItemIconAtPosition(cursorArea, cursorPos))
if ((gStorage->boxOption != OPTION_MOVE_ITEMS) || IsItemIconAtPosition(cursorArea, cursorPos))
return;
switch (cursorArea)
@ -186,21 +184,21 @@ void sub_8095C84(u8 cursorArea, u8 cursorPos)
SetItemIconPosition(id, cursorArea, cursorPos);
LoadItemIconGfx(id, tiles, pal);
SetItemIconAffineAnim(id, 1);
SetItemIconAffineAnim(id, ITEM_ANIM_APPEAR);
SetItemIconActive(id, TRUE);
}
}
void sub_8095D44(u8 cursorArea, u8 cursorPos)
void TryHideItemIconAtPos(u8 cursorArea, u8 cursorPos)
{
u8 id;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
id = GetItemIconIdxByPosition(cursorArea, cursorPos);
SetItemIconAffineAnim(id, 2);
SetItemIconCallback(id, 0, cursorArea, cursorPos);
SetItemIconAffineAnim(id, ITEM_ANIM_DISAPPEAR);
SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, cursorArea, cursorPos);
}
void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
@ -208,14 +206,14 @@ void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
u8 id;
u16 item;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
id = GetItemIconIdxByPosition(cursorArea, cursorPos);
item = 0;
SetItemIconAffineAnim(id, 3);
SetItemIconCallback(id, 1, cursorArea, cursorPos);
SetItemIconPosition(id, 2, 0);
SetItemIconAffineAnim(id, ITEM_ANIM_PICK_UP);
SetItemIconCallback(id, ITEM_CB_TO_HAND, cursorArea, cursorPos);
SetItemIconPosition(id, CURSOR_AREA_IN_HAND, 0);
if (cursorArea == CURSOR_AREA_IN_BOX)
{
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &item);
@ -227,21 +225,21 @@ void Item_FromMonToMoving(u8 cursorArea, u8 cursorPos)
SetPartyMonIconObjMode(cursorPos, ST_OAM_OBJ_BLEND);
}
gPSSData->movingItemId = gPSSData->displayMonItemId;
gStorage->movingItemId = gStorage->displayMonItemId;
}
void sub_8095E2C(u16 item)
void InitItemIconInCursor(u16 item)
{
const u32 *tiles = GetItemIconPic(item);
const u32 *pal = GetItemIconPalette(item);
u8 id = GetNewItemIconIdx();
LoadItemIconGfx(id, tiles, pal);
SetItemIconAffineAnim(id, 6);
SetItemIconCallback(id, 1, CURSOR_AREA_IN_BOX, 0);
SetItemIconPosition(id, CURSOR_AREA_BOX, 0);
SetItemIconAffineAnim(id, ITEM_ANIM_LARGE);
SetItemIconCallback(id, ITEM_CB_TO_HAND, 0, 0);
SetItemIconPosition(id, CURSOR_AREA_IN_HAND, 0);
SetItemIconActive(id, TRUE);
gPSSData->movingItemId = item;
gStorage->movingItemId = item;
}
void Item_SwitchMonsWithMoving(u8 cursorArea, u8 cursorPos)
@ -249,48 +247,48 @@ void Item_SwitchMonsWithMoving(u8 cursorArea, u8 cursorPos)
u8 id;
u16 item;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
id = GetItemIconIdxByPosition(cursorArea, cursorPos);
SetItemIconAffineAnim(id, 3);
SetItemIconCallback(id, 3, CURSOR_AREA_BOX, 0);
SetItemIconAffineAnim(id, ITEM_ANIM_PICK_UP);
SetItemIconCallback(id, ITEM_CB_SWAP_TO_HAND, CURSOR_AREA_IN_HAND, 0);
if (cursorArea == CURSOR_AREA_IN_BOX)
{
item = GetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM);
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
gPSSData->movingItemId = item;
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gStorage->movingItemId);
gStorage->movingItemId = item;
}
else
{
item = GetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM);
SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
gPSSData->movingItemId = item;
SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gStorage->movingItemId);
gStorage->movingItemId = item;
}
id = GetItemIconIdxByPosition(2, 0);
SetItemIconAffineAnim(id, 4);
SetItemIconCallback(id, 4, cursorArea, cursorPos);
SetItemIconAffineAnim(id, ITEM_ANIM_PUT_DOWN);
SetItemIconCallback(id, ITEM_CB_SWAP_TO_MON, cursorArea, cursorPos);
}
void Item_GiveMovingToMon(u8 cursorArea, u8 cursorPos)
{
u8 id;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
id = GetItemIconIdxByPosition(2, 0);
SetItemIconAffineAnim(id, 4);
SetItemIconCallback(id, 2, cursorArea, cursorPos);
SetItemIconAffineAnim(id, ITEM_ANIM_PUT_DOWN);
SetItemIconCallback(id, ITEM_CB_TO_MON, cursorArea, cursorPos);
if (cursorArea == CURSOR_AREA_IN_BOX)
{
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &gStorage->movingItemId);
SetBoxMonIconObjMode(cursorPos, ST_OAM_OBJ_NORMAL);
}
else
{
SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gPSSData->movingItemId);
SetMonData(&gPlayerParty[cursorPos], MON_DATA_HELD_ITEM, &gStorage->movingItemId);
SetPartyMonIconObjMode(cursorPos, ST_OAM_OBJ_NORMAL);
}
}
@ -300,13 +298,13 @@ void Item_TakeMons(u8 cursorArea, u8 cursorPos)
u8 id;
u16 item;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
item = 0;
item = ITEM_NONE;
id = GetItemIconIdxByPosition(cursorArea, cursorPos);
SetItemIconAffineAnim(id, 2);
SetItemIconCallback(id, 0, cursorArea, cursorPos);
SetItemIconAffineAnim(id, ITEM_ANIM_DISAPPEAR);
SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, cursorArea, cursorPos);
if (cursorArea == CURSOR_AREA_IN_BOX)
{
SetCurrentBoxMonData(cursorPos, MON_DATA_HELD_ITEM, &item);
@ -319,41 +317,44 @@ void Item_TakeMons(u8 cursorArea, u8 cursorPos)
}
}
void sub_8096088(void)
void MoveItemFromCursorToBag(void)
{
if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
if (gStorage->boxOption == OPTION_MOVE_ITEMS)
{
u8 id = GetItemIconIdxByPosition(2, 0);
SetItemIconAffineAnim(id, 5);
SetItemIconCallback(id, 0, CURSOR_AREA_BOX, 0);
u8 id = GetItemIconIdxByPosition(CURSOR_AREA_IN_HAND, 0);
SetItemIconAffineAnim(id, ITEM_ANIM_PUT_AWAY);
SetItemIconCallback(id, ITEM_CB_WAIT_ANIM, 2, 0);
}
}
void sub_80960C0(void)
// The party menu is being closed, if the cursor is on
// a Pokémon that has a held item make sure it slides
// up along with the closing menu.
void MoveHeldItemWithPartyMenu(void)
{
s32 i;
if (gPSSData->boxOption != OPTION_MOVE_ITEMS)
if (gStorage->boxOption != OPTION_MOVE_ITEMS)
return;
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active && gPSSData->itemIcons[i].cursorArea == CURSOR_AREA_IN_PARTY)
SetItemIconCallback(i, 7, CURSOR_AREA_BOX, 0);
if (gStorage->itemIcons[i].active && gStorage->itemIcons[i].cursorArea == CURSOR_AREA_IN_PARTY)
SetItemIconCallback(i, ITEM_CB_HIDE_PARTY, 2, 0);
}
}
bool8 sub_809610C(void)
bool8 IsItemIconAnimActive(void)
{
s32 i;
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active)
if (gStorage->itemIcons[i].active)
{
if (!gPSSData->itemIcons[i].sprite->affineAnimEnded && gPSSData->itemIcons[i].sprite->affineAnimBeginning)
if (!gStorage->itemIcons[i].sprite->affineAnimEnded && gStorage->itemIcons[i].sprite->affineAnimBeginning)
return TRUE;
if (gPSSData->itemIcons[i].sprite->callback != SpriteCallbackDummy && gPSSData->itemIcons[i].sprite->callback != SpriteCB_ItemIcon_SetPosToCursor)
if (gStorage->itemIcons[i].sprite->callback != SpriteCallbackDummy && gStorage->itemIcons[i].sprite->callback != SpriteCB_ItemIcon_SetPosToCursor)
return TRUE;
}
}
@ -365,11 +366,11 @@ bool8 IsActiveItemMoving(void)
{
s32 i;
if (gPSSData->boxOption == OPTION_MOVE_ITEMS)
if (gStorage->boxOption == OPTION_MOVE_ITEMS)
{
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active && gPSSData->itemIcons[i].cursorArea == CURSOR_AREA_BOX)
if (gStorage->itemIcons[i].active && gStorage->itemIcons[i].cursorArea == CURSOR_AREA_BOX_TITLE)
return TRUE;
}
}
@ -379,12 +380,12 @@ bool8 IsActiveItemMoving(void)
const u8 *GetMovingItemName(void)
{
return ItemId_GetName(gPSSData->movingItemId);
return ItemId_GetName(gStorage->movingItemId);
}
u16 GetMovingItem(void)
{
return gPSSData->movingItemId;
return gStorage->movingItemId;
}
static u8 GetNewItemIconIdx(void)
@ -393,9 +394,9 @@ static u8 GetNewItemIconIdx(void)
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (!gPSSData->itemIcons[i].active)
if (!gStorage->itemIcons[i].active)
{
gPSSData->itemIcons[i].active = TRUE;
gStorage->itemIcons[i].active = TRUE;
return i;
}
}
@ -409,9 +410,9 @@ static bool32 IsItemIconAtPosition(u8 cursorArea, u8 cursorPos)
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active
&& gPSSData->itemIcons[i].cursorArea == cursorArea
&& gPSSData->itemIcons[i].cursorPos == cursorPos)
if (gStorage->itemIcons[i].active
&& gStorage->itemIcons[i].cursorArea == cursorArea
&& gStorage->itemIcons[i].cursorPos == cursorPos)
return TRUE;
}
@ -424,9 +425,9 @@ static u8 GetItemIconIdxByPosition(u8 cursorArea, u8 cursorPos)
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active
&& gPSSData->itemIcons[i].cursorArea == cursorArea
&& gPSSData->itemIcons[i].cursorPos == cursorPos)
if (gStorage->itemIcons[i].active
&& gStorage->itemIcons[i].cursorArea == cursorArea
&& gStorage->itemIcons[i].cursorPos == cursorPos)
return i;
}
@ -439,8 +440,8 @@ static u8 GetItemIconIdxBySprite(struct Sprite *sprite)
for (i = 0; i < MAX_ITEM_ICONS; i++)
{
if (gPSSData->itemIcons[i].active
&& gPSSData->itemIcons[i].sprite == sprite)
if (gStorage->itemIcons[i].active
&& gStorage->itemIcons[i].sprite == sprite)
return i;
}
@ -457,29 +458,29 @@ static void SetItemIconPosition(u8 id, u8 cursorArea, u8 cursorPos)
switch (cursorArea)
{
case CURSOR_AREA_IN_BOX:
row = cursorPos % IN_BOX_ROWS;
column = cursorPos / IN_BOX_ROWS;
gPSSData->itemIcons[id].sprite->x = (24 * row) + 112;
gPSSData->itemIcons[id].sprite->y = (24 * column) + 56;
gPSSData->itemIcons[id].sprite->oam.priority = 2;
row = cursorPos % IN_BOX_COLUMNS;
column = cursorPos / IN_BOX_COLUMNS;
gStorage->itemIcons[id].sprite->x = (24 * row) + 112;
gStorage->itemIcons[id].sprite->y = (24 * column) + 56;
gStorage->itemIcons[id].sprite->oam.priority = 2;
break;
case CURSOR_AREA_IN_PARTY:
if (cursorPos == 0)
{
gPSSData->itemIcons[id].sprite->x = 116;
gPSSData->itemIcons[id].sprite->y = 76;
gStorage->itemIcons[id].sprite->x = 116;
gStorage->itemIcons[id].sprite->y = 76;
}
else
{
gPSSData->itemIcons[id].sprite->x = 164;
gPSSData->itemIcons[id].sprite->y = 24 * (cursorPos - 1) + 28;
gStorage->itemIcons[id].sprite->x = 164;
gStorage->itemIcons[id].sprite->y = 24 * (cursorPos - 1) + 28;
}
gPSSData->itemIcons[id].sprite->oam.priority = 1;
gStorage->itemIcons[id].sprite->oam.priority = 1;
break;
}
gPSSData->itemIcons[id].cursorArea = cursorArea;
gPSSData->itemIcons[id].cursorPos = cursorPos;
gStorage->itemIcons[id].cursorArea = cursorArea;
gStorage->itemIcons[id].cursorPos = cursorPos;
}
static void LoadItemIconGfx(u8 id, const u32 *itemTiles, const u32 *itemPal)
@ -489,14 +490,14 @@ static void LoadItemIconGfx(u8 id, const u32 *itemTiles, const u32 *itemPal)
if (id >= MAX_ITEM_ICONS)
return;
CpuFastFill(0, gPSSData->itemIconBuffer, 0x200);
LZ77UnCompWram(itemTiles, gPSSData->field_22C4);
CpuFastFill(0, gStorage->itemIconBuffer, 0x200);
LZ77UnCompWram(itemTiles, gStorage->tileBuffer);
for (i = 0; i < 3; i++)
CpuFastCopy(gPSSData->field_22C4 + (i * 0x60), gPSSData->itemIconBuffer + (i * 0x80), 0x60);
CpuFastCopy(gStorage->tileBuffer + (i * 0x60), gStorage->itemIconBuffer + (i * 0x80), 0x60);
CpuFastCopy(gPSSData->itemIconBuffer, gPSSData->itemIcons[id].tiles, 0x200);
LZ77UnCompWram(itemPal, gPSSData->itemIconBuffer);
LoadPalette(gPSSData->itemIconBuffer, gPSSData->itemIcons[id].palIndex, 0x20);
CpuFastCopy(gStorage->itemIconBuffer, gStorage->itemIcons[id].tiles, 0x200);
LZ77UnCompWram(itemPal, gStorage->itemIconBuffer);
LoadPalette(gStorage->itemIconBuffer, gStorage->itemIcons[id].palIndex, 0x20);
}
static void SetItemIconAffineAnim(u8 id, u8 animNum)
@ -504,7 +505,7 @@ static void SetItemIconAffineAnim(u8 id, u8 animNum)
if (id >= MAX_ITEM_ICONS)
return;
StartSpriteAffineAnim(gPSSData->itemIcons[id].sprite, animNum);
StartSpriteAffineAnim(gStorage->itemIcons[id].sprite, animNum);
}
#define sItemIconId data[0]
@ -520,36 +521,36 @@ static void SetItemIconCallback(u8 id, u8 callbackId, u8 cursorArea, u8 cursorPo
switch (callbackId)
{
case ITEM_CB_WAIT_ANIM:
gPSSData->itemIcons[id].sprite->sItemIconId = id;
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_WaitAnim;
gStorage->itemIcons[id].sprite->sItemIconId = id;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_WaitAnim;
break;
case ITEM_CB_TO_HAND:
gPSSData->itemIcons[id].sprite->sState = 0;
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToHand;
gStorage->itemIcons[id].sprite->sState = 0;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToHand;
break;
case ITEM_CB_TO_MON:
gPSSData->itemIcons[id].sprite->sState = 0;
gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToMon;
gStorage->itemIcons[id].sprite->sState = 0;
gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_ToMon;
break;
case ITEM_CB_SWAP_TO_HAND:
gPSSData->itemIcons[id].sprite->sState = 0;
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToHand;
gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
gStorage->itemIcons[id].sprite->sState = 0;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToHand;
gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
break;
case ITEM_CB_SWAP_TO_MON:
gPSSData->itemIcons[id].sprite->sState = 0;
gPSSData->itemIcons[id].sprite->sCursorArea = cursorArea;
gPSSData->itemIcons[id].sprite->sCursorPos = cursorPos;
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToMon;
gStorage->itemIcons[id].sprite->sState = 0;
gStorage->itemIcons[id].sprite->sCursorArea = cursorArea;
gStorage->itemIcons[id].sprite->sCursorPos = cursorPos;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_SwapToMon;
break;
case ITEM_CB_HIDE_PARTY:
// If cursor is on a Pokémon with a held item and
// the player closes the party menu, have the held
// item follow the Pokémon as the menu slides out
gPSSData->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_HideParty;
gStorage->itemIcons[id].sprite->callback = SpriteCB_ItemIcon_HideParty;
break;
}
}
@ -559,8 +560,8 @@ static void SetItemIconActive(u8 id, bool8 show)
if (id >= MAX_ITEM_ICONS)
return;
gPSSData->itemIcons[id].active = show;
gPSSData->itemIcons[id].sprite->invisible = (show == FALSE);
gStorage->itemIcons[id].active = show;
gStorage->itemIcons[id].sprite->invisible = (show == FALSE);
}
static const u32 *GetItemIconPic(u16 itemId)
@ -578,9 +579,9 @@ void PrintItemDescription(void)
const u8 *description;
if (IsActiveItemMoving())
description = ItemId_GetDescription(gPSSData->movingItemId);
description = ItemId_GetDescription(gStorage->movingItemId);
else
description = ItemId_GetDescription(gPSSData->displayMonItemId);
description = ItemId_GetDescription(gStorage->displayMonItemId);
FillWindowPixelBuffer(2, PIXEL_FILL(1));
AddTextPrinterParameterized5(2, FONT_2, description, 2, 0, 0, NULL, 0, 0);
@ -588,7 +589,7 @@ void PrintItemDescription(void)
void InitItemInfoWindow(void)
{
gPSSData->itemInfoWindowOffset = 25;
gStorage->itemInfoWindowOffset = 25;
LoadBgTiles(0, sItemInfoFrame_Gfx, 0x80, 0x1A4);
DrawItemInfoWindow(0);
}
@ -597,53 +598,49 @@ bool8 UpdateItemInfoWindowSlideIn(void)
{
s32 i, pos;
if (gPSSData->itemInfoWindowOffset == 0)
if (gStorage->itemInfoWindowOffset == 0)
return FALSE;
gPSSData->itemInfoWindowOffset--;
pos = 25 - gPSSData->itemInfoWindowOffset;
gStorage->itemInfoWindowOffset--;
pos = 25 - gStorage->itemInfoWindowOffset;
for (i = 0; i < pos; i++)
{
WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gPSSData->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
}
WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gStorage->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
DrawItemInfoWindow(pos);
return (gPSSData->itemInfoWindowOffset != 0);
return (gStorage->itemInfoWindowOffset != 0);
}
bool8 UpdateItemInfoWindowSlideOut(void)
{
s32 i, pos;
if (gPSSData->itemInfoWindowOffset == 25)
if (gStorage->itemInfoWindowOffset == 25)
return FALSE;
if (gPSSData->itemInfoWindowOffset == 0)
if (gStorage->itemInfoWindowOffset == 0)
FillBgTilemapBufferRect(0, 0, 25, 11, 1, 10, 17);
gPSSData->itemInfoWindowOffset++;
pos = 25 - gPSSData->itemInfoWindowOffset;
gStorage->itemInfoWindowOffset++;
pos = 25 - gStorage->itemInfoWindowOffset;
for (i = 0; i < pos; i++)
{
WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gPSSData->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
}
WriteSequenceToBgTilemapBuffer(0, GetBgAttribute(0, BG_ATTR_BASETILE) + 0x14 + gStorage->itemInfoWindowOffset + i, i, 12, 1, 8, 15, 25);
DrawItemInfoWindow(pos);
FillBgTilemapBufferRect(0, 0, pos, 11, 1, 10, 0x11);
return (gPSSData->itemInfoWindowOffset != 25);
FillBgTilemapBufferRect(0, 0, pos, 11, 1, 10, 17);
return (gStorage->itemInfoWindowOffset != 25);
}
static void DrawItemInfoWindow(u32 x)
{
if (x != 0)
{
FillBgTilemapBufferRect(0, 0x1A4, 0, 0xB, x, 1, 0xFu);
FillBgTilemapBufferRect(0, 0x9A4, 0, 0x14, x, 1, 0xFu);
FillBgTilemapBufferRect(0, 0x1A4, 0, 0xB, x, 1, 15);
FillBgTilemapBufferRect(0, 0x9A4, 0, 0x14, x, 1, 15);
}
FillBgTilemapBufferRect(0, 0x1A5, x, 0xC, 1, 8, 0xFu);
FillBgTilemapBufferRect(0, 0x1A6, x, 0xB, 1, 1, 0xFu);
FillBgTilemapBufferRect(0, 0x1A7, x, 0x14, 1, 1, 0xFu);
FillBgTilemapBufferRect(0, 0x1A5, x, 0xC, 1, 8, 15);
FillBgTilemapBufferRect(0, 0x1A6, x, 0xB, 1, 1, 15);
FillBgTilemapBufferRect(0, 0x1A7, x, 0x14, 1, 1, 15);
ScheduleBgCopyTilemapToVram(0);
}
@ -651,14 +648,14 @@ static void SpriteCB_ItemIcon_WaitAnim(struct Sprite *sprite)
{
if (sprite->affineAnimEnded)
{
SetItemIconActive(sprite->data[0], FALSE);
SetItemIconActive(sprite->sItemIconId, FALSE);
sprite->callback = SpriteCallbackDummy;
}
}
static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
{
switch (sprite->data[0])
switch (sprite->sState)
{
case 0:
sprite->data[1] = sprite->x << 4;
@ -666,7 +663,7 @@ static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
sprite->data[3] = 10;
sprite->data[4] = 21;
sprite->data[5] = 0;
sprite->data[0]++;
sprite->sState++;
case 1:
sprite->data[1] -= sprite->data[3];
sprite->data[2] -= sprite->data[4];
@ -680,14 +677,14 @@ static void SpriteCB_ItemIcon_ToHand(struct Sprite *sprite)
static void SpriteCB_ItemIcon_SetPosToCursor(struct Sprite *sprite)
{
sprite->x = gPSSData->cursorSprite->x + 4;
sprite->y = gPSSData->cursorSprite->y + gPSSData->cursorSprite->y2 + 8;
sprite->oam.priority = gPSSData->cursorSprite->oam.priority;
sprite->x = gStorage->cursorSprite->x + 4;
sprite->y = gStorage->cursorSprite->y + gStorage->cursorSprite->y2 + 8;
sprite->oam.priority = gStorage->cursorSprite->oam.priority;
}
static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
{
switch (sprite->data[0])
switch (sprite->sState)
{
case 0:
sprite->data[1] = sprite->x << 4;
@ -695,7 +692,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
sprite->data[3] = 10;
sprite->data[4] = 21;
sprite->data[5] = 0;
sprite->data[0]++;
sprite->sState++;
case 1:
sprite->data[1] += sprite->data[3];
sprite->data[2] += sprite->data[4];
@ -703,7 +700,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
sprite->y = sprite->data[2] >> 4;
if (++sprite->data[5] > 11)
{
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
sprite->callback = SpriteCallbackDummy;
}
break;
@ -712,7 +709,7 @@ static void SpriteCB_ItemIcon_ToMon(struct Sprite *sprite)
static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
{
switch (sprite->data[0])
switch (sprite->sState)
{
case 0:
sprite->data[1] = sprite->x << 4;
@ -720,7 +717,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
sprite->data[3] = 10;
sprite->data[4] = 21;
sprite->data[5] = 0;
sprite->data[0]++;
sprite->sState++;
case 1:
sprite->data[1] -= sprite->data[3];
sprite->data[2] -= sprite->data[4];
@ -729,7 +726,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
sprite->x2 = gSineTable[sprite->data[5] * 8] >> 4;
if (++sprite->data[5] > 11)
{
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
sprite->x2 = 0;
sprite->callback = SpriteCB_ItemIcon_SetPosToCursor;
}
@ -739,7 +736,7 @@ static void SpriteCB_ItemIcon_SwapToHand(struct Sprite *sprite)
static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
{
switch (sprite->data[0])
switch (sprite->sState)
{
case 0:
sprite->data[1] = sprite->x << 4;
@ -747,7 +744,7 @@ static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
sprite->data[3] = 10;
sprite->data[4] = 21;
sprite->data[5] = 0;
sprite->data[0]++;
sprite->sState++;
case 1:
sprite->data[1] += sprite->data[3];
sprite->data[2] += sprite->data[4];
@ -756,7 +753,7 @@ static void SpriteCB_ItemIcon_SwapToMon(struct Sprite *sprite)
sprite->x2 = -(gSineTable[sprite->data[5] * 8] >> 4);
if (++sprite->data[5] > 11)
{
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->data[6], sprite->data[7]);
SetItemIconPosition(GetItemIconIdxBySprite(sprite), sprite->sCursorArea, sprite->sCursorPos);
sprite->callback = SpriteCallbackDummy;
sprite->x2 = 0;
}
@ -779,16 +776,10 @@ static void SpriteCB_ItemIcon_HideParty(struct Sprite *sprite)
#undef sCursorArea
#undef sCursorPos
//------------------------------------------------------------------------------
// SECTION: UnkUtil
//
// Some data transfer utility that goes functionally unused.
// It gets initialized with UnkUtil_Init, and run every vblank in Pokémon
// Storage with UnkUtil_Run, but neither of the Add functions are ever used,
// so UnkUtil_Run performs no actions.
//------------------------------------------------------------------------------
static EWRAM_DATA struct UnkUtil *sUnkUtil = NULL;

2
src/tm_case.c
View File

@ -953,7 +953,7 @@ static void Task_SelectTMAction_Type3(u8 taskId)
if (!itemid_is_unique(BagGetItemIdByPocketPosition(POCKET_TM_CASE, data[1])))
{
sTMCaseDynamicResources->savedCallback = Cb2_ReturnToPSS;
sTMCaseDynamicResources->savedCallback = CB2_ReturnToPokeStorage;
Task_BeginFadeOutFromTMCase(taskId);
}
else