diff options
Diffstat (limited to 'src')
64 files changed, 11279 insertions, 1278 deletions
diff --git a/src/apprentice.c b/src/apprentice.c new file mode 100644 index 000000000..f2a8aa9c0 --- /dev/null +++ b/src/apprentice.c @@ -0,0 +1,2380 @@ +#include "global.h" +#include "apprentice.h" +#include "battle_tower.h" +#include "data2.h" +#include "event_data.h" +#include "event_object_movement.h" +#include "field_player_avatar.h" +#include "international_string_util.h" +#include "item.h" +#include "item_menu.h" +#include "main.h" +#include "malloc.h" +#include "menu.h" +#include "new_game.h" +#include "party_menu.h" +#include "random.h" +#include "script.h" +#include "script_menu.h" +#include "sound.h" +#include "string_util.h" +#include "strings.h" +#include "task.h" +#include "text.h" +#include "constants/apprentice.h" +#include "constants/items.h" +#include "constants/songs.h" +#include "constants/species.h" +#include "constants/moves.h" + +#define PLAYER_APPRENTICE gSaveBlock2Ptr->playerApprentice + +struct Unk030062ECStruct +{ + u8 unk0; + u16 unk2[3][5]; + u8 unk20[3][5]; +}; + +struct Unk030062F0Struct +{ + u16 unk0; + u16 unk2; + u16 unk4; + u16 unk6; +}; + +// data/scripts/apprentice.inc +extern const u8 gText_082B7229[]; +extern const u8 gText_082B731C[]; +extern const u8 gText_082B735B[]; +extern const u8 gText_082B7423[]; +extern const u8 gText_082B74C1[]; +extern const u8 gText_082B756F[]; +extern const u8 gText_082B75B2[]; +extern const u8 gText_082B763F[]; +extern const u8 gText_082B76AC[]; +extern const u8 gText_082B7772[]; +extern const u8 gText_082B77CE[]; +extern const u8 gText_082B7871[]; +extern const u8 gText_082B78D4[]; +extern const u8 gText_082B7B1A[]; +extern const u8 gText_082B7C13[]; +extern const u8 gText_082B7D18[]; +extern const u8 gText_082B7DD4[]; +extern const u8 gText_082B7EE5[]; +extern const u8 gText_082B7F35[]; +extern const u8 gText_082B7FE8[]; +extern const u8 gText_082B8087[]; +extern const u8 gText_082B822B[]; +extern const u8 gText_082B8286[]; +extern const u8 gText_082B8356[]; +extern const u8 gText_082B83CE[]; +extern const u8 gText_082B84FC[]; +extern const u8 gText_082B8559[]; +extern const u8 gText_082B8656[]; +extern const u8 gText_082B86EA[]; +extern const u8 gText_082B87DA[]; +extern const u8 gText_082B887C[]; +extern const u8 gText_082B8957[]; +extern const u8 gText_082B89C6[]; +extern const u8 gText_082B8ACF[]; +extern const u8 gText_082B8B66[]; +extern const u8 gText_082B8C20[]; +extern const u8 gText_082B8CAA[]; +extern const u8 gText_082B8DD3[]; +extern const u8 gText_082B8E24[]; +extern const u8 gText_082B8ED5[]; +extern const u8 gText_082B8F45[]; +extern const u8 gText_082B905F[]; +extern const u8 gText_082B910E[]; +extern const u8 gText_082B9204[]; +extern const u8 gText_082B929C[]; +extern const u8 gText_082B9438[]; +extern const u8 gText_082B9488[]; +extern const u8 gText_082B9564[]; +extern const u8 gText_082B95D8[]; +extern const u8 gText_082B9763[]; +extern const u8 gText_082B97E5[]; +extern const u8 gText_082B989A[]; +extern const u8 gText_082B992D[]; +extern const u8 gText_082B9A84[]; +extern const u8 gText_082B9AB9[]; +extern const u8 gText_082B9B76[]; +extern const u8 gText_082B9BF2[]; +extern const u8 gText_082B9D83[]; +extern const u8 gText_082B9DF9[]; +extern const u8 gText_082B9EAA[]; +extern const u8 gText_082B9F55[]; +extern const u8 gText_082BA084[]; +extern const u8 gText_082BA11D[]; +extern const u8 gText_082BA1F3[]; + +extern const u8 gText_082BE50D[]; +extern const u8 gText_082BE5F5[]; +extern const u8 gText_082BE679[]; +extern const u8 gText_082BE71E[]; +extern const u8 gText_082BE762[]; +extern const u8 gText_082BE7F8[]; +extern const u8 gText_082BE850[]; +extern const u8 gText_082BE99C[]; +extern const u8 gText_082BEA1B[]; +extern const u8 gText_082BEAE9[]; +extern const u8 gText_082BEB72[]; +extern const u8 gText_082BEC8E[]; +extern const u8 gText_082BED16[]; +extern const u8 gText_082BEE29[]; +extern const u8 gText_082BEEB4[]; +extern const u8 gText_082BEFE2[]; +extern const u8 gText_082BF04E[]; +extern const u8 gText_082BF11D[]; +extern const u8 gText_082BF1A8[]; +extern const u8 gText_082BF268[]; +extern const u8 gText_082BF2D1[]; +extern const u8 gText_082BF3CF[]; +extern const u8 gText_082BF46A[]; +extern const u8 gText_082BF551[]; +extern const u8 gText_082BF5C3[]; +extern const u8 gText_082BF6E5[]; +extern const u8 gText_082BF773[]; +extern const u8 gText_082BF869[]; +extern const u8 gText_082BF8DD[]; +extern const u8 gText_082BF9BA[]; +extern const u8 gText_082BFA5A[]; +extern const u8 gText_082BFB4E[]; + +extern const u8 gText_082BA2A3[]; +extern const u8 gText_082BA34E[]; +extern const u8 gText_082BA380[]; +extern const u8 gText_082BA3D2[]; +extern const u8 gText_082BA448[]; +extern const u8 gText_082BA4D3[]; +extern const u8 gText_082BA58C[]; +extern const u8 gText_082BA5BF[]; +extern const u8 gText_082BA5F3[]; +extern const u8 gText_082BA635[]; +extern const u8 gText_082BA6E6[]; +extern const u8 gText_082BA742[]; +extern const u8 gText_082BA770[]; +extern const u8 gText_082BA78F[]; +extern const u8 gText_082BA7D8[]; +extern const u8 gText_082BA867[]; +extern const u8 gText_082BA96B[]; +extern const u8 gText_082BA9B7[]; +extern const u8 gText_082BAA1B[]; +extern const u8 gText_082BAA81[]; +extern const u8 gText_082BAB22[]; +extern const u8 gText_082BAC43[]; +extern const u8 gText_082BAC78[]; +extern const u8 gText_082BAD17[]; +extern const u8 gText_082BADB6[]; +extern const u8 gText_082BAE36[]; +extern const u8 gText_082BAF4E[]; +extern const u8 gText_082BAF8F[]; +extern const u8 gText_082BAFDB[]; +extern const u8 gText_082BB05F[]; +extern const u8 gText_082BB0D4[]; +extern const u8 gText_082BB18C[]; +extern const u8 gText_082BB1CE[]; +extern const u8 gText_082BB242[]; +extern const u8 gText_082BB2D9[]; +extern const u8 gText_082BB370[]; +extern const u8 gText_082BB4C3[]; +extern const u8 gText_082BB4FB[]; +extern const u8 gText_082BB575[]; +extern const u8 gText_082BB5E1[]; +extern const u8 gText_082BB656[]; +extern const u8 gText_082BB6E5[]; +extern const u8 gText_082BB72C[]; +extern const u8 gText_082BB7A2[]; +extern const u8 gText_082BB84A[]; +extern const u8 gText_082BB8CD[]; +extern const u8 gText_082BB970[]; +extern const u8 gText_082BB9AE[]; +extern const u8 gText_082BBA05[]; +extern const u8 gText_082BBA6C[]; +extern const u8 gText_082BBB01[]; +extern const u8 gText_082BBC1C[]; +extern const u8 gText_082BBC4B[]; +extern const u8 gText_082BBCF6[]; +extern const u8 gText_082BBD90[]; +extern const u8 gText_082BBE0B[]; +extern const u8 gText_082BBEE5[]; +extern const u8 gText_082BBF25[]; +extern const u8 gText_082BBFA4[]; +extern const u8 gText_082BC024[]; +extern const u8 gText_082BC0C8[]; +extern const u8 gText_082BC213[]; +extern const u8 gText_082BC247[]; +extern const u8 gText_082BC2DD[]; +extern const u8 gText_082BC373[]; +extern const u8 gText_082BC40E[]; +extern const u8 gText_082BC514[]; +extern const u8 gText_082BC555[]; +extern const u8 gText_082BC5CE[]; +extern const u8 gText_082BC666[]; +extern const u8 gText_082BC714[]; +extern const u8 gText_082BC808[]; +extern const u8 gText_082BC84D[]; +extern const u8 gText_082BC8EA[]; +extern const u8 gText_082BC984[]; +extern const u8 gText_082BCA4D[]; +extern const u8 gText_082BCB75[]; +extern const u8 gText_082BCBA6[]; +extern const u8 gText_082BCBFC[]; +extern const u8 gText_082BCCA4[]; + +extern const u8 gText_082BFBF2[]; +extern const u8 gText_082BFCAE[]; +extern const u8 gText_082BFD26[]; +extern const u8 gText_082BFDB1[]; +extern const u8 gText_082BFE24[]; +extern const u8 gText_082BFEAD[]; +extern const u8 gText_082BFF0A[]; +extern const u8 gText_082C0032[]; +extern const u8 gText_082C0090[]; +extern const u8 gText_082C016E[]; +extern const u8 gText_082C01F7[]; +extern const u8 gText_082C034C[]; +extern const u8 gText_082C03CA[]; +extern const u8 gText_082C046E[]; +extern const u8 gText_082C04F9[]; +extern const u8 gText_082C0598[]; +extern const u8 gText_082C0602[]; +extern const u8 gText_082C06D8[]; +extern const u8 gText_082C074A[]; +extern const u8 gText_082C0809[]; +extern const u8 gText_082C086E[]; +extern const u8 gText_082C0982[]; +extern const u8 gText_082C0A1D[]; +extern const u8 gText_082C0AFD[]; +extern const u8 gText_082C0B6F[]; +extern const u8 gText_082C0C7D[]; +extern const u8 gText_082C0D0B[]; +extern const u8 gText_082C0DFE[]; +extern const u8 gText_082C0E71[]; +extern const u8 gText_082C0F6D[]; +extern const u8 gText_082C1003[]; +extern const u8 gText_082C1122[]; + +extern const u8 gText_082BCD68[]; +extern const u8 gText_082BCE64[]; +extern const u8 gText_082BCEF2[]; +extern const u8 gText_082BCF61[]; +extern const u8 gText_082BCFA1[]; +extern const u8 gText_082BD03C[]; +extern const u8 gText_082BD06D[]; +extern const u8 gText_082BD18A[]; +extern const u8 gText_082BD222[]; +extern const u8 gText_082BD325[]; +extern const u8 gText_082BD3B1[]; +extern const u8 gText_082BD493[]; +extern const u8 gText_082BD51C[]; +extern const u8 gText_082BD609[]; +extern const u8 gText_082BD697[]; +extern const u8 gText_082BD797[]; +extern const u8 gText_082BD806[]; +extern const u8 gText_082BD8F5[]; +extern const u8 gText_082BD9BE[]; +extern const u8 gText_082BDAE1[]; +extern const u8 gText_082BDB4E[]; +extern const u8 gText_082BDC6B[]; +extern const u8 gText_082BDD0D[]; +extern const u8 gText_082BDDEC[]; +extern const u8 gText_082BDE68[]; +extern const u8 gText_082BDF4D[]; +extern const u8 gText_082BDFD8[]; +extern const u8 gText_082BE0FD[]; +extern const u8 gText_082BE189[]; +extern const u8 gText_082BE2A5[]; +extern const u8 gText_082BE33E[]; +extern const u8 gText_082BE46C[]; + +extern const u8 gText_082C11D1[]; +extern const u8 gText_082C12D5[]; +extern const u8 gText_082C13AB[]; +extern const u8 gText_082C1444[]; +extern const u8 gText_082C1501[]; +extern const u8 gText_082C15B6[]; +extern const u8 gText_082C165E[]; +extern const u8 gText_082C174F[]; +extern const u8 gText_082C1862[]; +extern const u8 gText_082C19A0[]; +extern const u8 gText_082C1A76[]; +extern const u8 gText_082C1C16[]; +extern const u8 gText_082C1CF5[]; +extern const u8 gText_082C1DC1[]; +extern const u8 gText_082C1EDC[]; +extern const u8 gText_082C1FEC[]; +extern const u8 gText_082C20D1[]; +extern const u8 gText_082C21FF[]; +extern const u8 gText_082C231C[]; +extern const u8 gText_082C2407[]; +extern const u8 gText_082C24B5[]; +extern const u8 gText_082C25B1[]; +extern const u8 gText_082C2707[]; +extern const u8 gText_082C27D4[]; +extern const u8 gText_082C28D6[]; +extern const u8 gText_082C2A0B[]; +extern const u8 gText_082C2B50[]; +extern const u8 gText_082C2C77[]; +extern const u8 gText_082C2D67[]; +extern const u8 gText_082C2E41[]; +extern const u8 gText_082C2EF5[]; +extern const u8 gText_082C3023[]; + +extern const u8 gText_082B6EA5[]; +extern const u8 gText_082B6EEC[]; +extern const u8 gText_082B6F16[]; +extern const u8 gText_082B6F4C[]; +extern const u8 gText_082B6F92[]; +extern const u8 gText_082B6FC9[]; +extern const u8 gText_082B700C[]; +extern const u8 gText_082B703A[]; +extern const u8 gText_082B706A[]; +extern const u8 gText_082B709C[]; +extern const u8 gText_082B70CC[]; +extern const u8 gText_082B710A[]; +extern const u8 gText_082B714D[]; +extern const u8 gText_082B7185[]; +extern const u8 gText_082B71C1[]; +extern const u8 gText_082B71F9[]; + +extern struct Unk030062ECStruct *gUnknown_030062EC; +extern struct Unk030062F0Struct *gUnknown_030062F0; +extern void (*gUnknown_030062F4)(void); + +extern void sub_8165AE8(struct Apprentice *); + +extern const u8 gUnknown_085DCEDC[]; +extern const u8 gUnknown_085DCF0E[]; +extern const u8 gUnknown_085DCEFA[]; +extern const u8 gUnknown_085DCF2C[]; + +// This file's functions. +static u16 sub_819FF98(u8 arg0); +static bool8 sub_81A0194(u8 arg0, u16 moveId); +static void CreateChooseAnswerTask(bool8 noBButton, u8 itemsCount, u8 windowId); +static u8 CreateAndShowWindow(u8 left, u8 top, u8 width, u8 height); +static void RemoveAndHideWindow(u8 windowId); +static void ExecuteFuncAfterButtonPress(void (*func)(void)); + +static void Script_IsPlayersApprenticeActive(void); +static void Script_SetPlayersApprenticeLvlMode(void); +static void sub_81A0978(void); +static void sub_819FC60(void); +static void sub_81A0984(void); +static void sub_81A0990(void); +static void sub_81A09D0(void); +static void Script_CreateApprenticeMenu(void); +static void Script_PrintMessage(void); +static void Script_ResetPlayerApprentice(void); +static void sub_81A1638(void); +static void sub_81A0CC0(void); +static void sub_81A09B4(void); +static void sub_81A0D40(void); +static void sub_81A0DD4(void); +static void sub_81A0FE4(void); +static void sub_81A0FFC(void); +static void sub_81A0D80(void); +static void sub_81A11F8(void); +static void sub_81A1218(void); +static void sub_81A1224(void); +static void sub_81A1438(void); +static void sub_81A150C(void); +static void sub_81A15A4(void); +static void sub_81A1644(void); +static void sub_81A1370(void); + +// rodata + +const struct ApprenticeTrainer gApprentices[] = +{ + { + .name = {_("サダヒロ"), _("ALANN"), _("ALAIN"), _("ADELFO"), _("CLAUS"), _("TEO")}, + .otId = 0xBDC9, + .facilityClass = 0x43, + .species = {SPECIES_BEAUTIFLY, SPECIES_DUSTOX, SPECIES_ILLUMISE, SPECIES_SHIFTRY, SPECIES_BRELOOM, SPECIES_NINJASK, SPECIES_SHEDINJA, SPECIES_PINSIR, SPECIES_HERACROSS, SPECIES_VOLBEAT}, + .rest = {0, 0, 0x1D, 8, 0x3e, 20, 0, 12, 1, 10, 0x30, 6, 0x44, 20}, + }, + { + .name = {_("ヒロオ"), _("LIONEL"), _("LIONEL"), _("CAIO"), _("LUDWIG"), _("LEO")}, + .otId = 0xCF09, + .facilityClass = 0x2B, + .species = {SPECIES_SWELLOW, SPECIES_SWALOT, SPECIES_SHUCKLE, SPECIES_MANECTRIC, SPECIES_TORKOAL, SPECIES_HARIYAMA, SPECIES_MIGHTYENA, SPECIES_LUDICOLO, SPECIES_CRAWDAUNT, SPECIES_WHISCASH}, + .rest = {1, 0, 0x38, 12, 1, 10, 0x30, 6, 6, 10, 0x20, 0x10, 0x13, 0x22}, + }, + { + .name = {_("ケイジ"), _("SONNY"), _("HERVE"), _("FEDRO"), _("WENZEL"), _("SANTI")}, + .otId = 0x2E34, + .facilityClass = 0x26, + .species = {SPECIES_LINOONE, SPECIES_MIGHTYENA, SPECIES_WHISCASH, SPECIES_ZANGOOSE, SPECIES_SEVIPER, SPECIES_NINETALES, SPECIES_KECLEON, SPECIES_SHUCKLE, SPECIES_MANECTRIC, SPECIES_MACHAMP}, + .rest = {2, 0, 1, 10, 10, 0x16, 0x15, 14, 0x30, 6, 0x3b, 12, 0x4, 12}, + }, + { + .name = {_("ユラ"), _("LAYLA"), _("LAYLA"), _("ASTRID"), _("SONJA"), _("LOLA")}, + .otId = 0x84EF, + .facilityClass = 0x47, + .species = {SPECIES_SWALOT, SPECIES_XATU, SPECIES_ALTARIA, SPECIES_GOLDUCK, SPECIES_FLYGON, SPECIES_ALAKAZAM, SPECIES_GARDEVOIR, SPECIES_WAILORD, SPECIES_GRUMPIG, SPECIES_MIGHTYENA}, + .rest = {3, 0, 11, 16, 15, 0x1e, 0x39, 16, 0x21, 0x14, 0x3, 12, 0xff, 0xff}, + }, + { + .name = {_("ヨウカ"), _("MACY"), _("AMELIE"), _("CLEO"), _("MARIA"), _("ELISA")}, + .otId = 0x1E43, + .facilityClass = 0x27, + .species = {SPECIES_WIGGLYTUFF, SPECIES_LINOONE, SPECIES_KINGDRA, SPECIES_DELCATTY, SPECIES_RAICHU, SPECIES_FEAROW, SPECIES_STARMIE, SPECIES_MEDICHAM, SPECIES_SHIFTRY, SPECIES_BEAUTIFLY}, + .rest = {4, 0, 15, 0x1e, 0x14, 16, 6, 16, 15, 0x28, 0x1c, 0x1c, 0x13, 0x1c}, + }, + { + .name = {_("ヤスシ"), _("DONTE"), _("BRAHIM"), _("GLAUCO"), _("JOSEF"), _("ROQUE")}, + .otId = 0x379F, + .facilityClass = 0x30, + .species = {SPECIES_STARMIE, SPECIES_DODRIO, SPECIES_AGGRON, SPECIES_MAGNETON, SPECIES_MACHAMP, SPECIES_ARMALDO, SPECIES_HERACROSS, SPECIES_NOSEPASS, SPECIES_EXPLOUD, SPECIES_MIGHTYENA}, + .rest = {5, 0, 0x29, 0x0A, 0x08, 0x14, 0x2F, 0x10, 0x38, 0x16, 0x20, 0x08, 0x00, 0x0C}, + }, + { + .name = {_("ミサオ"), _("AMIRA"), _("LAURE"), _("DAFNE"), _("AMELIE"), _("LARA")}, + .otId = 0xF555, + .facilityClass = 0x31, + .species = {SPECIES_STARMIE, SPECIES_DODRIO, SPECIES_MAGNETON, SPECIES_MEDICHAM, SPECIES_MIGHTYENA, SPECIES_GLALIE, SPECIES_GOLEM, SPECIES_ELECTRODE, SPECIES_PELIPPER, SPECIES_SHARPEDO}, + .rest = {6, 0, 0x0B, 0x0C, 0x3E, 0x12, 0x00, 0x0C, 0x31, 0x0A, 0x30, 0x14, 0x00, 0x0C}, + }, + { + .name = {_("カズサ"), _("KALI"), _("JODIE"), _("ILENIA"), _("KARO"), _("ELSA")}, + .otId = 0x8D26, + .facilityClass = 0x14, + .species = {SPECIES_NINETALES, SPECIES_ALAKAZAM, SPECIES_SCEPTILE, SPECIES_SALAMENCE, SPECIES_GOLDUCK, SPECIES_MAWILE, SPECIES_WEEZING, SPECIES_LANTURN, SPECIES_GARDEVOIR, SPECIES_MILOTIC}, + .rest = {7, 0, 0x06, 0x0A, 0x20, 0x06, 0x1F, 0x0A, 0x02, 0x0A, 0x03, 0x0C, 0xFF, 0xFF}, + }, + { + .name = {_("スミレ"), _("ANNIE"), _("ANNIE"), _("IMELDA"), _("INES"), _("ROSA")}, + .otId = 0x800C, + .facilityClass = 0xD, + .species = {SPECIES_SCEPTILE, SPECIES_VILEPLUME, SPECIES_BELLOSSOM, SPECIES_ROSELIA, SPECIES_CORSOLA, SPECIES_FLYGON, SPECIES_BRELOOM, SPECIES_MILOTIC, SPECIES_ALTARIA, SPECIES_CRADILY}, + .rest = {8, 0, 0x22, 0x1E, 0x33, 0x04, 0x0E, 0x02, 0x02, 0x0A, 0x1E, 0x10, 0x00, 0x0C}, + }, + { + .name = {_("アキノリ"), _("DILLEN"), _("RENE"), _("INDRO"), _("DETLEF"), _("PEDRO")}, + .otId = 0x469f, + .facilityClass = 0, + .species = {SPECIES_SKARMORY, SPECIES_GOLEM, SPECIES_BLAZIKEN, SPECIES_CAMERUPT, SPECIES_DONPHAN, SPECIES_MUK, SPECIES_SALAMENCE, SPECIES_TROPIUS, SPECIES_SOLROCK, SPECIES_RHYDON}, + .rest = {9, 0, 0x3D, 0x0A, 0x11, 0x10, 0x1E, 0x0E, 0x1C, 0x20, 0x04, 0x0C, 0xFF, 0xFF}, + }, + { + .name = {_("トウゾウ"), _("DALLAS"), _("BRUNO"), _("LEARCO"), _("ANSGAR"), _("MANOLO")}, + .otId = 0x71FC, + .facilityClass = 0x2D, + .species = {SPECIES_SEAKING, SPECIES_STARMIE, SPECIES_GOLDUCK, SPECIES_TENTACRUEL, SPECIES_OCTILLERY, SPECIES_GOREBYSS, SPECIES_GLALIE, SPECIES_WAILORD, SPECIES_SHARPEDO, SPECIES_KINGDRA}, + .rest = {10, 0, 0x05, 0x0A, 0x06, 0x06, 0x0E, 0x16, 0x14, 0x0A, 0x00, 0x0C, 0xFF, 0xFF}, + }, + { + .name = {_("セイヤ"), _("FRANK"), _("FRANK"), _("OLINDO"), _("FRANK"), _("MAURO")}, + .otId = 0xA39E, + .facilityClass = 0x3A, + .species = {SPECIES_QUAGSIRE, SPECIES_STARMIE, SPECIES_PELIPPER, SPECIES_CRAWDAUNT, SPECIES_WAILORD, SPECIES_GYARADOS, SPECIES_SWAMPERT, SPECIES_LANTURN, SPECIES_WHISCASH, SPECIES_SHUCKLE}, + .rest = {11, 0, 0x0E, 0x28, 0x3D, 0x10, 0x0F, 0x24, 0x14, 0x0A, 0x23, 0x1E, 0x24, 0x10}, + }, + { + .name = {_("リュウジ"), _("LAMONT"), _("XAV"), _("ORFEO"), _("JÜRGEN"), _("JORGE")}, + .otId = 0xE590, + .facilityClass = 0x19, + .species = {SPECIES_ABSOL, SPECIES_CROBAT, SPECIES_EXPLOUD, SPECIES_MAGNETON, SPECIES_SHARPEDO, SPECIES_MANECTRIC, SPECIES_METAGROSS, SPECIES_ELECTRODE, SPECIES_NOSEPASS, SPECIES_WEEZING}, + .rest = {12, 0, 0x20, 0x10, 0x2E, 0x06, 0x0B, 0x10, 0x22, 0x1E, 0x0F, 0x1E, 0x0B, 0x10}, + }, + { + .name = {_("カツアキ"), _("TYRESE"), _("ANDY"), _("PARIDE"), _("DAVID"), _("CHICHO")}, + .otId = 0xD018, + .facilityClass = 10, + .species = {SPECIES_BLAZIKEN, SPECIES_GOLEM, SPECIES_MACHAMP, SPECIES_RHYDON, SPECIES_HARIYAMA, SPECIES_AGGRON, SPECIES_MEDICHAM, SPECIES_ZANGOOSE, SPECIES_VIGOROTH, SPECIES_SLAKING}, + .rest = {13, 0, 0x29, 0x0A, 0x3A, 0x06, 0x15, 0x0E, 0x35, 0x14, 0x34, 0x10, 0x1E, 0x06}, + }, + { + .name = {_("トシミツ"), _("DANTE"), _("DANTE"), _("RAOUL"), _("LOTHAR"), _("PABLO")}, + .otId = 0xBC75, + .facilityClass = 14, + .species = {SPECIES_SCEPTILE, SPECIES_SANDSLASH, SPECIES_FLYGON, SPECIES_CLAYDOL, SPECIES_ARMALDO, SPECIES_CROBAT, SPECIES_CRADILY, SPECIES_SOLROCK, SPECIES_LUNATONE, SPECIES_GOLEM}, + .rest = {14, 0, 0x01, 0x0A, 0x17, 0x10, 0x43, 0x12, 0x22, 0x1E, 0x0B, 0x10, 0x0F, 0x28}, + }, + { + .name = {_("ローウェン"), _("ARTURO"), _("ARTURO"), _("ROMOLO"), _("BRIAN"), _("ARTURO")}, + .otId = 0xFA02, + .facilityClass = 0x20, + .species = {SPECIES_ABSOL, SPECIES_MIGHTYENA, SPECIES_ALAKAZAM, SPECIES_BANETTE, SPECIES_NINETALES, SPECIES_CLAYDOL, SPECIES_MUK, SPECIES_SALAMENCE, SPECIES_WALREIN, SPECIES_DUSCLOPS}, + .rest = {15, 0, 0x0F, 0x1E, 0x04, 0x14, 0x2F, 0x10, 0x06, 0x10, 0x20, 0x10, 0x03, 0x0E}, + }, +}; + +static const u8 *const gUnknown_08610EF0[][4] = +{ + {gText_082B7229, gText_082B731C, gText_082B735B, gText_082B7423}, + {gText_082B74C1, gText_082B756F, gText_082B75B2, gText_082B763F}, + {gText_082B76AC, gText_082B7772, gText_082B77CE, gText_082B7871}, + {gText_082B78D4, gText_082B7B1A, gText_082B7C13, gText_082B7D18}, + {gText_082B7DD4, gText_082B7EE5, gText_082B7F35, gText_082B7FE8}, + {gText_082B8087, gText_082B822B, gText_082B8286, gText_082B8356}, + {gText_082B83CE, gText_082B84FC, gText_082B8559, gText_082B8656}, + {gText_082B86EA, gText_082B87DA, gText_082B887C, gText_082B8957}, + {gText_082B89C6, gText_082B8ACF, gText_082B8B66, gText_082B8C20}, + {gText_082B8CAA, gText_082B8DD3, gText_082B8E24, gText_082B8ED5}, + {gText_082B8F45, gText_082B905F, gText_082B910E, gText_082B9204}, + {gText_082B929C, gText_082B9438, gText_082B9488, gText_082B9564}, + {gText_082B95D8, gText_082B9763, gText_082B97E5, gText_082B989A}, + {gText_082B992D, gText_082B9A84, gText_082B9AB9, gText_082B9B76}, + {gText_082B9BF2, gText_082B9D83, gText_082B9DF9, gText_082B9EAA}, + {gText_082B9F55, gText_082BA084, gText_082BA11D, gText_082BA1F3}, +}; + +static const u8 *const gUnknown_08610FF0[][2] = +{ + {gText_082BE50D, gText_082BE5F5}, + {gText_082BE679, gText_082BE71E}, + {gText_082BE762, gText_082BE7F8}, + {gText_082BE850, gText_082BE99C}, + {gText_082BEA1B, gText_082BEAE9}, + {gText_082BEB72, gText_082BEC8E}, + {gText_082BED16, gText_082BEE29}, + {gText_082BEEB4, gText_082BEFE2}, + {gText_082BF04E, gText_082BF11D}, + {gText_082BF1A8, gText_082BF268}, + {gText_082BF2D1, gText_082BF3CF}, + {gText_082BF46A, gText_082BF551}, + {gText_082BF5C3, gText_082BF6E5}, + {gText_082BF773, gText_082BF869}, + {gText_082BF8DD, gText_082BF9BA}, + {gText_082BFA5A, gText_082BFB4E}, +}; + +static const u8 *const gUnknown_08611070[][5] = +{ + {gText_082BA2A3, gText_082BA34E, gText_082BA380, gText_082BA3D2, gText_082BA448}, + {gText_082BA4D3, gText_082BA58C, gText_082BA5BF, gText_082BA5F3, gText_082BA635}, + {gText_082BA6E6, gText_082BA742, gText_082BA770, gText_082BA78F, gText_082BA7D8}, + {gText_082BA867, gText_082BA96B, gText_082BA9B7, gText_082BAA1B, gText_082BAA81}, + {gText_082BAB22, gText_082BAC43, gText_082BAC78, gText_082BAD17, gText_082BADB6}, + {gText_082BAE36, gText_082BAF4E, gText_082BAF8F, gText_082BAFDB, gText_082BB05F}, + {gText_082BB0D4, gText_082BB18C, gText_082BB1CE, gText_082BB242, gText_082BB2D9}, + {gText_082BB370, gText_082BB4C3, gText_082BB4FB, gText_082BB575, gText_082BB5E1}, + {gText_082BB656, gText_082BB6E5, gText_082BB72C, gText_082BB7A2, gText_082BB84A}, + {gText_082BB8CD, gText_082BB970, gText_082BB9AE, gText_082BBA05, gText_082BBA6C}, + {gText_082BBB01, gText_082BBC1C, gText_082BBC4B, gText_082BBCF6, gText_082BBD90}, + {gText_082BBE0B, gText_082BBEE5, gText_082BBF25, gText_082BBFA4, gText_082BC024}, + {gText_082BC0C8, gText_082BC213, gText_082BC247, gText_082BC2DD, gText_082BC373}, + {gText_082BC40E, gText_082BC514, gText_082BC555, gText_082BC5CE, gText_082BC666}, + {gText_082BC714, gText_082BC808, gText_082BC84D, gText_082BC8EA, gText_082BC984}, + {gText_082BCA4D, gText_082BCB75, gText_082BCBA6, gText_082BCBFC, gText_082BCCA4}, +}; + +static const u8 *const gUnknown_086111B0[][2] = +{ + {gText_082BFBF2, gText_082BFCAE}, + {gText_082BFD26, gText_082BFDB1}, + {gText_082BFE24, gText_082BFEAD}, + {gText_082BFF0A, gText_082C0032}, + {gText_082C0090, gText_082C016E}, + {gText_082C01F7, gText_082C034C}, + {gText_082C03CA, gText_082C046E}, + {gText_082C04F9, gText_082C0598}, + {gText_082C0602, gText_082C06D8}, + {gText_082C074A, gText_082C0809}, + {gText_082C086E, gText_082C0982}, + {gText_082C0A1D, gText_082C0AFD}, + {gText_082C0B6F, gText_082C0C7D}, + {gText_082C0D0B, gText_082C0DFE}, + {gText_082C0E71, gText_082C0F6D}, + {gText_082C1003, gText_082C1122}, +}; + +static const u8 *const gUnknown_08611230[][2] = +{ + {gText_082BCD68, gText_082BCE64}, + {gText_082BCEF2, gText_082BCF61}, + {gText_082BCFA1, gText_082BD03C}, + {gText_082BD06D, gText_082BD18A}, + {gText_082BD222, gText_082BD325}, + {gText_082BD3B1, gText_082BD493}, + {gText_082BD51C, gText_082BD609}, + {gText_082BD697, gText_082BD797}, + {gText_082BD806, gText_082BD8F5}, + {gText_082BD9BE, gText_082BDAE1}, + {gText_082BDB4E, gText_082BDC6B}, + {gText_082BDD0D, gText_082BDDEC}, + {gText_082BDE68, gText_082BDF4D}, + {gText_082BDFD8, gText_082BE0FD}, + {gText_082BE189, gText_082BE2A5}, + {gText_082BE33E, gText_082BE46C}, +}; + +static const u8 *const gUnknown_086112B0[][2] = +{ + {gText_082C11D1, gText_082C12D5}, + {gText_082C13AB, gText_082C1444}, + {gText_082C1501, gText_082C15B6}, + {gText_082C165E, gText_082C174F}, + {gText_082C1862, gText_082C19A0}, + {gText_082C1A76, gText_082C1C16}, + {gText_082C1CF5, gText_082C1DC1}, + {gText_082C1EDC, gText_082C1FEC}, + {gText_082C20D1, gText_082C21FF}, + {gText_082C231C, gText_082C2407}, + {gText_082C24B5, gText_082C25B1}, + {gText_082C2707, gText_082C27D4}, + {gText_082C28D6, gText_082C2A0B}, + {gText_082C2B50, gText_082C2C77}, + {gText_082C2D67, gText_082C2E41}, + {gText_082C2EF5, gText_082C3023}, +}; + +static const u8 *const gUnknown_08611330[] = +{ + gText_082B6EA5, + gText_082B6EEC, + gText_082B6F16, + gText_082B6F4C, + gText_082B6F92, + gText_082B6FC9, + gText_082B700C, + gText_082B703A, + gText_082B706A, + gText_082B709C, + gText_082B70CC, + gText_082B710A, + gText_082B714D, + gText_082B7185, + gText_082B71C1, + gText_082B71F9, +}; + +static const bool8 gUnknown_08611370[MOVES_COUNT] = +{ + [MOVE_NONE] = FALSE, + [MOVE_POUND] = FALSE, + [MOVE_KARATE_CHOP] = TRUE, + [MOVE_DOUBLE_SLAP] = TRUE, + [MOVE_COMET_PUNCH] = FALSE, + [MOVE_MEGA_PUNCH] = TRUE, + [MOVE_PAY_DAY] = FALSE, + [MOVE_FIRE_PUNCH] = TRUE, + [MOVE_ICE_PUNCH] = TRUE, + [MOVE_THUNDER_PUNCH] = TRUE, + [MOVE_SCRATCH] = FALSE, + [MOVE_VICE_GRIP] = FALSE, + [MOVE_GUILLOTINE] = TRUE, + [MOVE_RAZOR_WIND] = FALSE, + [MOVE_SWORDS_DANCE] = TRUE, + [MOVE_CUT] = FALSE, + [MOVE_GUST] = FALSE, + [MOVE_WING_ATTACK] = FALSE, + [MOVE_WHIRLWIND] = TRUE, + [MOVE_FLY] = TRUE, + [MOVE_BIND] = TRUE, + [MOVE_SLAM] = TRUE, + [MOVE_VINE_WHIP] = FALSE, + [MOVE_STOMP] = TRUE, + [MOVE_DOUBLE_KICK] = TRUE, + [MOVE_MEGA_KICK] = TRUE, + [MOVE_JUMP_KICK] = TRUE, + [MOVE_ROLLING_KICK] = TRUE, + [MOVE_SAND_ATTACK] = TRUE, + [MOVE_HEADBUTT] = TRUE, + [MOVE_HORN_ATTACK] = FALSE, + [MOVE_FURY_ATTACK] = FALSE, + [MOVE_HORN_DRILL] = TRUE, + [MOVE_TACKLE] = FALSE, + [MOVE_BODY_SLAM] = TRUE, + [MOVE_WRAP] = TRUE, + [MOVE_TAKE_DOWN] = TRUE, + [MOVE_THRASH] = TRUE, + [MOVE_DOUBLE_EDGE] = TRUE, + [MOVE_TAIL_WHIP] = FALSE, + [MOVE_POISON_STING] = FALSE, + [MOVE_TWINEEDLE] = TRUE, + [MOVE_PIN_MISSILE] = FALSE, + [MOVE_LEER] = FALSE, + [MOVE_BITE] = TRUE, + [MOVE_GROWL] = FALSE, + [MOVE_ROAR] = TRUE, + [MOVE_SING] = TRUE, + [MOVE_SUPERSONIC] = TRUE, + [MOVE_SONIC_BOOM] = TRUE, + [MOVE_DISABLE] = TRUE, + [MOVE_ACID] = FALSE, + [MOVE_EMBER] = FALSE, + [MOVE_FLAMETHROWER] = TRUE, + [MOVE_MIST] = TRUE, + [MOVE_WATER_GUN] = FALSE, + [MOVE_HYDRO_PUMP] = TRUE, + [MOVE_SURF] = TRUE, + [MOVE_ICE_BEAM] = TRUE, + [MOVE_BLIZZARD] = TRUE, + [MOVE_PSYBEAM] = TRUE, + [MOVE_BUBBLE_BEAM] = FALSE, + [MOVE_AURORA_BEAM] = FALSE, + [MOVE_HYPER_BEAM] = TRUE, + [MOVE_PECK] = FALSE, + [MOVE_DRILL_PECK] = TRUE, + [MOVE_SUBMISSION] = TRUE, + [MOVE_LOW_KICK] = TRUE, + [MOVE_COUNTER] = TRUE, + [MOVE_SEISMIC_TOSS] = TRUE, + [MOVE_STRENGTH] = TRUE, + [MOVE_ABSORB] = FALSE, + [MOVE_MEGA_DRAIN] = FALSE, + [MOVE_LEECH_SEED] = TRUE, + [MOVE_GROWTH] = TRUE, + [MOVE_RAZOR_LEAF] = TRUE, + [MOVE_SOLAR_BEAM] = TRUE, + [MOVE_POISON_POWDER] = TRUE, + [MOVE_STUN_SPORE] = TRUE, + [MOVE_SLEEP_POWDER] = TRUE, + [MOVE_PETAL_DANCE] = TRUE, + [MOVE_STRING_SHOT] = FALSE, + [MOVE_DRAGON_RAGE] = TRUE, + [MOVE_FIRE_SPIN] = TRUE, + [MOVE_THUNDER_SHOCK] = FALSE, + [MOVE_THUNDERBOLT] = TRUE, + [MOVE_THUNDER_WAVE] = TRUE, + [MOVE_THUNDER] = TRUE, + [MOVE_ROCK_THROW] = FALSE, + [MOVE_EARTHQUAKE] = TRUE, + [MOVE_FISSURE] = TRUE, + [MOVE_DIG] = TRUE, + [MOVE_TOXIC] = TRUE, + [MOVE_CONFUSION] = FALSE, + [MOVE_PSYCHIC] = TRUE, + [MOVE_HYPNOSIS] = TRUE, + [MOVE_MEDITATE] = TRUE, + [MOVE_AGILITY] = TRUE, + [MOVE_QUICK_ATTACK] = TRUE, + [MOVE_RAGE] = FALSE, + [MOVE_TELEPORT] = FALSE, + [MOVE_NIGHT_SHADE] = TRUE, + [MOVE_MIMIC] = TRUE, + [MOVE_SCREECH] = TRUE, + [MOVE_DOUBLE_TEAM] = TRUE, + [MOVE_RECOVER] = TRUE, + [MOVE_HARDEN] = TRUE, + [MOVE_MINIMIZE] = TRUE, + [MOVE_SMOKESCREEN] = TRUE, + [MOVE_CONFUSE_RAY] = TRUE, + [MOVE_WITHDRAW] = TRUE, + [MOVE_DEFENSE_CURL] = TRUE, + [MOVE_BARRIER] = TRUE, + [MOVE_LIGHT_SCREEN] = TRUE, + [MOVE_HAZE] = TRUE, + [MOVE_REFLECT] = TRUE, + [MOVE_FOCUS_ENERGY] = TRUE, + [MOVE_BIDE] = FALSE, + [MOVE_METRONOME] = TRUE, + [MOVE_MIRROR_MOVE] = TRUE, + [MOVE_SELF_DESTRUCT] = TRUE, + [MOVE_EGG_BOMB] = TRUE, + [MOVE_LICK] = TRUE, + [MOVE_SMOG] = FALSE, + [MOVE_SLUDGE] = FALSE, + [MOVE_BONE_CLUB] = FALSE, + [MOVE_FIRE_BLAST] = TRUE, + [MOVE_WATERFALL] = TRUE, + [MOVE_CLAMP] = TRUE, + [MOVE_SWIFT] = TRUE, + [MOVE_SKULL_BASH] = TRUE, + [MOVE_SPIKE_CANNON] = FALSE, + [MOVE_CONSTRICT] = FALSE, + [MOVE_AMNESIA] = TRUE, + [MOVE_KINESIS] = TRUE, + [MOVE_SOFT_BOILED] = TRUE, + [MOVE_HI_JUMP_KICK] = TRUE, + [MOVE_GLARE] = TRUE, + [MOVE_DREAM_EATER] = TRUE, + [MOVE_POISON_GAS] = FALSE, + [MOVE_BARRAGE] = FALSE, + [MOVE_LEECH_LIFE] = FALSE, + [MOVE_LOVELY_KISS] = TRUE, + [MOVE_SKY_ATTACK] = TRUE, + [MOVE_TRANSFORM] = TRUE, + [MOVE_BUBBLE] = FALSE, + [MOVE_DIZZY_PUNCH] = TRUE, + [MOVE_SPORE] = TRUE, + [MOVE_FLASH] = TRUE, + [MOVE_PSYWAVE] = TRUE, + [MOVE_SPLASH] = FALSE, + [MOVE_ACID_ARMOR] = TRUE, + [MOVE_CRABHAMMER] = TRUE, + [MOVE_EXPLOSION] = TRUE, + [MOVE_FURY_SWIPES] = FALSE, + [MOVE_BONEMERANG] = TRUE, + [MOVE_REST] = TRUE, + [MOVE_ROCK_SLIDE] = TRUE, + [MOVE_HYPER_FANG] = TRUE, + [MOVE_SHARPEN] = TRUE, + [MOVE_CONVERSION] = TRUE, + [MOVE_TRI_ATTACK] = TRUE, + [MOVE_SUPER_FANG] = TRUE, + [MOVE_SLASH] = TRUE, + [MOVE_SUBSTITUTE] = TRUE, + [MOVE_STRUGGLE] = TRUE, + [MOVE_SKETCH] = TRUE, + [MOVE_TRIPLE_KICK] = TRUE, + [MOVE_THIEF] = TRUE, + [MOVE_SPIDER_WEB] = TRUE, + [MOVE_MIND_READER] = TRUE, + [MOVE_NIGHTMARE] = TRUE, + [MOVE_FLAME_WHEEL] = FALSE, + [MOVE_SNORE] = TRUE, + [MOVE_CURSE] = TRUE, + [MOVE_FLAIL] = TRUE, + [MOVE_CONVERSION_2] = TRUE, + [MOVE_AEROBLAST] = TRUE, + [MOVE_COTTON_SPORE] = TRUE, + [MOVE_REVERSAL] = TRUE, + [MOVE_SPITE] = TRUE, + [MOVE_POWDER_SNOW] = FALSE, + [MOVE_PROTECT] = TRUE, + [MOVE_MACH_PUNCH] = TRUE, + [MOVE_SCARY_FACE] = TRUE, + [MOVE_FAINT_ATTACK] = TRUE, + [MOVE_SWEET_KISS] = TRUE, + [MOVE_BELLY_DRUM] = TRUE, + [MOVE_SLUDGE_BOMB] = TRUE, + [MOVE_MUD_SLAP] = TRUE, + [MOVE_OCTAZOOKA] = TRUE, + [MOVE_SPIKES] = TRUE, + [MOVE_ZAP_CANNON] = TRUE, + [MOVE_FORESIGHT] = TRUE, + [MOVE_DESTINY_BOND] = TRUE, + [MOVE_PERISH_SONG] = TRUE, + [MOVE_ICY_WIND] = TRUE, + [MOVE_DETECT] = TRUE, + [MOVE_BONE_RUSH] = FALSE, + [MOVE_LOCK_ON] = TRUE, + [MOVE_OUTRAGE] = TRUE, + [MOVE_SANDSTORM] = TRUE, + [MOVE_GIGA_DRAIN] = TRUE, + [MOVE_ENDURE] = TRUE, + [MOVE_CHARM] = TRUE, + [MOVE_ROLLOUT] = TRUE, + [MOVE_FALSE_SWIPE] = TRUE, + [MOVE_SWAGGER] = TRUE, + [MOVE_MILK_DRINK] = TRUE, + [MOVE_SPARK] = FALSE, + [MOVE_FURY_CUTTER] = TRUE, + [MOVE_STEEL_WING] = TRUE, + [MOVE_MEAN_LOOK] = TRUE, + [MOVE_ATTRACT] = TRUE, + [MOVE_SLEEP_TALK] = TRUE, + [MOVE_HEAL_BELL] = TRUE, + [MOVE_RETURN] = TRUE, + [MOVE_PRESENT] = TRUE, + [MOVE_FRUSTRATION] = TRUE, + [MOVE_SAFEGUARD] = TRUE, + [MOVE_PAIN_SPLIT] = TRUE, + [MOVE_SACRED_FIRE] = TRUE, + [MOVE_MAGNITUDE] = FALSE, + [MOVE_DYNAMIC_PUNCH] = TRUE, + [MOVE_MEGAHORN] = TRUE, + [MOVE_DRAGON_BREATH] = TRUE, + [MOVE_BATON_PASS] = TRUE, + [MOVE_ENCORE] = TRUE, + [MOVE_PURSUIT] = TRUE, + [MOVE_RAPID_SPIN] = TRUE, + [MOVE_SWEET_SCENT] = TRUE, + [MOVE_IRON_TAIL] = TRUE, + [MOVE_METAL_CLAW] = TRUE, + [MOVE_VITAL_THROW] = TRUE, + [MOVE_MORNING_SUN] = TRUE, + [MOVE_SYNTHESIS] = TRUE, + [MOVE_MOONLIGHT] = TRUE, + [MOVE_HIDDEN_POWER] = TRUE, + [MOVE_CROSS_CHOP] = TRUE, + [MOVE_TWISTER] = FALSE, + [MOVE_RAIN_DANCE] = TRUE, + [MOVE_SUNNY_DAY] = TRUE, + [MOVE_CRUNCH] = TRUE, + [MOVE_MIRROR_COAT] = TRUE, + [MOVE_PSYCH_UP] = TRUE, + [MOVE_EXTREME_SPEED] = TRUE, + [MOVE_ANCIENT_POWER] = TRUE, + [MOVE_SHADOW_BALL] = TRUE, + [MOVE_FUTURE_SIGHT] = TRUE, + [MOVE_ROCK_SMASH] = TRUE, + [MOVE_WHIRLPOOL] = TRUE, + [MOVE_BEAT_UP] = TRUE, + [MOVE_FAKE_OUT] = TRUE, + [MOVE_UPROAR] = TRUE, + [MOVE_STOCKPILE] = TRUE, + [MOVE_SPIT_UP] = TRUE, + [MOVE_SWALLOW] = TRUE, + [MOVE_HEAT_WAVE] = TRUE, + [MOVE_HAIL] = TRUE, + [MOVE_TORMENT] = TRUE, + [MOVE_FLATTER] = TRUE, + [MOVE_WILL_O_WISP] = TRUE, + [MOVE_MEMENTO] = TRUE, + [MOVE_FACADE] = TRUE, + [MOVE_FOCUS_PUNCH] = TRUE, + [MOVE_SMELLING_SALT] = TRUE, + [MOVE_FOLLOW_ME] = TRUE, + [MOVE_NATURE_POWER] = TRUE, + [MOVE_CHARGE] = TRUE, + [MOVE_TAUNT] = TRUE, + [MOVE_HELPING_HAND] = TRUE, + [MOVE_TRICK] = TRUE, + [MOVE_ROLE_PLAY] = TRUE, + [MOVE_WISH] = TRUE, + [MOVE_ASSIST] = TRUE, + [MOVE_INGRAIN] = TRUE, + [MOVE_SUPERPOWER] = TRUE, + [MOVE_MAGIC_COAT] = TRUE, + [MOVE_RECYCLE] = TRUE, + [MOVE_REVENGE] = TRUE, + [MOVE_BRICK_BREAK] = TRUE, + [MOVE_YAWN] = TRUE, + [MOVE_KNOCK_OFF] = TRUE, + [MOVE_ENDEAVOR] = TRUE, + [MOVE_ERUPTION] = TRUE, + [MOVE_SKILL_SWAP] = TRUE, + [MOVE_IMPRISON] = TRUE, + [MOVE_REFRESH] = TRUE, + [MOVE_GRUDGE] = TRUE, + [MOVE_SNATCH] = TRUE, + [MOVE_SECRET_POWER] = TRUE, + [MOVE_DIVE] = TRUE, + [MOVE_ARM_THRUST] = FALSE, + [MOVE_CAMOUFLAGE] = TRUE, + [MOVE_TAIL_GLOW] = TRUE, + [MOVE_LUSTER_PURGE] = TRUE, + [MOVE_MIST_BALL] = TRUE, + [MOVE_FEATHER_DANCE] = TRUE, + [MOVE_TEETER_DANCE] = TRUE, + [MOVE_BLAZE_KICK] = TRUE, + [MOVE_MUD_SPORT] = TRUE, + [MOVE_ICE_BALL] = FALSE, + [MOVE_NEEDLE_ARM] = TRUE, + [MOVE_SLACK_OFF] = TRUE, + [MOVE_HYPER_VOICE] = TRUE, + [MOVE_POISON_FANG] = FALSE, + [MOVE_CRUSH_CLAW] = TRUE, + [MOVE_BLAST_BURN] = TRUE, + [MOVE_HYDRO_CANNON] = TRUE, + [MOVE_METEOR_MASH] = TRUE, + [MOVE_ASTONISH] = TRUE, + [MOVE_WEATHER_BALL] = TRUE, + [MOVE_AROMATHERAPY] = TRUE, + [MOVE_FAKE_TEARS] = TRUE, + [MOVE_AIR_CUTTER] = TRUE, + [MOVE_OVERHEAT] = TRUE, + [MOVE_ODOR_SLEUTH] = TRUE, + [MOVE_ROCK_TOMB] = TRUE, + [MOVE_SILVER_WIND] = TRUE, + [MOVE_METAL_SOUND] = TRUE, + [MOVE_GRASS_WHISTLE] = TRUE, + [MOVE_TICKLE] = TRUE, + [MOVE_COSMIC_POWER] = TRUE, + [MOVE_WATER_SPOUT] = TRUE, + [MOVE_SIGNAL_BEAM] = TRUE, + [MOVE_SHADOW_PUNCH] = TRUE, + [MOVE_EXTRASENSORY] = TRUE, + [MOVE_SKY_UPPERCUT] = TRUE, + [MOVE_SAND_TOMB] = TRUE, + [MOVE_SHEER_COLD] = TRUE, + [MOVE_MUDDY_WATER] = TRUE, + [MOVE_BULLET_SEED] = FALSE, + [MOVE_AERIAL_ACE] = TRUE, + [MOVE_ICICLE_SPEAR] = FALSE, + [MOVE_IRON_DEFENSE] = TRUE, + [MOVE_BLOCK] = TRUE, + [MOVE_HOWL] = TRUE, + [MOVE_DRAGON_CLAW] = TRUE, + [MOVE_FRENZY_PLANT] = TRUE, + [MOVE_BULK_UP] = TRUE, + [MOVE_BOUNCE] = TRUE, + [MOVE_MUD_SHOT] = FALSE, + [MOVE_POISON_TAIL] = TRUE, + [MOVE_COVET] = TRUE, + [MOVE_VOLT_TACKLE] = TRUE, + [MOVE_MAGICAL_LEAF] = TRUE, + [MOVE_WATER_SPORT] = TRUE, + [MOVE_CALM_MIND] = TRUE, + [MOVE_LEAF_BLADE] = TRUE, + [MOVE_DRAGON_DANCE] = TRUE, + [MOVE_ROCK_BLAST] = FALSE, + [MOVE_SHOCK_WAVE] = TRUE, + [MOVE_WATER_PULSE] = TRUE, + [MOVE_DOOM_DESIRE] = TRUE, + [MOVE_PSYCHO_BOOST] = TRUE, +}; + +static const u8 gUnknown_086114D3[] = {0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00}; + +static void (* const sApprenticeFunctions[])(void) = +{ + Script_IsPlayersApprenticeActive, + Script_SetPlayersApprenticeLvlMode, + sub_81A0978, + sub_819FC60, + sub_81A0984, + sub_81A0990, + sub_81A09D0, + Script_CreateApprenticeMenu, + Script_PrintMessage, + Script_ResetPlayerApprentice, + sub_81A1638, + sub_81A0CC0, + sub_81A09B4, + sub_81A0D40, + sub_81A0DD4, + sub_81A0FE4, + sub_81A0FFC, + sub_81A0D80, + sub_81A11F8, + sub_81A1218, + sub_81A1224, + sub_81A1438, + sub_81A150C, + sub_81A15A4, + sub_81A1644, + sub_81A1370, +}; + +static const u8 gUnknown_08611548[8] = {0x00, 0x01, 0x02, 0x03, 0x06, 0x07, 0x08, 0x09}; + +// text +extern const u8 gText_Give[]; +extern const u8 gText_NoNeed[]; +extern const u8 gText_Yes[]; +extern const u8 gText_No[]; + +void CopyFriendsApprenticeChallengeText(u8 saveblockApprenticeId) +{ + u8 i, var; + const u8 *str; + + var = gSaveBlock2Ptr->apprentices[saveblockApprenticeId].number; + for (i = 0; var != 0 && i < 4; var /= 10, i++) + ; + + StringCopy7(gStringVar1, gSaveBlock2Ptr->apprentices[saveblockApprenticeId].playerName); + ConvertInternationalString(gStringVar1, gSaveBlock2Ptr->apprentices[saveblockApprenticeId].language); + ConvertIntToDecimalStringN(gStringVar2, gSaveBlock2Ptr->apprentices[saveblockApprenticeId].number, STR_CONV_MODE_RIGHT_ALIGN, i); + str = gUnknown_08611330[gSaveBlock2Ptr->apprentices[saveblockApprenticeId].id]; + StringExpandPlaceholders(gStringVar4, str); +} + +void Apprentice_EnableBothScriptContexts(void) +{ + EnableBothScriptContexts(); +} + +void ResetApprenticeStruct(struct Apprentice *apprentice) +{ + u8 i; + + for (i = 0; i < 6; i++) + apprentice->easyChatWords[i] |= 0xFFFF; + + apprentice->playerName[0] = EOS; + apprentice->id = 16; +} + +void ResetAllApprenticeData(void) +{ + u8 i, j; + + PLAYER_APPRENTICE.field_B2_1 = 0; + for (i = 0; i < 4; i++) + { + for (j = 0; j < 6; j++) + gSaveBlock2Ptr->apprentices[i].easyChatWords[j] |= 0xFFFF; + gSaveBlock2Ptr->apprentices[i].id = 16; + gSaveBlock2Ptr->apprentices[i].playerName[0] = EOS; + gSaveBlock2Ptr->apprentices[i].lvlMode = 0; + gSaveBlock2Ptr->apprentices[i].number = 0; + gSaveBlock2Ptr->apprentices[i].field_1 = 0; + for (j = 0; j < 4; j++) + gSaveBlock2Ptr->apprentices[i].playerId[j] = 0; + gSaveBlock2Ptr->apprentices[i].language = gGameLanguage; + gSaveBlock2Ptr->apprentices[i].unk40 = 0; + } + + Script_ResetPlayerApprentice(); +} + +static bool8 IsPlayersApprenticeActive(void) +{ + return (PLAYER_APPRENTICE.activeLvlMode != 0); +} + +static void sub_819FBC8(void) +{ + if (gSaveBlock2Ptr->apprentices[0].number == 0) + { + do + { + PLAYER_APPRENTICE.id = gUnknown_08611548[Random() % ARRAY_COUNT(gUnknown_08611548)]; + } while (PLAYER_APPRENTICE.id == gSaveBlock2Ptr->apprentices[0].id); + } + else + { + do + { + PLAYER_APPRENTICE.id = Random() % 16; + } while (PLAYER_APPRENTICE.id == gSaveBlock2Ptr->apprentices[0].id); + } +} + +static void SetPlayersApprenticeLvlMode(u8 mode) +{ + PLAYER_APPRENTICE.activeLvlMode = mode; +} + +static void sub_819FC60(void) +{ + u8 array[APPRENTICE_SPECIES_COUNT]; + u8 i; + + for (i = 0; i < ARRAY_COUNT(array); i++) + array[i] = i; + + for (i = 0; i < 50; i++) + { + u8 temp; + u8 var1 = Random() % ARRAY_COUNT(array); + u8 var2 = Random() % ARRAY_COUNT(array); + SWAP(array[var1], array[var2], temp); + } + + for (i = 0; i < 3; i++) + PLAYER_APPRENTICE.monIds[i] = ((array[i * 2] & 0xF) << 4) | ((array[i * 2 + 1]) & 0xF); +} + +static u8 sub_819FCF8(u8 val, u8 *arg1, u8 *arg2) +{ + u8 i, count; + u8 ret = 0; + + if (val == 2) + { + do + { + ret = Random() % 3; + for (count = 0, i = 0; i < 5; i++) + { + if (gUnknown_030062EC->unk2[ret][i] != 0) + count++; + } + } while (count > 3); + } + else if (val == 1) + { + ret = arg1[*arg2]; + (*arg2)++; + } + + return ret; +} + +static void sub_819FD64(void) +{ + u8 sp_0[10]; + u8 sp_C[3]; + u8 sp_10; + u8 i, j; + u8 rand1, rand2; + u8 id; + + for (i = 0; i < 3; i++) + sp_C[i] = i; + for (i = 0; i < 10; i++) + { + u8 temp; + rand1 = Random() % ARRAY_COUNT(sp_C); + rand2 = Random() % ARRAY_COUNT(sp_C); + SWAP(sp_C[rand1], sp_C[rand2], temp); + } + + for (i = 0; i < 10; i++) + sp_0[i] = gUnknown_086114D3[i]; + for (i = 0; i < 50; i++) + { + u8 temp; + rand1 = Random() % ARRAY_COUNT(sp_0); + rand2 = Random() % ARRAY_COUNT(sp_0); + SWAP(sp_0[rand1], sp_0[rand2], temp); + } + + gUnknown_030062EC = AllocZeroed(sizeof(*gUnknown_030062EC)); + gUnknown_030062EC->unk0 = 0; + for (i = 0; i < 5; i++) + { + for (j = 0; j < 3; j++) + gUnknown_030062EC->unk20[j][i] = 4; + } + + sp_10 = 0; + for (i = 0; i < 9; i++) + { + PLAYER_APPRENTICE.field_B8[i].unk0_0 = sp_0[i]; + if (sp_0[i] != 3) + { + PLAYER_APPRENTICE.field_B8[i].unk0_1 = sub_819FCF8(sp_0[i], sp_C, &sp_10); + id = PLAYER_APPRENTICE.field_B8[i].unk0_1; + if (sp_0[i] == 2) + { + do + { + rand1 = Random() % 4; + for (j = 0; j < gUnknown_030062EC->unk0 + 1; j++) + { + if (gUnknown_030062EC->unk20[id][j] == rand1) + break; + } + } while (j != gUnknown_030062EC->unk0 + 1); + + gUnknown_030062EC->unk20[id][gUnknown_030062EC->unk0] = rand1; + PLAYER_APPRENTICE.field_B8[i].unk0_2 = rand1; + PLAYER_APPRENTICE.field_B8[i].unk2 = sub_819FF98(PLAYER_APPRENTICE.field_B8[i].unk0_1); + } + } + } + + FREE_AND_SET_NULL(gUnknown_030062EC); +} + +// No idea why a do-while loop is needed, but it will not match without it. + +#define APPRENTICE_SPECIES_ID(speciesArrId, monId) speciesArrId = (PLAYER_APPRENTICE.monIds[monId] >> \ + (((PLAYER_APPRENTICE.field_B2_0 >> monId) & 1) << 2)) & 0xF; \ + do {} while (0) + +// Why the need to have two macros do the exact thing differently? +#define APPRENTICE_SPECIES_ID_2(speciesArrId, monId) { u8 a0 = ((PLAYER_APPRENTICE.field_B2_0 >> monId) & 1);\ + speciesArrId = PLAYER_APPRENTICE.monIds[monId]; \ + speciesArrId = ((speciesArrId) >> (a0 << 2)) & 0xF; \ + } + +static u16 sub_819FF98(u8 arg0) +{ + u8 i, j; + u8 id; + u8 knownMovesCount; + u16 species; + const u16 *learnset; + bool32 var_24 = FALSE; + u16 moveId = 0; + bool32 valid; + u8 level; + + if (arg0 < 3) + { + APPRENTICE_SPECIES_ID(id, arg0); + } + else + { + id = 0; + } + + species = gApprentices[PLAYER_APPRENTICE.id].species[id]; + learnset = gLevelUpLearnsets[species]; + j = 0; + if (PLAYER_APPRENTICE.activeLvlMode == 1) + level = 50; + else + level = 60; + + for (j = 0; learnset[j] != 0xFFFF; j++) + { + if ((learnset[j] & 0xFE00) > (level << 9)) + break; + } + + knownMovesCount = j; + i = 0; + while (i < 5) + { + if (Random() % 2 == 0 || var_24 == TRUE) + { + do + { + do + { + id = Random() % (NUM_TECHNICAL_MACHINES + NUM_HIDDEN_MACHINES); + valid = CanSpeciesLearnTMHM(species, id); + } + while (!valid); + + moveId = ItemIdToBattleMoveId(ITEM_TM01 + id); + valid = TRUE; + + if (knownMovesCount < 5) + j = 0; + else + j = knownMovesCount - 4; + + for (; j < knownMovesCount; j++) + { + if ((learnset[j] & 0x1FF) == moveId) + { + valid = FALSE; + break; + } + } + } while (valid != TRUE); + } + else + { + if (knownMovesCount < 5) + { + var_24 = TRUE; + continue; + } + else + { + do + { + u8 learnsetId = Random() % (knownMovesCount - 4); + moveId = learnset[learnsetId] & 0x1FF; + valid = TRUE; + for (j = knownMovesCount - 4; j < knownMovesCount; j++) + { + if ((learnset[j] & 0x1FF) == moveId) + { + valid = FALSE; + break; + } + } + } while (valid != TRUE); + } + } + + if (sub_81A0194(arg0, moveId)) + { + if (gUnknown_08611370[moveId]) + break; + i++; + } + } + + gUnknown_030062EC->unk0++; + return moveId; +} + +static bool8 sub_81A0194(u8 arg0, u16 moveId) +{ + u8 i; + + for (i = 0; i < 5; i++) + { + if (gUnknown_030062EC->unk2[arg0][i] == moveId) + return FALSE; + } + + gUnknown_030062EC->unk2[arg0][gUnknown_030062EC->unk0] = moveId; + return TRUE; +} + +static void GetLatestLearnedMoves(u16 species, u16 *moves) +{ + u8 i, j; + u8 level, knownMovesCount; + const u16 *learnset; + + if (PLAYER_APPRENTICE.activeLvlMode == 1) + level = 50; + else + level = 60; + + learnset = gLevelUpLearnsets[species]; + for (i = 0; learnset[i] != 0xFFFF; i++) + { + if ((learnset[i] & 0xFE00) > (level << 9)) + break; + } + + knownMovesCount = i; + if (knownMovesCount > 4) + knownMovesCount = 4; + + for (j = 0; j < knownMovesCount; j++) + moves[j] = learnset[(i - 1) - j] & 0x1FF; +} + +static u16 sub_81A0284(u8 arg0, u8 speciesTableId, u8 arg2) +{ + u16 moves[4]; + u8 i, count; + + if (PLAYER_APPRENTICE.field_B1_1 < 3) + return 0; + + count = 0; + for (i = 0; i < 9; i++) + { + if (PLAYER_APPRENTICE.field_B8[i].unk0_0 == 0) + break; + count++; + } + + GetLatestLearnedMoves(gApprentices[PLAYER_APPRENTICE.id].species[speciesTableId], moves); + for (i = 0; i < count && i < PLAYER_APPRENTICE.field_B1_1 - 3; i++) + { + if (PLAYER_APPRENTICE.field_B8[i].unk0_0 == 2 + && PLAYER_APPRENTICE.field_B8[i].unk0_1 == arg0 + && PLAYER_APPRENTICE.field_B8[i].unk0_3 != 0) + { + moves[PLAYER_APPRENTICE.field_B8[i].unk0_2] = PLAYER_APPRENTICE.field_B8[i].unk2; + } + } + + return moves[arg2]; +} + +static void sub_81A0390(u8 arg0) +{ + struct ApprenticeMon *apprenticeMons[3]; + u8 i, j; + u32 speciesTableId; + + for (i = 0; i < 3; i++) + { + gSaveBlock2Ptr->apprentices[0].monData[i].species = 0; + gSaveBlock2Ptr->apprentices[0].monData[i].item = 0; + for (j = 0; j < 4; j++) + gSaveBlock2Ptr->apprentices[0].monData[i].moves[j] = 0; + } + + j = PLAYER_APPRENTICE.field_B1_2; + for (i = 0; i < 3; i++) + { + apprenticeMons[j] = &gSaveBlock2Ptr->apprentices[0].monData[i]; + j = (j + 1) % 3; + } + + for (i = 0; i < 3; i++) + { + APPRENTICE_SPECIES_ID(speciesTableId, i); + apprenticeMons[i]->species = gApprentices[PLAYER_APPRENTICE.id].species[speciesTableId]; + GetLatestLearnedMoves(apprenticeMons[i]->species, apprenticeMons[i]->moves); + } + + for (i = 0; i < arg0; i++) + { + u8 var1 = PLAYER_APPRENTICE.field_B8[i].unk0_0; + u8 monId = PLAYER_APPRENTICE.field_B8[i].unk0_1; + if (var1 == 1) + { + if (PLAYER_APPRENTICE.field_B8[i].unk0_3 != 0) + apprenticeMons[monId]->item = PLAYER_APPRENTICE.field_B8[i].unk2; + } + else if (var1 == 2) + { + if (PLAYER_APPRENTICE.field_B8[i].unk0_3 != 0) + { + u32 moveSlot = PLAYER_APPRENTICE.field_B8[i].unk0_2; + apprenticeMons[monId]->moves[moveSlot] = PLAYER_APPRENTICE.field_B8[i].unk2; + } + } + } +} + +static void CreateMenuWithAnswers(u8 arg0) +{ + u8 i; + u8 windowId; + const u8 *strings[3]; + u8 count = 2; + u8 width; + u8 left; + u8 top; + s32 pixelWidth; + + switch (arg0) + { + case APPRENTICE_ASK_WHICH_LEVEL: + left = 0x12; + top = 8; + strings[0] = gText_Lv50; + strings[1] = gText_OpenLevel; + break; + case APPRENTICE_ASK_3SPECIES: + count = 3; + left = 0x12; + top = 6; + for (i = 0; i < 3; i++) + { + u16 species; + u32 speciesTableId; + + APPRENTICE_SPECIES_ID(speciesTableId, i); + species = gApprentices[PLAYER_APPRENTICE.id].species[speciesTableId]; + strings[i] = gSpeciesNames[species]; + } + break; + case APPRENTICE_ASK_2SPECIES: + left = 0x12; + top = 8; + if (PLAYER_APPRENTICE.field_B1_1 > 2) + return; + strings[1] = gSpeciesNames[gUnknown_030062F0->unk2]; + strings[0] = gSpeciesNames[gUnknown_030062F0->unk0]; + break; + case APPRENTICE_ASK_MOVES: + left = 0x11; + top = 8; + strings[0] = gMoveNames[gUnknown_030062F0->unk4]; + strings[1] = gMoveNames[gUnknown_030062F0->unk6]; + break; + case APPRENTICE_ASK_GIVE: + left = 0x12; + top = 8; + strings[0] = gText_Give; + strings[1] = gText_NoNeed; + break; + case APPRENTICE_ASK_YES_NO: + left = 0x14; + top = 8; + strings[0] = gText_Yes; + strings[1] = gText_No; + break; + default: + left = 0; + top = 0; + break; + } + + pixelWidth = 0; + for (i = 0; i < count; i++) + { + s32 width = GetStringWidth(1, strings[i], 0); + if (width > pixelWidth) + pixelWidth = width; + } + + width = convert_pixel_width_to_tile_width(pixelWidth); + left = sub_80E2D5C(left, width); + windowId = CreateAndShowWindow(left, top, width, count * 2); + SetStandardWindowBorderStyle(windowId, 0); + + for (i = 0; i < count; i++) + AddTextPrinterParameterized(windowId, 1, strings[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL); + + InitMenuInUpperLeftCornerPlaySoundWhenAPressed(windowId, count, 0); + CreateChooseAnswerTask(TRUE, count, windowId); +} + +#define tNoBButton data[4] +#define tWrapAround data[5] +#define tWindowId data[6] + +static void Task_ChooseAnswer(u8 taskId) +{ + s8 input; + s16 *data = gTasks[taskId].data; + + if (!tWrapAround) + input = Menu_ProcessInputNoWrapAround(); + else + input = ProcessMenuInput(); + + switch (input) + { + case MENU_NOTHING_CHOSEN: + return; + case MENU_B_PRESSED: + if (tNoBButton) + return; + + PlaySE(SE_SELECT); + gSpecialVar_Result = 0x7F; + break; + default: + gSpecialVar_Result = input; + break; + } + + RemoveAndHideWindow(tWindowId); + DestroyTask(taskId); + EnableBothScriptContexts(); +} + +static u8 CreateAndShowWindow(u8 left, u8 top, u8 width, u8 height) +{ + u8 windowId; + struct WindowTemplate winTemplate = CreateWindowTemplate(0, left + 1, top + 1, width, height, 15, 100); + + windowId = AddWindow(&winTemplate); + PutWindowTilemap(windowId); + CopyWindowToVram(windowId, 3); + return windowId; +} + +static void RemoveAndHideWindow(u8 windowId) +{ + sub_8198070(windowId, TRUE); + RemoveWindow(windowId); +} + +static void CreateChooseAnswerTask(bool8 noBButton, u8 itemsCount, u8 windowId) +{ + u8 taskId = CreateTask(Task_ChooseAnswer, 80); + gTasks[taskId].tNoBButton = noBButton; + + if (itemsCount > 3) + gTasks[taskId].tWrapAround = TRUE; + else + gTasks[taskId].tWrapAround = FALSE; + + gTasks[taskId].tWindowId = windowId; +} + +#undef tNoBButton +#undef tWrapAround +#undef tWindowId + +void CallApprenticeFunction(void) +{ + sApprenticeFunctions[gSpecialVar_0x8004](); +} + +static void Script_ResetPlayerApprentice(void) +{ + u8 i; + + sub_819FBC8(); + PLAYER_APPRENTICE.activeLvlMode = 0; + PLAYER_APPRENTICE.field_B1_1 = 0; + PLAYER_APPRENTICE.field_B1_2 = 0; + PLAYER_APPRENTICE.field_B2_0 = 0; + + for (i = 0; i < 3; i++) + PLAYER_APPRENTICE.monIds[i] = 0; + + for (i = 0; i < 9; i++) + { + PLAYER_APPRENTICE.field_B8[i].unk0_0 = 0; + PLAYER_APPRENTICE.field_B8[i].unk0_1 = 0; + PLAYER_APPRENTICE.field_B8[i].unk0_2 = 0; + PLAYER_APPRENTICE.field_B8[i].unk0_3 = 0; + PLAYER_APPRENTICE.field_B8[i].unk2 = 0; + } +} + +static void Script_IsPlayersApprenticeActive(void) +{ + if (!IsPlayersApprenticeActive()) + gSpecialVar_Result = FALSE; + else + gSpecialVar_Result = TRUE; +} + +static void Script_SetPlayersApprenticeLvlMode(void) +{ + SetPlayersApprenticeLvlMode(gSpecialVar_0x8005); +} + +static void sub_81A0978(void) +{ + sub_819FBC8(); +} + +static void sub_81A0984(void) +{ + sub_819FD64(); +} + +static void sub_81A0990(void) +{ + PLAYER_APPRENTICE.field_B1_1++; +} + +static void sub_81A09B4(void) +{ + gSpecialVar_Result = PLAYER_APPRENTICE.field_B1_1; +} + +static void sub_81A09D0(void) +{ + s32 var = PLAYER_APPRENTICE.field_B1_1 - 3; + if (var < 0) + { + gSpecialVar_Result = FALSE; + } + else + { + if (var > 8) + gSpecialVar_Result = TRUE; + + if (!PLAYER_APPRENTICE.field_B8[var].unk0_0) + gSpecialVar_Result = TRUE; + else + gSpecialVar_Result = FALSE; + } +} + +static void Script_CreateApprenticeMenu(void) +{ + CreateMenuWithAnswers(gSpecialVar_0x8005); +} + +static void Task_WaitForPrintingMessage(u8 taskId) +{ + if (!RunTextPrintersAndIsPrinter0Active()) + { + DestroyTask(taskId); + if (gSpecialVar_0x8005) + ExecuteFuncAfterButtonPress(EnableBothScriptContexts); + else + EnableBothScriptContexts(); + } +} + +static void PrintMessage(void) +{ + const u8 *string; + + if (gSpecialVar_0x8006 == 6) + { + string = gUnknown_08610FF0[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 7) + { + string = gUnknown_08610FF0[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 8) + { + string = gUnknown_086111B0[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 9) + { + string = gUnknown_086111B0[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 4) + { + string = gUnknown_08611230[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 5) + { + string = gUnknown_08611230[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 10) + { + string = gUnknown_08611070[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 11) + { + string = gUnknown_086112B0[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 12) + { + string = gUnknown_08611070[PLAYER_APPRENTICE.id][3]; + } + else if (gSpecialVar_0x8006 == 13) + { + string = gUnknown_08611070[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 16) + { + string = gUnknown_08611070[PLAYER_APPRENTICE.id][4]; + } + else if (gSpecialVar_0x8006 == 14) + { + string = gUnknown_08611070[PLAYER_APPRENTICE.id][2]; + } + else if (gSpecialVar_0x8006 == 15) + { + string = gUnknown_086112B0[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 0) + { + string = gUnknown_08610EF0[PLAYER_APPRENTICE.id][0]; + } + else if (gSpecialVar_0x8006 == 1) + { + string = gUnknown_08610EF0[PLAYER_APPRENTICE.id][1]; + } + else if (gSpecialVar_0x8006 == 2) + { + string = gUnknown_08610EF0[PLAYER_APPRENTICE.id][2]; + } + else if (gSpecialVar_0x8006 == 3) + { + string = gUnknown_08610EF0[PLAYER_APPRENTICE.id][3]; + } + else + { + EnableBothScriptContexts(); + return; + } + + StringExpandPlaceholders(gStringVar4, string); + AddTextPrinterForMessage(TRUE); + CreateTask(Task_WaitForPrintingMessage, 1); +} + +static void Script_PrintMessage(void) +{ + ScriptContext2_Enable(); + FreezeEventObjects(); + sub_808B864(); + sub_808BCF4(); + NewMenuHelpers_DrawDialogueFrame(0, 1); + PrintMessage(); +} + +static void sub_81A0CC0(void) +{ + if (PLAYER_APPRENTICE.field_B1_1 < 3) + { + gSpecialVar_Result = 2; + } + else if (PLAYER_APPRENTICE.field_B1_1 > 11) + { + gSpecialVar_Result = 5; + } + else + { + s32 id = PLAYER_APPRENTICE.field_B1_1 - 3; + switch (PLAYER_APPRENTICE.field_B8[id].unk0_0) + { + case 1: + gSpecialVar_Result = 4; + break; + case 2: + gSpecialVar_Result = 3; + break; + case 3: + gSpecialVar_Result = 1; + break; + default: + gSpecialVar_Result = 5; + break; + } + } +} + +static void sub_81A0D40(void) +{ + if (gSpecialVar_0x8005) + { + u8 bitNo = gSpecialVar_0x8006; + PLAYER_APPRENTICE.field_B2_0 |= 1 << bitNo; + } +} + +static void sub_81A0D80(void) +{ + if (PLAYER_APPRENTICE.field_B1_1 >= 3) + { + u8 id = PLAYER_APPRENTICE.field_B1_1 - 3; + if (gSpecialVar_0x8005) + PLAYER_APPRENTICE.field_B8[id].unk0_3 = 1; + else + PLAYER_APPRENTICE.field_B8[id].unk0_3 = 0; + } +} + +static void sub_81A0DD4(void) +{ + u8 i; + u8 count = 0; + u8 id1, id2; + + for (i = 0; i < 9 && PLAYER_APPRENTICE.field_B8[i].unk0_0; count++, i++) + ; + + gUnknown_030062F0 = AllocZeroed(sizeof(*gUnknown_030062F0)); + if (gSpecialVar_0x8005 == 2) + { + if (PLAYER_APPRENTICE.field_B1_1 < 3) + { + id1 = PLAYER_APPRENTICE.monIds[PLAYER_APPRENTICE.field_B1_1] >> 4; + gUnknown_030062F0->unk2 = gApprentices[PLAYER_APPRENTICE.id].species[id1]; + + id2 = PLAYER_APPRENTICE.monIds[PLAYER_APPRENTICE.field_B1_1] & 0xF; + gUnknown_030062F0->unk0 = gApprentices[PLAYER_APPRENTICE.id].species[id2]; + } + } + else if (gSpecialVar_0x8005 == 3) + { + if (PLAYER_APPRENTICE.field_B1_1 >= 3 + && PLAYER_APPRENTICE.field_B1_1 < count + 3 + && PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_0 == 2) + { + count = PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_1; + APPRENTICE_SPECIES_ID_2(id1, count); + gUnknown_030062F0->unk0 = gApprentices[PLAYER_APPRENTICE.id].species[id1]; + gUnknown_030062F0->unk4 = sub_81A0284(count, id1, PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_2); + gUnknown_030062F0->unk6 = PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk2; + } + } + else if (gSpecialVar_0x8005 == 4) + { + if (PLAYER_APPRENTICE.field_B1_1 >= 3 + && PLAYER_APPRENTICE.field_B1_1 < count + 3 + && PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_0 == 1) + { + count = PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_1; + APPRENTICE_SPECIES_ID_2(id2, count); + gUnknown_030062F0->unk0 = gApprentices[PLAYER_APPRENTICE.id].species[id2]; + } + } +} + +static void sub_81A0FE4(void) +{ + FREE_AND_SET_NULL(gUnknown_030062F0); +} + +static void sub_81A0FFC(void) +{ + u8 *stringDst; + u8 text[16]; + u32 speciesArrayId; + + switch (gSpecialVar_0x8005) + { + case 0: + stringDst = gStringVar1; + break; + case 1: + stringDst = gStringVar2; + break; + case 2: + stringDst = gStringVar3; + break; + default: + return; + } + + switch (gSpecialVar_0x8006) + { + case APPRENTICE_BUFF_SPECIES1: + StringCopy(stringDst, gSpeciesNames[gUnknown_030062F0->unk0]); + break; + case APPRENTICE_BUFF_SPECIES2: + StringCopy(stringDst, gSpeciesNames[gUnknown_030062F0->unk2]); + break; + case APPRENTICE_BUFF_SPECIES3: + StringCopy(stringDst, gSpeciesNames[gUnknown_030062F0->unk0]); + break; + case APPRENTICE_BUFF_MOVE1: + StringCopy(stringDst, gMoveNames[gUnknown_030062F0->unk4]); + break; + case APPRENTICE_BUFF_MOVE2: + StringCopy(stringDst, gMoveNames[gUnknown_030062F0->unk6]); + break; + case APPRENTICE_BUFF_ITEM: + StringCopy(stringDst, ItemId_GetName(PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk2)); + break; + case APPRENTICE_BUFF_NAME: + TVShowConvertInternationalString(text, GetApprenticeNameInLanguage(PLAYER_APPRENTICE.id, LANGUAGE_ENGLISH), LANGUAGE_ENGLISH); + StringCopy(stringDst, text); + break; + case APPRENTICE_BUFF_LEVEL: + if (PLAYER_APPRENTICE.activeLvlMode == 1) + StringCopy(stringDst, gText_Lv50); + else + StringCopy(stringDst, gText_OpenLevel); + break; + case APPRENTICE_BUFF_EASY_CHAT: + ConvertBattleFrontierTrainerSpeechToString(gSaveBlock2Ptr->apprentices[0].easyChatWords); + StringCopy(stringDst, gStringVar4); + break; + case APPRENTICE_BUFF_SPECIES4: + if (PLAYER_APPRENTICE.field_B1_2 < 3) + { + APPRENTICE_SPECIES_ID(speciesArrayId, PLAYER_APPRENTICE.field_B1_2); + } + else + { + speciesArrayId = 0; + } + StringCopy(stringDst, gSpeciesNames[gApprentices[PLAYER_APPRENTICE.id].species[speciesArrayId]]); + break; + } +} + +static void sub_81A11F8(void) +{ + PLAYER_APPRENTICE.field_B1_2 = gSpecialVar_0x8005; +} + +static void sub_81A1218(void) +{ + sub_81AAC28(); +} + +#ifdef NONMATCHING +static void sub_81A1224(void) +{ + u8 count; + u8 i, j; + + if (PLAYER_APPRENTICE.field_B1_1 < 3) + return; + + count = 0; + for (j = 0; j < 9 && PLAYER_APPRENTICE.field_B8[j].unk0_0; count++, j++) + ; + + for (i = 0; i < count && i < PLAYER_APPRENTICE.field_B1_1 - 3; i++) + { + if (PLAYER_APPRENTICE.field_B8[i].unk0_0 == 1 + && PLAYER_APPRENTICE.field_B8[i].unk0_3 + && PLAYER_APPRENTICE.field_B8[i].unk2 == gSpecialVar_0x8005) + { + PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_3 = 0; + PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk2 = gSpecialVar_0x8005; + gSpecialVar_Result = i; + return; + } + } + + PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk0_3 = 1; + PLAYER_APPRENTICE.field_B8[PLAYER_APPRENTICE.field_B1_1 - 3].unk2 = gSpecialVar_0x8005; + gSpecialVar_Result = 1; +} +#else +NAKED +static void sub_81A1224(void) +{ + asm_unified("\n\ + push {r4-r7,lr}\n\ + mov r7, r9\n\ + mov r6, r8\n\ + push {r6,r7}\n\ + ldr r1, =gSaveBlock2Ptr\n\ + ldr r3, [r1]\n\ + adds r0, r3, 0\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + adds r7, r1, 0\n\ + cmp r0, 0x2\n\ + bhi _081A1242\n\ + b _081A1362\n\ +_081A1242:\n\ + movs r5, 0\n\ + movs r2, 0\n\ + adds r0, r3, 0\n\ + adds r0, 0xB8\n\ + ldrb r0, [r0]\n\ + lsls r0, 30\n\ + ldr r1, =gSpecialVar_0x8005\n\ + mov r12, r1\n\ + ldr r1, =gSpecialVar_Result\n\ + mov r8, r1\n\ + cmp r0, 0\n\ + beq _081A127C\n\ + adds r3, r7, 0\n\ +_081A125C:\n\ + adds r0, r5, 0x1\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + adds r0, r2, 0x1\n\ + lsls r0, 24\n\ + lsrs r2, r0, 24\n\ + cmp r2, 0x8\n\ + bhi _081A127C\n\ + ldr r0, [r3]\n\ + lsls r1, r2, 2\n\ + adds r0, r1\n\ + adds r0, 0xB8\n\ + ldrb r0, [r0]\n\ + lsls r0, 30\n\ + cmp r0, 0\n\ + bne _081A125C\n\ +_081A127C:\n\ + movs r4, 0\n\ + cmp r4, r5\n\ + bcs _081A1322\n\ + ldr r0, [r7]\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + cmp r4, r0\n\ + bge _081A1322\n\ + adds r6, r7, 0\n\ + mov r9, r4\n\ +_081A1296:\n\ + ldr r3, [r6]\n\ + lsls r0, r4, 2\n\ + adds r2, r3, r0\n\ + adds r0, r2, 0\n\ + adds r0, 0xB8\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 30\n\ + lsrs r0, 30\n\ + cmp r0, 0x1\n\ + bne _081A1308\n\ + lsrs r0, r1, 6\n\ + cmp r0, 0\n\ + beq _081A1308\n\ + adds r0, r2, 0\n\ + adds r0, 0xBA\n\ + ldrh r0, [r0]\n\ + mov r2, r12\n\ + ldrh r2, [r2]\n\ + cmp r0, r2\n\ + bne _081A1308\n\ + adds r0, r3, 0\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + lsls r0, 2\n\ + adds r0, r3, r0\n\ + adds r0, 0xB8\n\ + ldrb r2, [r0]\n\ + movs r1, 0x3F\n\ + ands r1, r2\n\ + strb r1, [r0]\n\ + ldr r1, [r6]\n\ + adds r0, r1, 0\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + lsls r0, 2\n\ + adds r1, r0\n\ + mov r2, r12\n\ + ldrh r0, [r2]\n\ + adds r1, 0xBA\n\ + strh r0, [r1]\n\ + mov r1, r9\n\ + mov r0, r8\n\ + strh r1, [r0]\n\ + b _081A1362\n\ + .pool\n\ +_081A1308:\n\ + adds r0, r4, 0x1\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + cmp r4, r5\n\ + bcs _081A1322\n\ + ldr r0, [r6]\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + cmp r4, r0\n\ + blt _081A1296\n\ +_081A1322:\n\ + ldr r2, [r7]\n\ + adds r0, r2, 0\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + lsls r0, 2\n\ + adds r2, r0\n\ + adds r2, 0xB8\n\ + ldrb r1, [r2]\n\ + movs r0, 0x3F\n\ + ands r0, r1\n\ + movs r1, 0x40\n\ + orrs r0, r1\n\ + strb r0, [r2]\n\ + ldr r1, [r7]\n\ + adds r0, r1, 0\n\ + adds r0, 0xB1\n\ + ldrb r0, [r0]\n\ + lsls r0, 26\n\ + lsrs r0, 28\n\ + subs r0, 0x3\n\ + lsls r0, 2\n\ + adds r1, r0\n\ + mov r2, r12\n\ + ldrh r0, [r2]\n\ + adds r1, 0xBA\n\ + strh r0, [r1]\n\ + movs r0, 0x1\n\ + mov r1, r8\n\ + strh r0, [r1]\n\ +_081A1362:\n\ + pop {r3,r4}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ +"); +} +#endif // NONMATCHING + +static void sub_81A1370(void) +{ + s32 i; + s32 r10; + s32 r9; + + if (gSaveBlock2Ptr->apprentices[0].playerName[0] == EOS) + return; + + for (i = 0; i < 3; i++) + { + if (gSaveBlock2Ptr->apprentices[i + 1].playerName[0] == EOS) + { + gSaveBlock2Ptr->apprentices[i + 1] = gSaveBlock2Ptr->apprentices[0]; + return; + } + } + + r10 = 0xFFFF; + r9 = -1; + for (i = 1; i < 4; i++) + { + if (ReadUnalignedWord(gSaveBlock2Ptr->apprentices[i].playerId) == ReadUnalignedWord(gSaveBlock2Ptr->playerTrainerId) + && gSaveBlock2Ptr->apprentices[i].number < r10) + { + r10 = gSaveBlock2Ptr->apprentices[i].number; + r9 = i; + } + } + + if (r9 > 0) + gSaveBlock2Ptr->apprentices[r9] = gSaveBlock2Ptr->apprentices[0]; +} + +static void sub_81A1438(void) +{ + u8 i; + + gSaveBlock2Ptr->apprentices[0].id = PLAYER_APPRENTICE.id; + gSaveBlock2Ptr->apprentices[0].lvlMode = PLAYER_APPRENTICE.activeLvlMode; + + for (i = 0; i < 9 && PLAYER_APPRENTICE.field_B8[i].unk0_0; i++) + ; + + gSaveBlock2Ptr->apprentices[0].field_1 = i; + if (gSaveBlock2Ptr->apprentices[0].number < 255) + gSaveBlock2Ptr->apprentices[0].number++; + + sub_81A0390(gSaveBlock2Ptr->apprentices[0].field_1); + for (i = 0; i < 4; i++) + gSaveBlock2Ptr->apprentices[0].playerId[i] = gSaveBlock2Ptr->playerTrainerId[i]; + + StringCopy(gSaveBlock2Ptr->apprentices[0].playerName, gSaveBlock2Ptr->playerName); + gSaveBlock2Ptr->apprentices[0].language = gGameLanguage; + sub_8165AE8(&gSaveBlock2Ptr->apprentices[0]); +} + +static void sub_81A150C(void) +{ + u8 i; + u8 mapObjectGfxId; + u8 class = gApprentices[gSaveBlock2Ptr->apprentices[0].id].facilityClass; + + for (i = 0; i < 30 && gUnknown_085DCEDC[i] != class; i++) + ; + + if (i != 30) + { + mapObjectGfxId = gUnknown_085DCF0E[i]; + VarSet(VAR_OBJ_GFX_ID_0, mapObjectGfxId); + } + else + { + for (i = 0; i < 20 && gUnknown_085DCEFA[i] != class; i++) + ; + + if (i != 20) + { + mapObjectGfxId = gUnknown_085DCF2C[i]; + VarSet(VAR_OBJ_GFX_ID_0, mapObjectGfxId); + } + } +} + +static void sub_81A15A4(void) +{ + u8 i; + u8 mapObjectGfxId; + u8 class = gApprentices[PLAYER_APPRENTICE.id].facilityClass; + + for (i = 0; i < 30 && gUnknown_085DCEDC[i] != class; i++) + ; + + if (i != 30) + { + mapObjectGfxId = gUnknown_085DCF0E[i]; + VarSet(VAR_OBJ_GFX_ID_0, mapObjectGfxId); + } + else + { + for (i = 0; i < 20 && gUnknown_085DCEFA[i] != class; i++) + ; + + if (i != 20) + { + mapObjectGfxId = gUnknown_085DCF2C[i]; + VarSet(VAR_OBJ_GFX_ID_0, mapObjectGfxId); + } + } +} + +static void sub_81A1638(void) +{ + gSpecialVar_0x8004 = 1; +} + +static void sub_81A1644(void) +{ + gSpecialVar_0x8004 = 1; +} + +const u8 *GetApprenticeNameInLanguage(u32 apprenticeId, s32 language) +{ + const struct ApprenticeTrainer *apprentice = &gApprentices[apprenticeId]; + + switch (language) + { + case LANGUAGE_JAPANESE: + return apprentice->name[0]; + case LANGUAGE_ENGLISH: + return apprentice->name[1]; + case LANGUAGE_FRENCH: + return apprentice->name[2]; + case LANGUAGE_ITALIAN: + return apprentice->name[3]; + case LANGUAGE_GERMAN: + return apprentice->name[4]; + case LANGUAGE_SPANISH: + default: + return apprentice->name[5]; + } +} + +static void sub_81A16B4(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + SwitchTaskToFollowupFunc(taskId); +} + +static void Task_ExecuteFuncAfterButtonPress(u8 taskId) +{ + if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + { + gUnknown_030062F4 = (void*)(u32)(((u16)gTasks[taskId].data[0] | (gTasks[taskId].data[1] << 0x10))); + gUnknown_030062F4(); + DestroyTask(taskId); + } +} + +static void ExecuteFuncAfterButtonPress(void (*func)(void)) +{ + u8 taskId = CreateTask(Task_ExecuteFuncAfterButtonPress, 1); + gTasks[taskId].data[0] = (u32)(func); + gTasks[taskId].data[1] = (u32)(func) >> 16; +} + +static void sub_81A175C(TaskFunc taskFunc) +{ + u8 taskId = CreateTask(sub_81A16B4, 1); + SetTaskFuncWithFollowupFunc(taskId, sub_81A16B4, taskFunc); +} diff --git a/src/battle_ai_script_commands.c b/src/battle_ai_script_commands.c index 1201a855a..e89d308f5 100644 --- a/src/battle_ai_script_commands.c +++ b/src/battle_ai_script_commands.c @@ -2191,7 +2191,7 @@ static void BattleAICmd_if_level_cond(void) static void BattleAICmd_if_target_taunted(void) { - if (gDisableStructs[gBattlerTarget].tauntTimer1 != 0) + if (gDisableStructs[gBattlerTarget].tauntTimer != 0) gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); else gAIScriptPtr += 5; @@ -2199,7 +2199,7 @@ static void BattleAICmd_if_target_taunted(void) static void BattleAICmd_if_target_not_taunted(void) { - if (gDisableStructs[gBattlerTarget].tauntTimer1 == 0) + if (gDisableStructs[gBattlerTarget].tauntTimer == 0) gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); else gAIScriptPtr += 5; diff --git a/src/battle_ai_switch_items.c b/src/battle_ai_switch_items.c index a105e7edf..40fffd6e5 100644 --- a/src/battle_ai_switch_items.c +++ b/src/battle_ai_switch_items.c @@ -17,7 +17,7 @@ static bool8 ShouldUseItem(void); static bool8 ShouldSwitchIfPerishSong(void) { if (gStatuses3[gActiveBattler] & STATUS3_PERISH_SONG - && gDisableStructs[gActiveBattler].perishSongTimer1 == 0) + && gDisableStructs[gActiveBattler].perishSongTimer == 0) { *(gBattleStruct->AI_monToSwitchIntoId + gActiveBattler) = PARTY_SIZE; BtlController_EmitTwoReturnValues(1, B_ACTION_SWITCH, 0); diff --git a/src/battle_anim.c b/src/battle_anim.c index 2d514c955..0a5395b02 100644 --- a/src/battle_anim.c +++ b/src/battle_anim.c @@ -16,9 +16,6 @@ #include "palette.h" #include "main.h" -// sprites start at 10000 and thus must be subtracted of 10000 to account for the true index. -#define GET_TRUE_SPRITE_INDEX(i) ((i - 10000)) - #define ANIM_SPRITE_INDEX_COUNT 8 extern u16 gBattle_WIN0H; @@ -33,8 +30,8 @@ extern struct MusicPlayerInfo gMPlayInfo_BGM; extern struct MusicPlayerInfo gMPlayInfo_SE1; extern struct MusicPlayerInfo gMPlayInfo_SE2; -extern const u16 gUnknown_082C8D64[]; -extern const u8 * const gBattleAnims_Moves[]; +extern const u16 gMovesWithQuietBGM[]; +extern const u8 *const gBattleAnims_Moves[]; extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; extern const struct BattleAnimBackground gBattleAnimBackgroundTable[]; @@ -110,7 +107,7 @@ EWRAM_DATA bool8 gAnimScriptActive = FALSE; EWRAM_DATA u8 gAnimVisualTaskCount = 0; EWRAM_DATA u8 gAnimSoundTaskCount = 0; EWRAM_DATA struct DisableStruct *gAnimDisableStructPtr = NULL; -EWRAM_DATA u32 gAnimMoveDmg = 0; +EWRAM_DATA s32 gAnimMoveDmg = 0; EWRAM_DATA u16 gAnimMovePower = 0; EWRAM_DATA static u16 sAnimSpriteIndexArray[ANIM_SPRITE_INDEX_COUNT] = {0}; EWRAM_DATA u8 gAnimFriendship = 0; @@ -237,7 +234,7 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo else { for (i = 0; i < 4; i++) - gAnimBattlerSpecies[i] = gContestResources->field_18->field_0; + gAnimBattlerSpecies[i] = gContestResources->field_18->unk0; } if (!isMoveAnim) @@ -260,9 +257,9 @@ void LaunchBattleAnimation(const u8 *const animsTable[], u16 tableId, bool8 isMo if (isMoveAnim) { - for (i = 0; gUnknown_082C8D64[i] != 0xFFFF; i++) + for (i = 0; gMovesWithQuietBGM[i] != 0xFFFF; i++) { - if (tableId == gUnknown_082C8D64[i]) + if (tableId == gMovesWithQuietBGM[i]) { m4aMPlayVolumeControl(&gMPlayInfo_BGM, 0xFFFF, 128); break; @@ -684,7 +681,7 @@ void sub_80A438C(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible) } sub_80A6B30(&unknownStruct); - CpuFill16(0, unknownStruct.unk0, 0x1000); + CpuFill16(0, unknownStruct.bgTiles, 0x1000); CpuFill16(0xFF, unknownStruct.unk4, 0x800); SetAnimBgAttribute(1, BG_ANIM_PRIORITY, 2); @@ -694,7 +691,7 @@ void sub_80A438C(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible) battlerSpriteId = gBattlerSpriteIds[battlerId]; gBattle_BG1_X = -(gSprites[battlerSpriteId].pos1.x + gSprites[battlerSpriteId].pos2.x) + 0x20; - if (IsContest() && IsSpeciesNotUnown(gContestResources->field_18->field_0)) + if (IsContest() && IsSpeciesNotUnown(gContestResources->field_18->unk0)) gBattle_BG1_X--; gBattle_BG1_Y = -(gSprites[battlerSpriteId].pos1.y + gSprites[battlerSpriteId].pos2.y) + 0x20; @@ -712,7 +709,7 @@ void sub_80A438C(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible) else battlerPosition = GetBattlerPosition(battlerId); - sub_8118FBC(1, 0, 0, battlerPosition, unknownStruct.unk8, unknownStruct.unk0, unknownStruct.unk4, unknownStruct.unkA); + sub_8118FBC(1, 0, 0, battlerPosition, unknownStruct.unk8, unknownStruct.bgTiles, unknownStruct.unk4, unknownStruct.tilesOffset); if (IsContest()) sub_80A46A0(); @@ -722,7 +719,7 @@ void sub_80A438C(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible) RequestDma3Fill(0, (void*)(VRAM + 0x6000), 0x2000, 1); RequestDma3Fill(0, (void*)(VRAM + 0xF000), 0x1000, 1); sub_80A6B90(&unknownStruct, 2); - CpuFill16(0, unknownStruct.unk0 + 0x1000, 0x1000); + CpuFill16(0, unknownStruct.bgTiles + 0x1000, 0x1000); CpuFill16(0, unknownStruct.unk4 + 0x400, 0x800); SetAnimBgAttribute(2, BG_ANIM_PRIORITY, 2); SetAnimBgAttribute(2, BG_ANIM_SCREEN_SIZE, 1); @@ -742,7 +739,7 @@ void sub_80A438C(u8 battlerId, bool8 toBG_2, bool8 setSpriteInvisible) LoadPalette(&gPlttBufferUnfaded[0x100 + battlerId * 16], 0x90, 0x20); CpuCopy32(&gPlttBufferUnfaded[0x100 + battlerId * 16], (void*)(BG_PLTT + 0x120), 0x20); - sub_8118FBC(2, 0, 0, GetBattlerPosition(battlerId), unknownStruct.unk8, unknownStruct.unk0 + 0x1000, unknownStruct.unk4 + 0x400, unknownStruct.unkA); + sub_8118FBC(2, 0, 0, GetBattlerPosition(battlerId), unknownStruct.unk8, unknownStruct.bgTiles + 0x1000, unknownStruct.unk4 + 0x400, unknownStruct.tilesOffset); } } @@ -752,7 +749,7 @@ static void sub_80A46A0(void) struct UnknownAnimStruct2 unknownStruct; u16 *ptr; - if (IsSpeciesNotUnown(gContestResources->field_18->field_0)) + if (IsSpeciesNotUnown(gContestResources->field_18->unk0)) { sub_80A6B30(&unknownStruct); ptr = unknownStruct.unk4; diff --git a/src/battle_anim_80A5C6C.c b/src/battle_anim_80A5C6C.c new file mode 100644 index 000000000..ebe1718b7 --- /dev/null +++ b/src/battle_anim_80A5C6C.c @@ -0,0 +1,2459 @@ +#include "global.h" +#include "constants/battle_anim.h" +#include "constants/species.h" +#include "battle.h" +#include "battle_anim.h" +#include "contest.h" +#include "data2.h" +#include "decompress.h" +#include "palette.h" +#include "pokemon_icon.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "util.h" +#include "gpu_regs.h" +#include "bg.h" +#include "malloc.h" +#include "dma3.h" + +#define GET_UNOWN_LETTER(personality) (( \ + (((personality & 0x03000000) >> 24) << 6) \ + | (((personality & 0x00030000) >> 16) << 4) \ + | (((personality & 0x00000300) >> 8) << 2) \ + | (((personality & 0x00000003) >> 0) << 0) \ +) % 28) + +#define IS_DOUBLE_BATTLE() ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) + +extern const struct OamData gUnknown_0852497C; +extern const struct MonCoords gMonFrontPicCoords[]; +extern const struct MonCoords gMonBackPicCoords[]; +extern const u8 gEnemyMonElevation[]; +extern const struct CompressedSpriteSheet gMonFrontPicTable[]; +extern const union AffineAnimCmd *gUnknown_082FF6C0[]; + +// This file's functions. +void sub_80A64EC(struct Sprite *sprite); +void sub_80A653C(struct Sprite *sprite); +void InitAnimLinearTranslation(struct Sprite *sprite); +void sub_80A6FB4(struct Sprite *sprite); +void sub_80A6F98(struct Sprite *sprite); +void sub_80A7144(struct Sprite *sprite); +void sub_80A791C(struct Sprite *sprite); +void sub_80A8DFC(struct Sprite *sprite); +void sub_80A8E88(struct Sprite *sprite); +void sub_80A7E6C(u8 spriteId); +u16 sub_80A7F18(u8 spriteId); +void AnimTask_BlendMonInAndOutSetup(struct Task *task); +void sub_80A7AFC(u8 taskId); +void sub_80A8CAC(u8 taskId); +void AnimTask_BlendMonInAndOutStep(u8 taskId); +bool8 sub_80A7238(void); +void sub_80A8048(s16 *bottom, s16 *top, const void *ptr); +void *sub_80A8050(s16 bottom, s16 top); +u8 sub_80A82E4(u8 battlerId); +void sub_80A8D78(struct Task *task, u8 taskId); + +// EWRAM vars +EWRAM_DATA static union AffineAnimCmd *gUnknown_02038444 = NULL; + +// Const rom data +static const struct UCoords8 sBattlerCoords[][4] = +{ + { + { 72, 80 }, + { 176, 40 }, + { 48, 40 }, + { 112, 80 }, + }, + { + { 32, 80 }, + { 200, 40 }, + { 90, 88 }, + { 152, 32 }, + }, +}; + +// One entry for each of the four Castform forms. +const struct MonCoords gCastformFrontSpriteCoords[] = +{ + { 0x44, 17 }, // NORMAL + { 0x66, 9 }, // SUN + { 0x46, 9 }, // RAIN + { 0x86, 8 }, // HAIL +}; + +static const u8 sCastformElevations[] = +{ + 13, // NORMAL + 14, // SUN + 13, // RAIN + 13, // HAIL +}; + +// Y position of the backsprite for each of the four Castform forms. +static const u8 sCastformBackSpriteYCoords[] = +{ + 0, // NORMAL + 0, // SUN + 0, // RAIN + 0, // HAIL +}; + +static const struct SpriteTemplate sUnknown_08525F90[] = +{ + { + .tileTag = 55125, + .paletteTag = 55125, + .oam = &gUnknown_0852497C, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + }, + { + .tileTag = 55126, + .paletteTag = 55126, + .oam = &gUnknown_0852497C, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, + } +}; + +static const struct SpriteSheet sUnknown_08525FC0[] = +{ + { gMiscBlank_Gfx, 0x800, 55125, }, + { gMiscBlank_Gfx, 0x800, 55126, }, +}; + +// code +u8 GetBattlerSpriteCoord(u8 battlerId, u8 attributeId) +{ + u8 retVal; + u16 species; + struct BattleSpriteInfo *spriteInfo; + + if (IsContest()) + { + if (attributeId == BATTLER_COORD_3 && battlerId == 3) + attributeId = BATTLER_COORD_Y; + } + + switch (attributeId) + { + case BATTLER_COORD_X: + case BATTLER_COORD_X_2: + retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].x; + break; + case BATTLER_COORD_Y: + retVal = sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y; + break; + case BATTLER_COORD_3: + case BATTLER_COORD_4: + default: + if (IsContest()) + { + if (shared19348.unk4_0) + species = shared19348.unk2; + else + species = shared19348.unk0; + } + else + { + if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + } + } + if (attributeId == BATTLER_COORD_3) + retVal = GetBattlerSpriteFinal_Y(battlerId, species, TRUE); + else + retVal = GetBattlerSpriteFinal_Y(battlerId, species, FALSE); + break; + } + + return retVal; +} + +u8 GetBattlerYDelta(u8 battlerId, u16 species) +{ + u16 letter; + u32 personality; + struct BattleSpriteInfo *spriteInfo; + u8 ret; + u16 coordSpecies; + + if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest()) + { + if (species == SPECIES_UNOWN) + { + if (IsContest()) + { + if (shared19348.unk4_0) + personality = shared19348.unk10; + else + personality = shared19348.unk8; + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY); + else + personality = gTransformedPersonalities[battlerId]; + } + letter = GET_UNOWN_LETTER(personality); + if (!letter) + coordSpecies = species; + else + coordSpecies = letter + SPECIES_UNOWN_B - 1; + ret = gMonBackPicCoords[coordSpecies].y_offset; + } + else if (species == SPECIES_CASTFORM) + { + ret = sCastformBackSpriteYCoords[gBattleMonForms[battlerId]]; + } + else if (species > NUM_SPECIES) + { + ret = gMonBackPicCoords[0].y_offset; + } + else + { + ret = gMonBackPicCoords[species].y_offset; + } + } + else + { + if (species == SPECIES_UNOWN) + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY); + else + personality = gTransformedPersonalities[battlerId]; + letter = GET_UNOWN_LETTER(personality); + if (!letter) + coordSpecies = species; + else + coordSpecies = letter + SPECIES_UNOWN_B - 1; + ret = gMonFrontPicCoords[coordSpecies].y_offset; + } + else if (species == SPECIES_CASTFORM) + { + ret = gCastformFrontSpriteCoords[gBattleMonForms[battlerId]].y_offset; + } + else if (species > NUM_SPECIES) + { + ret = gMonFrontPicCoords[0].y_offset; + } + else + { + ret = gMonFrontPicCoords[species].y_offset; + } + } + return ret; +} + +u8 GetBattlerElevation(u8 battlerId, u16 species) +{ + u8 ret = 0; + if (GetBattlerSide(battlerId) == B_SIDE_OPPONENT) + { + if (!IsContest()) + { + if (species == SPECIES_CASTFORM) + ret = sCastformElevations[gBattleMonForms[battlerId]]; + else if (species > NUM_SPECIES) + ret = gEnemyMonElevation[0]; + else + ret = gEnemyMonElevation[species]; + } + } + return ret; +} + +u8 GetBattlerSpriteFinal_Y(u8 battlerId, u16 species, bool8 a3) +{ + u16 offset; + u8 y; + + if (GetBattlerSide(battlerId) == B_SIDE_PLAYER || IsContest()) + { + offset = GetBattlerYDelta(battlerId, species); + } + else + { + offset = GetBattlerYDelta(battlerId, species); + offset -= GetBattlerElevation(battlerId, species); + } + y = offset + sBattlerCoords[IS_DOUBLE_BATTLE()][GetBattlerPosition(battlerId)].y; + if (a3) + { + if (GetBattlerSide(battlerId) == B_SIDE_PLAYER) + y += 8; + if (y > 104) + y = 104; + } + return y; +} + +u8 GetBattlerSpriteCoord2(u8 battlerId, u8 attributeId) +{ + u16 species; + struct BattleSpriteInfo *spriteInfo; + + if (attributeId == BATTLER_COORD_3 || attributeId == BATTLER_COORD_4) + { + if (IsContest()) + { + if (shared19348.unk4_0) + species = shared19348.unk2; + else + species = shared19348.unk0; + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = gAnimBattlerSpecies[battlerId]; + else + species = spriteInfo[battlerId].transformSpecies; + } + if (attributeId == BATTLER_COORD_3) + return GetBattlerSpriteFinal_Y(battlerId, species, TRUE); + else + return GetBattlerSpriteFinal_Y(battlerId, species, FALSE); + } + else + { + return GetBattlerSpriteCoord(battlerId, attributeId); + } +} + +u8 GetBattlerSpriteDefault_Y(u8 battlerId) +{ + return GetBattlerSpriteCoord(battlerId, BATTLER_COORD_4); +} + +u8 GetSubstituteSpriteDefault_Y(u8 battlerId) +{ + u16 y; + if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 16; + else + y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 17; + return y; +} + +u8 GetBattlerYCoordWithElevation(u8 battlerId) +{ + u16 species; + u8 y; + struct BattleSpriteInfo *spriteInfo; + + y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y); + if (!IsContest()) + { + if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + } + if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + y -= GetBattlerElevation(battlerId, species); + } + return y; +} + +u8 GetAnimBattlerSpriteId(u8 which) +{ + u8 *sprites; + + if (which == ANIM_ATTACKER) + { + if (IsBattlerSpritePresent(gBattleAnimAttacker)) + { + sprites = gBattlerSpriteIds; + return sprites[gBattleAnimAttacker]; + } + else + { + return 0xff; + } + } + else if (which == ANIM_TARGET) + { + if (IsBattlerSpritePresent(gBattleAnimTarget)) + { + sprites = gBattlerSpriteIds; + return sprites[gBattleAnimTarget]; + } + else + { + return 0xff; + } + } + else if (which == ANIM_ATK_PARTNER) + { + if (!IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) + return 0xff; + else + return gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimAttacker)]; + } + else + { + if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + return gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimTarget)]; + else + return 0xff; + } +} + +void StoreSpriteCallbackInData6(struct Sprite *sprite, void (*callback)(struct Sprite*)) +{ + sprite->data[6] = (u32)(callback) & 0xffff; + sprite->data[7] = (u32)(callback) >> 16; +} + +void SetCallbackToStoredInData6(struct Sprite *sprite) +{ + u32 callback = (u16)sprite->data[6] | (sprite->data[7] << 16); + sprite->callback = (void (*)(struct Sprite *))callback; +} + +void sub_80A62EC(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[1]); + sprite->data[0] += sprite->data[2]; + if (sprite->data[0] >= 0x100) + sprite->data[0] -= 0x100; + else if (sprite->data[0] < 0) + sprite->data[0] += 0x100; + sprite->data[3]--; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A634C(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = Sin(sprite->data[0], (sprite->data[5] >> 8) + sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], (sprite->data[5] >> 8) + sprite->data[1]); + sprite->data[0] += sprite->data[2]; + sprite->data[5] += sprite->data[4]; + if (sprite->data[0] >= 0x100) + sprite->data[0] -= 0x100; + else if (sprite->data[0] < 0) + sprite->data[0] += 0x100; + sprite->data[3]--; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A63C8(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[4], sprite->data[1]); + sprite->data[0] += sprite->data[2]; + sprite->data[4] += sprite->data[5]; + if (sprite->data[0] >= 0x100) + sprite->data[0] -= 0x100; + else if (sprite->data[0] < 0) + sprite->data[0] += 0x100; + if (sprite->data[4] >= 0x100) + sprite->data[4] -= 0x100; + else if (sprite->data[4] < 0) + sprite->data[4] += 0x100; + sprite->data[3]--; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A6450(struct Sprite *sprite) +{ + if (sprite->data[3]) + { + sprite->pos2.x = Sin(sprite->data[0], sprite->data[1]); + sprite->pos2.y = Cos(sprite->data[0], sprite->data[4]); + sprite->data[0] += sprite->data[2]; + if (sprite->data[0] >= 0x100) + sprite->data[0] -= 0x100; + else if (sprite->data[0] < 0) + sprite->data[0] += 0x100; + sprite->data[3]--; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +// Simply waits until the sprite's data[0] hits zero. +// This is used to let sprite anims or affine anims to run for a designated +// duration. +void sub_80A64B0(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + sprite->data[0]--; + else + SetCallbackToStoredInData6(sprite); +} + +void sub_80A64D0(struct Sprite *sprite) +{ + sub_80A64EC(sprite); + sprite->callback = sub_80A653C; + sprite->callback(sprite); +} + +void sub_80A64EC(struct Sprite *sprite) +{ + s16 old; + int v1; + + if (sprite->data[1] > sprite->data[2]) + sprite->data[0] = -sprite->data[0]; + v1 = sprite->data[2] - sprite->data[1]; + old = sprite->data[0]; + sprite->data[0] = abs(v1 / sprite->data[0]); + sprite->data[2] = (sprite->data[4] - sprite->data[3]) / sprite->data[0]; + sprite->data[1] = old; +} + +void sub_80A653C(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->pos2.x += sprite->data[1]; + sprite->pos2.y += sprite->data[2]; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A656C(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + sprite->pos2.x = sprite->data[3] >> 8; + sprite->pos2.y = sprite->data[4] >> 8; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A65A8(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + sprite->pos2.x = sprite->data[3] >> 8; + sprite->pos2.y = sprite->data[4] >> 8; + } + else + { + SetCallbackToStoredInData6(sprite); + } + UpdateMonIconFrame(sprite); +} + +void sub_80A65EC(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x + sprite->pos2.x; + sprite->data[3] = sprite->pos1.y + sprite->pos2.y; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3); + sprite->callback = sub_80A64D0; +} + +void sub_80A6630(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + gSprites[sprite->data[3]].pos2.x += sprite->data[1]; + gSprites[sprite->data[3]].pos2.y += sprite->data[2]; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +// Same as sub_80A6630, but it operates on sub-pixel values +// to handle slower translations. +void sub_80A6680(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + gSprites[sprite->data[5]].pos2.x = sprite->data[3] >> 8; + gSprites[sprite->data[5]].pos2.y = sprite->data[4] >> 8; + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void sub_80A66DC(struct Sprite *sprite) +{ + if (sprite->data[0] > 0) + { + sprite->data[0]--; + sprite->pos2.x = sprite->data[2] >> 8; + sprite->data[2] += sprite->data[1]; + sprite->pos2.y = sprite->data[4] >> 8; + sprite->data[4] += sprite->data[3]; + if (sprite->data[0] % sprite->data[5] == 0) + { + if (sprite->data[5]) + sprite->invisible ^= 1; + } + } + else + { + SetCallbackToStoredInData6(sprite); + } +} + +void move_anim_8074EE0(struct Sprite *sprite) +{ + FreeSpriteOamMatrix(sprite); + DestroyAnimSprite(sprite); +} + +void sub_80A6760(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x + sprite->pos2.x; + sprite->data[3] = sprite->pos1.y + sprite->pos2.y; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); + sprite->callback = sub_80A64D0; +} + +void sub_80A67A4(struct Sprite *sprite) +{ + ResetPaletteStructByUid(sprite->data[5]); + move_anim_8074EE0(sprite); +} + +void sub_80A67BC(struct Sprite *sprite) +{ + if (sprite->affineAnimEnded) + SetCallbackToStoredInData6(sprite); +} + +void sub_80A67D8(struct Sprite *sprite) +{ + if (sprite->animEnded) + SetCallbackToStoredInData6(sprite); +} + +void sub_80A67F4(struct Sprite *sprite) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimSprite(sprite); +} + +void sub_80A6814(u8 taskId) +{ + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); +} + +void sub_80A6838(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, 3); +} + +void sub_80A6864(struct Sprite *sprite, s16 a2) +{ + u16 v1 = GetBattlerSpriteCoord(gBattleAnimAttacker, 0); + u16 v2 = GetBattlerSpriteCoord(gBattleAnimTarget, 0); + + if (v1 > v2) + { + sprite->pos1.x -= a2; + } + else if (v1 < v2) + { + sprite->pos1.x += a2; + } + else + { + if (GetBattlerSide(gBattleAnimAttacker) != 0) + sprite->pos1.x -= a2; + else + sprite->pos1.x += a2; + } +} + +void sub_80A68D4(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + InitAnimLinearTranslation(sprite); + sprite->data[6] = 0x8000 / sprite->data[0]; + sprite->data[7] = 0; +} + +bool8 TranslateAnimArc(struct Sprite *sprite) +{ + if (TranslateAnimLinear(sprite)) + return TRUE; + sprite->data[7] += sprite->data[6]; + sprite->pos2.y += Sin((u8)(sprite->data[7] >> 8), sprite->data[5]); + return FALSE; +} + +bool8 sub_80A6934(struct Sprite *sprite) +{ + if (TranslateAnimLinear(sprite)) + return TRUE; + sprite->data[7] += sprite->data[6]; + sprite->pos2.x += Sin((u8)(sprite->data[7] >> 8), sprite->data[5]); + return FALSE; +} + +void oamt_add_pos2_onto_pos1(struct Sprite *sprite) +{ + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; +} + +void sub_80A6980(struct Sprite *sprite, bool8 a2) +{ + if (!a2) + { + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimTarget, 0); + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimTarget, 1); + } + sub_80A6864(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; +} + +void sub_80A69CC(struct Sprite *sprite, u8 a2) +{ + if (!a2) + { + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, 0); + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, 1); + } + else + { + sprite->pos1.x = GetBattlerSpriteCoord2(gBattleAnimAttacker, 2); + sprite->pos1.y = GetBattlerSpriteCoord2(gBattleAnimAttacker, 3); + } + sub_80A6864(sprite, gBattleAnimArgs[0]); + sprite->pos1.y += gBattleAnimArgs[1]; +} + +u8 GetBattlerSide(u8 battlerId) +{ + return GET_BATTLER_SIDE2(battlerId); +} + +u8 GetBattlerPosition(u8 battlerId) +{ + return GET_BATTLER_POSITION(battlerId); +} + +u8 GetBattlerAtPosition(u8 position) +{ + u8 i; + + for (i = 0; i < gBattlersCount; i++) + { + if (gBattlerPositions[i] == position) + break; + } + return i; +} + +bool8 IsBattlerSpritePresent(u8 battlerId) +{ + if (IsContest()) + { + if (gBattleAnimAttacker == battlerId) + return TRUE; + else if (gBattleAnimTarget == battlerId) + return TRUE; + else + return FALSE; + } + else + { + if (gBattlerPositions[battlerId] == 0xff) + { + return FALSE; + } + else if (GetBattlerSide(battlerId) != B_SIDE_PLAYER) + { + if (GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0) + return TRUE; + } + else + { + if (GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_HP) != 0) + return TRUE; + } + } + return FALSE; +} + +bool8 IsDoubleBattle(void) +{ + return IS_DOUBLE_BATTLE(); +} + +void sub_80A6B30(struct UnknownAnimStruct2 *unk) +{ + if (IsContest()) + { + unk->bgTiles = gUnknown_0202305C; + unk->unk4 = (u16 *)gUnknown_02023060; + unk->unk8 = 0xe; + unk->bgId = 1; + unk->tilesOffset = 0; + unk->unkC = 0; + } + else + { + unk->bgTiles = gUnknown_0202305C; + unk->unk4 = (u16 *)gUnknown_02023060; + unk->unk8 = 0x8; + unk->bgId = 1; + unk->tilesOffset = 0x200; + unk->unkC = 0; + } +} + +void sub_80A6B90(struct UnknownAnimStruct2 *unk, u32 arg1) +{ + if (IsContest()) + { + unk->bgTiles = gUnknown_0202305C; + unk->unk4 = (u16 *)gUnknown_02023060; + unk->unk8 = 0xe; + unk->bgId = 1; + unk->tilesOffset = 0; + unk->unkC = 0; + } + else if (arg1 == 1) + { + sub_80A6B30(unk); + } + else + { + unk->bgTiles = gUnknown_0202305C; + unk->unk4 = (u16 *)gUnknown_02023060; + unk->unk8 = 0x9; + unk->bgId = 2; + unk->tilesOffset = 0x300; + unk->unkC = 0; + } +} + +void sub_80A6BFC(struct UnknownAnimStruct2 *unk) +{ + unk->bgTiles = gUnknown_0202305C; + unk->unk4 = (u16 *)gUnknown_02023060; + if (IsContest()) + { + unk->unk8 = 0xe; + unk->bgId = 1; + unk->tilesOffset = 0; + unk->unkC = 0; + } + else if (sub_80A8364(gBattleAnimAttacker) == 1) + { + unk->unk8 = 8; + unk->bgId = 1; + unk->tilesOffset = 0x200; + unk->unkC = 0; + } + else + { + unk->unk8 = 0x9; + unk->bgId = 2; + unk->tilesOffset = 0x300; + unk->unkC = 0; + } +} + +void sub_80A6C68(u32 arg0) +{ + struct UnknownAnimStruct2 unkStruct; + + sub_80A6B90(&unkStruct, arg0); + CpuFill32(0, unkStruct.bgTiles, 0x2000); + LoadBgTiles(unkStruct.bgId, unkStruct.bgTiles, 0x2000, unkStruct.tilesOffset); + FillBgTilemapBufferRect(unkStruct.bgId, 0, 0, 0, 0x20, 0x40, 0x11); + CopyBgTilemapBufferToVram(unkStruct.bgId); +} + +void sub_80A6CC0(u32 bgId, void *src, u32 tilesOffset) +{ + CpuFill32(0, gUnknown_0202305C, 0x2000); + LZDecompressWram(src, gUnknown_0202305C); + LoadBgTiles(bgId, gUnknown_0202305C, 0x2000, tilesOffset); +} + +void sub_80A6D10(u32 bgId, const void *src) +{ + FillBgTilemapBufferRect(bgId, 0, 0, 0, 0x20, 0x40, 0x11); + CopyToBgTilemapBuffer(bgId, src, 0, 0); +} + +void sub_80A6D48(u32 bgId, const void *src) +{ + sub_80A6D10(bgId, src); + CopyBgTilemapBufferToVram(bgId); +} + +void sub_80A6D60(struct UnknownAnimStruct2 *unk, const void *src, u32 arg2) +{ + sub_80A6D10(unk->bgId, src); + if (IsContest() == TRUE) + sub_80A4720(unk->unk8, unk->unk4, 0, arg2); + CopyBgTilemapBufferToVram(unk->bgId); +} + +u8 sub_80A6D94(void) +{ + if (IsContest()) + return 1; + else + return 2; +} + +void sub_80A6DAC(bool8 arg0) +{ + if (!arg0 || IsContest()) + { + SetAnimBgAttribute(3, BG_ANIM_SCREEN_SIZE, 0); + SetAnimBgAttribute(3, BG_ANIM_AREA_OVERFLOW_MODE, 1); + } + else + { + SetAnimBgAttribute(3, BG_ANIM_SCREEN_SIZE, 1); + SetAnimBgAttribute(3, BG_ANIM_AREA_OVERFLOW_MODE, 0); + } +} + +void sub_80A6DEC(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sub_80A6E14(sprite); + sprite->callback = sub_80A65A8; + sprite->callback(sprite); +} + +void sub_80A6E14(struct Sprite *sprite) +{ + s16 x = (sprite->data[2] - sprite->data[1]) << 8; + s16 y = (sprite->data[4] - sprite->data[3]) << 8; + sprite->data[1] = x / sprite->data[0]; + sprite->data[2] = y / sprite->data[0]; + sprite->data[4] = 0; + sprite->data[3] = 0; +} + +void InitAnimLinearTranslation(struct Sprite *sprite) +{ + int x = sprite->data[2] - sprite->data[1]; + int y = sprite->data[4] - sprite->data[3]; + bool8 movingLeft = x < 0; + bool8 movingUp = y < 0; + u16 xDelta = abs(x) << 8; + u16 yDelta = abs(y) << 8; + + xDelta = xDelta / sprite->data[0]; + yDelta = yDelta / sprite->data[0]; + + if (movingLeft) + xDelta |= 1; + else + xDelta &= ~1; + + if (movingUp) + yDelta |= 1; + else + yDelta &= ~1; + + sprite->data[1] = xDelta; + sprite->data[2] = yDelta; + sprite->data[4] = 0; + sprite->data[3] = 0; +} + +void sub_80A6EEC(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + InitAnimLinearTranslation(sprite); + sprite->callback = sub_80A6F98; + sprite->callback(sprite); +} + +void sub_80A6F14(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + InitAnimLinearTranslation(sprite); + sprite->callback = sub_80A6FB4; + sprite->callback(sprite); +} + +bool8 TranslateAnimLinear(struct Sprite *sprite) +{ + u16 v1, v2, x, y; + + if (!sprite->data[0]) + return TRUE; + + v1 = sprite->data[1]; + v2 = sprite->data[2]; + x = sprite->data[3]; + y = sprite->data[4]; + x += v1; + y += v2; + + if (v1 & 1) + sprite->pos2.x = -(x >> 8); + else + sprite->pos2.x = x >> 8; + + if (v2 & 1) + sprite->pos2.y = -(y >> 8); + else + sprite->pos2.y = y >> 8; + + sprite->data[3] = x; + sprite->data[4] = y; + sprite->data[0]--; + return FALSE; +} + +void sub_80A6F98(struct Sprite *sprite) +{ + if (TranslateAnimLinear(sprite)) + SetCallbackToStoredInData6(sprite); +} + +void sub_80A6FB4(struct Sprite *sprite) +{ + sub_8039E9C(sprite); + if (TranslateAnimLinear(sprite)) + SetCallbackToStoredInData6(sprite); +} + +void sub_80A6FD4(struct Sprite *sprite) +{ + int v1 = abs(sprite->data[2] - sprite->data[1]) << 8; + sprite->data[0] = v1 / sprite->data[0]; + InitAnimLinearTranslation(sprite); +} + +void sub_80A7000(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sub_80A6FD4(sprite); + sprite->callback = sub_80A6F98; + sprite->callback(sprite); +} + +void sub_80A7028(struct Sprite *sprite) +{ + int x = sprite->data[2] - sprite->data[1]; + int y = sprite->data[4] - sprite->data[3]; + bool8 x_sign = x < 0; + bool8 y_sign = y < 0; + u16 x2 = abs(x) << 4; + u16 y2 = abs(y) << 4; + + x2 /= sprite->data[0]; + y2 /= sprite->data[0]; + + if (x_sign) + x2 |= 1; + else + x2 &= ~1; + + if (y_sign) + y2 |= 1; + else + y2 &= ~1; + + sprite->data[1] = x2; + sprite->data[2] = y2; + sprite->data[4] = 0; + sprite->data[3] = 0; +} + +void sub_80A70C0(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sub_80A7028(sprite); + sprite->callback = sub_80A7144; + sprite->callback(sprite); +} + +bool8 sub_80A70E8(struct Sprite *sprite) +{ + u16 v1, v2, x, y; + + if (!sprite->data[0]) + return TRUE; + + v1 = sprite->data[1]; + v2 = sprite->data[2]; + x = sprite->data[3]; + y = sprite->data[4]; + x += v1; + y += v2; + + if (v1 & 1) + sprite->pos2.x = -(x >> 4); + else + sprite->pos2.x = x >> 4; + + if (v2 & 1) + sprite->pos2.y = -(y >> 4); + else + sprite->pos2.y = y >> 4; + + sprite->data[3] = x; + sprite->data[4] = y; + sprite->data[0]--; + return FALSE; +} + +void sub_80A7144(struct Sprite *sprite) +{ + if (sub_80A70E8(sprite)) + SetCallbackToStoredInData6(sprite); +} + +void sub_80A7160(struct Sprite *sprite) +{ + int v1 = abs(sprite->data[2] - sprite->data[1]) << 4; + sprite->data[0] = v1 / sprite->data[0]; + sub_80A7028(sprite); +} + +void sub_80A718C(struct Sprite *sprite) +{ + sprite->data[1] = sprite->pos1.x; + sprite->data[3] = sprite->pos1.y; + sub_80A7160(sprite); + sprite->callback = sub_80A7144; + sprite->callback(sprite); +} + +void obj_id_set_rotscale(u8 spriteId, s16 xScale, s16 yScale, u16 rotation) +{ + int i; + struct ObjAffineSrcData src; + struct OamMatrix matrix; + + src.xScale = xScale; + src.yScale = yScale; + src.rotation = rotation; + if (sub_80A7238()) + src.xScale = -src.xScale; + i = gSprites[spriteId].oam.matrixNum; + ObjAffineSet(&src, &matrix, 1, 2); + gOamMatrices[i].a = matrix.a; + gOamMatrices[i].b = matrix.b; + gOamMatrices[i].c = matrix.c; + gOamMatrices[i].d = matrix.d; +} + +bool8 sub_80A7238(void) +{ + if (IsContest()) + { + if (gSprites[GetAnimBattlerSpriteId(ANIM_ATTACKER)].data[2] == SPECIES_UNOWN) + return FALSE; + else + return TRUE; + } + else + { + return FALSE; + } +} + +void sub_80A7270(u8 spriteId, u8 objMode) +{ + u8 battlerId = gSprites[spriteId].data[0]; + + if (IsContest() || IsBattlerSpriteVisible(battlerId)) + gSprites[spriteId].invisible = FALSE; + gSprites[spriteId].oam.objMode = objMode; + gSprites[spriteId].affineAnimPaused = TRUE; + if (!IsContest() && !gSprites[spriteId].oam.affineMode) + gSprites[spriteId].oam.matrixNum = gBattleSpritesDataPtr->healthBoxesData[battlerId].field_6; + gSprites[spriteId].oam.affineMode = 3; + CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); +} + +void sub_80A7344(u8 spriteId) +{ + obj_id_set_rotscale(spriteId, 0x100, 0x100, 0); + gSprites[spriteId].oam.affineMode = 1; + gSprites[spriteId].oam.objMode = 0; + gSprites[spriteId].affineAnimPaused = FALSE; + CalcCenterToCornerVec(&gSprites[spriteId], gSprites[spriteId].oam.shape, gSprites[spriteId].oam.size, gSprites[spriteId].oam.affineMode); +} + +void sub_80A73A0(u8 spriteId) +{ + u16 matrix = gSprites[spriteId].oam.matrixNum; + s16 c = gOamMatrices[matrix].c; + + if (c < 0) + c = -c; + gSprites[spriteId].pos2.y = c >> 3; +} + +// related to obj_id_set_rotscale +void sub_80A73E0(struct Sprite *sprite, bool8 a2, s16 xScale, s16 yScale, u16 rotation) +{ + int i; + struct ObjAffineSrcData src; + struct OamMatrix matrix; + + if (sprite->oam.affineMode & 1) + { + sprite->affineAnimPaused = TRUE; + if (a2) + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode); + src.xScale = xScale; + src.yScale = yScale; + src.rotation = rotation; + if (sub_80A7238()) + src.xScale = -src.xScale; + i = sprite->oam.matrixNum; + ObjAffineSet(&src, &matrix, 1, 2); + gOamMatrices[i].a = matrix.a; + gOamMatrices[i].b = matrix.b; + gOamMatrices[i].c = matrix.c; + gOamMatrices[i].d = matrix.d; + } +} + +void sub_80A749C(struct Sprite *sprite) +{ + sub_80A73E0(sprite, TRUE, 0x100, 0x100, 0); + sprite->affineAnimPaused = FALSE; + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode); +} + +static u16 ArcTan2_(s16 a, s16 b) +{ + return ArcTan2(a, b); +} + +u16 ArcTan2Neg(s16 a, s16 b) +{ + u16 var = ArcTan2_(a, b); + return -var; +} + +void sub_80A750C(u16 a1, bool8 a2) +{ + int i; + struct PlttData *c; + struct PlttData *c2; + u16 average; + + a1 *= 0x10; + + if (!a2) + { + for (i = 0; i < 0x10; i++) + { + c = (struct PlttData *)&gPlttBufferUnfaded[a1 + i]; + average = c->r + c->g + c->b; + average /= 3; + + c2 = (struct PlttData *)&gPlttBufferFaded[a1 + i]; + c2->r = average; + c2->g = average; + c2->b = average; + } + } + else + { + CpuCopy32(&gPlttBufferUnfaded[a1], &gPlttBufferFaded[a1], 0x20); + } +} + +u32 sub_80A75AC(u8 a1, u8 a2, u8 a3, u8 a4, u8 a5, u8 a6, u8 a7) +{ + u32 var = 0; + u32 shift; + + if (a1) + { + if (!IsContest()) + var = 0xe; + else + var = 1 << sub_80A6D94(); + } + if (a2) + { + shift = gBattleAnimAttacker + 16; + var |= 1 << shift; + } + if (a3) { + shift = gBattleAnimTarget + 16; + var |= 1 << shift; + } + if (a4) + { + if (IsBattlerSpriteVisible(gBattleAnimAttacker ^ 2)) + { + shift = (gBattleAnimAttacker ^ 2) + 16; + var |= 1 << shift; + } + } + if (a5) + { + if (IsBattlerSpriteVisible(gBattleAnimTarget ^ 2)) + { + shift = (gBattleAnimTarget ^ 2) + 16; + var |= 1 << shift; + } + } + if (a6) + { + if (!IsContest()) + var |= 0x100; + else + var |= 0x4000; + } + if (a7) + { + if (!IsContest()) + var |= 0x200; + } + return var; +} + +u32 sub_80A76C4(u8 a1, u8 a2, u8 a3, u8 a4) +{ + u32 var = 0; + u32 shift; + + if (IsContest()) + { + if (a1) + { + var |= 1 << 18; + return var; + } + } + else + { + if (a1) + { + if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_LEFT))) + { + var |= 1 << (GetBattlerAtPosition(B_POSITION_PLAYER_LEFT) + 16); + } + } + if (a2) + { + if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT))) + { + shift = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT) + 16; + var |= 1 << shift; + } + } + if (a3) + { + if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT))) + { + shift = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT) + 16; + var |= 1 << shift; + } + } + if (a4) + { + if (IsBattlerSpriteVisible(GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT))) + { + shift = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT) + 16; + var |= 1 << shift; + } + } + } + return var; +} + +u8 sub_80A77AC(u8 a1) +{ + return a1; +} + +u8 sub_80A77B4(u8 position) +{ + return GetBattlerAtPosition(position); +} + +void sub_80A77C8(struct Sprite *sprite) +{ + bool8 var; + + if (!sprite->data[0]) + { + if (!gBattleAnimArgs[3]) + var = TRUE; + else + var = FALSE; + if (!gBattleAnimArgs[2]) + sub_80A69CC(sprite, var); + else + sub_80A6980(sprite, var); + sprite->data[0]++; + + } + else if (sprite->animEnded || sprite->affineAnimEnded) + { + move_anim_8074EE0(sprite); + } +} + +// Linearly translates a sprite to a target position on the +// other mon's sprite. +// arg 0: initial x offset +// arg 1: initial y offset +// arg 2: target x offset +// arg 3: target y offset +// arg 4: duration +// arg 5: lower 8 bits = location on attacking mon, upper 8 bits = location on target mon pick to target +void TranslateAnimSpriteToTargetMonLocation(struct Sprite *sprite) +{ + bool8 v1; + u8 attributeId; + + if (!(gBattleAnimArgs[5] & 0xff00)) + v1 = TRUE; + else + v1 = FALSE; + + if (!(gBattleAnimArgs[5] & 0xff)) + attributeId = BATTLER_COORD_3; + else + attributeId = BATTLER_COORD_Y; + + sub_80A69CC(sprite, v1); + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, attributeId) + gBattleAnimArgs[3]; + sprite->callback = sub_80A6EEC; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void sub_80A78AC(struct Sprite *sprite) +{ + sub_80A69CC(sprite, 1); + if (GetBattlerSide(gBattleAnimAttacker)) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(gBattleAnimTarget, 2) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(gBattleAnimTarget, 3) + gBattleAnimArgs[3]; + sprite->data[5] = gBattleAnimArgs[5]; + sub_80A68D4(sprite); + sprite->callback = sub_80A791C; +} + +void sub_80A791C(struct Sprite *sprite) +{ + if (TranslateAnimArc(sprite)) + DestroyAnimSprite(sprite); +} + +void sub_80A7938(struct Sprite *sprite) +{ + bool8 r4; + u8 battlerId, attributeId; + + if (!gBattleAnimArgs[6]) + { + r4 = TRUE; + attributeId = BATTLER_COORD_3; + } + else + { + r4 = FALSE; + attributeId = BATTLER_COORD_Y; + } + if (!gBattleAnimArgs[5]) + { + sub_80A69CC(sprite, r4); + battlerId = gBattleAnimAttacker; + } + else + { + sub_80A6980(sprite, r4); + battlerId = gBattleAnimTarget; + } + if (GetBattlerSide(gBattleAnimAttacker)) + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + sub_80A6980(sprite, r4); + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[2] = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X_2) + gBattleAnimArgs[2]; + sprite->data[4] = GetBattlerSpriteCoord(battlerId, attributeId) + gBattleAnimArgs[3]; + sprite->callback = sub_80A6EEC; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +s16 duplicate_obj_of_side_rel2move_in_transparent_mode(u8 whichBattler) +{ + u16 i; + u8 spriteId = GetAnimBattlerSpriteId(whichBattler); + + if (spriteId != 0xff) + { + for (i = 0; i < MAX_SPRITES; i++) + { + if (!gSprites[i].inUse) + { + gSprites[i] = gSprites[spriteId]; + gSprites[i].oam.objMode = 1; + gSprites[i].invisible = FALSE; + return i; + } + } + } + return -1; +} + +void obj_delete_but_dont_free_vram(struct Sprite *sprite) +{ + sprite->usingSheet = TRUE; + DestroySprite(sprite); +} + +void sub_80A7A74(u8 taskId) +{ + s16 v1 = 0; + s16 v2 = 0; + + if (gBattleAnimArgs[2] > gBattleAnimArgs[0]) + v2 = 1; + if (gBattleAnimArgs[2] < gBattleAnimArgs[0]) + v2 = -1; + if (gBattleAnimArgs[3] > gBattleAnimArgs[1]) + v1 = 1; + if (gBattleAnimArgs[3] < gBattleAnimArgs[1]) + v1 = -1; + + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = gBattleAnimArgs[4]; + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3] = gBattleAnimArgs[0]; + gTasks[taskId].data[4] = gBattleAnimArgs[1]; + gTasks[taskId].data[5] = v2; + gTasks[taskId].data[6] = v1; + gTasks[taskId].data[7] = gBattleAnimArgs[2]; + gTasks[taskId].data[8] = gBattleAnimArgs[3]; + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(gBattleAnimArgs[0], gBattleAnimArgs[1])); + gTasks[taskId].func = sub_80A7AFC; +} + +void sub_80A7AFC(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (++task->data[0] > task->data[1]) + { + task->data[0] = 0; + if (++task->data[2] & 1) + { + if (task->data[3] != task->data[7]) + task->data[3] += task->data[5]; + } + else + { + if (task->data[4] != task->data[8]) + task->data[4] += task->data[6]; + } + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(task->data[3], task->data[4])); + if (task->data[3] == task->data[7] && task->data[4] == task->data[8]) + { + DestroyAnimVisualTask(taskId); + return; + } + } +} + +// Linearly blends a mon's sprite colors with a target color with increasing +// strength, and then blends out to the original color. +// arg 0: anim bank +// arg 1: blend color +// arg 2: target blend coefficient +// arg 3: initial delay +// arg 4: number of times to blend in and out +void AnimTask_BlendMonInAndOut(u8 task) +{ + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (spriteId == 0xff) + { + DestroyAnimVisualTask(task); + return; + } + gTasks[task].data[0] = (gSprites[spriteId].oam.paletteNum * 0x10) + 0x101; + AnimTask_BlendMonInAndOutSetup(&gTasks[task]); +} + +void AnimTask_BlendMonInAndOutSetup(struct Task *task) +{ + task->data[1] = gBattleAnimArgs[1]; + task->data[2] = 0; + task->data[3] = gBattleAnimArgs[2]; + task->data[4] = 0; + task->data[5] = gBattleAnimArgs[3]; + task->data[6] = 0; + task->data[7] = gBattleAnimArgs[4]; + task->func = AnimTask_BlendMonInAndOutStep; +} + +void AnimTask_BlendMonInAndOutStep(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + if (++task->data[4] >= task->data[5]) + { + task->data[4] = 0; + if (!task->data[6]) + { + task->data[2]++; + BlendPalette(task->data[0], 15, task->data[2], task->data[1]); + if (task->data[2] == task->data[3]) + task->data[6] = 1; + } + else + { + task->data[2]--; + BlendPalette(task->data[0], 15, task->data[2], task->data[1]); + if (!task->data[2]) + { + if (--task->data[7]) + { + task->data[4] = 0; + task->data[6] = 0; + } + else + { + DestroyAnimVisualTask(taskId); + return; + } + } + } + } +} + +void sub_80A7CB4(u8 task) +{ + u8 palette = IndexOfSpritePaletteTag(gBattleAnimArgs[0]); + + if (palette == 0xff) + { + DestroyAnimVisualTask(task); + return; + } + gTasks[task].data[0] = (palette * 0x10) + 0x101; + AnimTask_BlendMonInAndOutSetup(&gTasks[task]); +} + +void sub_80A7CFC(struct Task *task, u8 a2, const void *a3) +{ + task->data[7] = 0; + task->data[8] = 0; + task->data[9] = 0; + task->data[15] = a2; + task->data[10] = 0x100; + task->data[11] = 0x100; + task->data[12] = 0; + sub_80A8048(&task->data[13], &task->data[14], a3); + sub_80A7270(a2, 0); +} + +bool8 sub_80A7D34(struct Task *task) +{ + gUnknown_02038444 = sub_80A8050(task->data[13], task->data[14]) + (task->data[7] << 3); + switch (gUnknown_02038444->type) + { + default: + if (!gUnknown_02038444->frame.duration) + { + task->data[10] = gUnknown_02038444->frame.xScale; + task->data[11] = gUnknown_02038444->frame.yScale; + task->data[12] = gUnknown_02038444->frame.rotation; + task->data[7]++; + gUnknown_02038444++; + } + task->data[10] += gUnknown_02038444->frame.xScale; + task->data[11] += gUnknown_02038444->frame.yScale; + task->data[12] += gUnknown_02038444->frame.rotation; + obj_id_set_rotscale(task->data[15], task->data[10], task->data[11], task->data[12]); + sub_80A7E6C(task->data[15]); + if (++task->data[8] >= gUnknown_02038444->frame.duration) + { + task->data[8] = 0; + task->data[7]++; + } + break; + case AFFINEANIMCMDTYPE_JUMP: + task->data[7] = gUnknown_02038444->jump.target; + break; + case AFFINEANIMCMDTYPE_LOOP: + if (gUnknown_02038444->loop.count) + { + if (task->data[9]) + { + if (!--task->data[9]) + { + task->data[7]++; + break; + } + } + else + { + task->data[9] = gUnknown_02038444->loop.count; + } + if (!task->data[7]) + { + break; + } + for (;;) + { + task->data[7]--; + gUnknown_02038444--; + if (gUnknown_02038444->type == AFFINEANIMCMDTYPE_LOOP) + { + task->data[7]++; + return TRUE; + } + if (!task->data[7]) + return TRUE; + } + } + task->data[7]++; + break; + case AFFINEANIMCMDTYPE_END: + gSprites[task->data[15]].pos2.y = 0; + sub_80A7344(task->data[15]); + return FALSE; + } + + return TRUE; +} + +void sub_80A7E6C(u8 spriteId) +{ + int var = 0x40 - sub_80A7F18(spriteId) * 2; + u16 matrix = gSprites[spriteId].oam.matrixNum; + int var2 = (var << 8) / gOamMatrices[matrix].d; + + if (var2 > 0x80) + var2 = 0x80; + gSprites[spriteId].pos2.y = (var - var2) / 2; +} + +void sub_80A7EC0(u8 spriteId, u8 spriteId2) +{ + int var = 0x40 - sub_80A7F18(spriteId2) * 2; + u16 matrix = gSprites[spriteId].oam.matrixNum; + int var2 = (var << 8) / gOamMatrices[matrix].d; + + if (var2 > 0x80) + var2 = 0x80; + gSprites[spriteId].pos2.y = (var - var2) / 2; +} + +u16 sub_80A7F18(u8 spriteId) +{ + struct BattleSpriteInfo *spriteInfo; + u8 battlerId = gSprites[spriteId].data[0]; + u16 species; + u16 i; + + for (i = 0; i < MAX_BATTLERS_COUNT; i++) + { + if (gBattlerSpriteIds[i] == spriteId) + { + if (IsContest()) + { + species = shared19348.unk0; + return gMonBackPicCoords[species].y_offset; + } + else + { + if (GetBattlerSide(i) == B_SIDE_PLAYER) + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + + if (species == SPECIES_CASTFORM) + return sCastformBackSpriteYCoords[gBattleMonForms[battlerId]]; + else + return gMonBackPicCoords[species].y_offset; + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[i]], MON_DATA_SPECIES); + else + species = spriteInfo[battlerId].transformSpecies; + + if (species == SPECIES_CASTFORM) + return sCastformElevations[gBattleMonForms[battlerId]]; + else + return gMonFrontPicCoords[species].y_offset; + } + } + } + } + return 0x40; +} + +void sub_80A8048(s16 *bottom, s16 *top, const void *ptr) +{ + *bottom = ((intptr_t) ptr) & 0xffff; + *top = (((intptr_t) ptr) >> 16) & 0xffff; +} + +void *sub_80A8050(s16 bottom, s16 top) +{ + return (void *)((u16)bottom | ((u16)top << 16)); +} + +void sub_80A805C(struct Task *task, u8 a2, s16 a3, s16 a4, s16 a5, s16 a6, u16 a7) +{ + task->data[8] = a7; + task->data[15] = a2; // spriteId + task->data[9] = a3; + task->data[10] = a4; + task->data[13] = a5; + task->data[14] = a6; + task->data[11] = (a5 - a3) / a7; + task->data[12] = (a6 - a4) / a7; +} + +u8 sub_80A80C8(struct Task *task) +{ + if (!task->data[8]) + return 0; + + if (--task->data[8] != 0) + { + task->data[9] += task->data[11]; + task->data[10] += task->data[12]; + } + else + { + task->data[9] = task->data[13]; + task->data[10] = task->data[14]; + } + obj_id_set_rotscale(task->data[15], task->data[9], task->data[10], 0); + if (task->data[8]) + sub_80A7E6C(task->data[15]); + else + gSprites[task->data[15]].pos2.y = 0; + return task->data[8]; +} + +void AnimTask_GetFrustrationPowerLevel(u8 taskId) +{ + u16 powerLevel; + + if (gAnimFriendship <= 30) + powerLevel = 0; + else if (gAnimFriendship <= 100) + powerLevel = 1; + else if (gAnimFriendship <= 200) + powerLevel = 2; + else + powerLevel = 3; + gBattleAnimArgs[7] = powerLevel; + DestroyAnimVisualTask(taskId); +} + +void sub_80A8174(u8 priority) +{ + if (IsBattlerSpriteVisible(gBattleAnimTarget)) + gSprites[gBattlerSpriteIds[gBattleAnimTarget]].oam.priority = priority; + if (IsBattlerSpriteVisible(gBattleAnimAttacker)) + gSprites[gBattlerSpriteIds[gBattleAnimAttacker]].oam.priority = priority; + if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimTarget)]].oam.priority = priority; + if (IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) + gSprites[gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimAttacker)]].oam.priority = priority; +} + +void sub_80A8278(void) +{ + int i; + + for (i = 0; i < gBattlersCount; i++) + { + if (IsBattlerSpriteVisible(i)) + { + gSprites[gBattlerSpriteIds[i]].subpriority = sub_80A82E4(i); + gSprites[gBattlerSpriteIds[i]].oam.priority = 2; + } + } +} + +u8 sub_80A82E4(u8 battlerId) +{ + u8 position; + u8 ret; + + if (IsContest()) + { + if (battlerId == 2) + return 30; + else + return 40; + } + else + { + position = GetBattlerPosition(battlerId); + if (position == B_POSITION_PLAYER_LEFT) + ret = 30; + else if (position == B_POSITION_PLAYER_RIGHT) + ret = 20; + else if (position == B_POSITION_OPPONENT_LEFT) + ret = 40; + else + ret = 50; + } + return ret; +} + +u8 sub_80A8328(u8 battlerId) +{ + u8 position = GetBattlerPosition(battlerId); + + if (IsContest()) + return 2; + else if (position == B_POSITION_PLAYER_LEFT || position == B_POSITION_OPPONENT_RIGHT) + return GetAnimBgAttribute(2, BG_ANIM_PRIORITY); + else + return GetAnimBgAttribute(1, BG_ANIM_PRIORITY); +} + +u8 sub_80A8364(u8 battlerId) +{ + if (!IsContest()) + { + u8 position = GetBattlerPosition(battlerId); + if (position == B_POSITION_PLAYER_LEFT || position == B_POSITION_OPPONENT_RIGHT) + return 2; + else + return 1; + } + return 1; +} + +u8 sub_80A8394(u16 species, bool8 isBackpic, u8 a3, s16 x, s16 y, u8 subpriority, u32 personality, u32 trainerId, u32 battlerId, u32 a10) +{ + u8 spriteId; + u16 sheet = LoadSpriteSheet(&sUnknown_08525FC0[a3]); + u16 palette = AllocSpritePalette(sUnknown_08525F90[a3].paletteTag); + + if (gMonSpritesGfxPtr != NULL && gMonSpritesGfxPtr->field_17C == NULL) + gMonSpritesGfxPtr->field_17C = AllocZeroed(0x2000); + if (!isBackpic) + { + LoadCompressedPalette(GetFrontSpritePalFromSpeciesAndPersonality(species, trainerId, personality), (palette * 0x10) + 0x100, 0x20); + if (a10 == 1 || sub_80688F8(5, battlerId) == 1 || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0) + LoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species], + gMonSpritesGfxPtr->field_17C, + species, + personality, + TRUE); + else + LoadSpecialPokePic_2(&gMonFrontPicTable[species], + gMonSpritesGfxPtr->field_17C, + species, + personality, + TRUE); + } + else + { + LoadCompressedPalette(GetFrontSpritePalFromSpeciesAndPersonality(species, trainerId, personality), (palette * 0x10) + 0x100, 0x20); + if (a10 == 1 || sub_80688F8(5, battlerId) == 1 || gBattleSpritesDataPtr->battlerData[battlerId].transformSpecies != 0) + LoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species], + gMonSpritesGfxPtr->field_17C, + species, + personality, + FALSE); + else + LoadSpecialPokePic_2(&gMonBackPicTable[species], + gMonSpritesGfxPtr->field_17C, + species, + personality, + FALSE); + } + + RequestDma3Copy(gMonSpritesGfxPtr->field_17C, (void *)(OBJ_VRAM0 + (sheet * 0x20)), 0x800, 1); + FREE_AND_SET_NULL(gMonSpritesGfxPtr->field_17C); + + if (!isBackpic) + spriteId = CreateSprite(&sUnknown_08525F90[a3], x, y + gMonFrontPicCoords[species].y_offset, subpriority); + else + spriteId = CreateSprite(&sUnknown_08525F90[a3], x, y + gMonBackPicCoords[species].y_offset, subpriority); + + if (IsContest()) + { + gSprites[spriteId].affineAnims = gUnknown_082FF6C0; + StartSpriteAffineAnim(&gSprites[spriteId], 0); + } + return spriteId; +} + +void sub_80A8610(struct Sprite *sprite) +{ + DestroySpriteAndFreeResources(sprite); +} + +s16 sub_80A861C(u8 battlerId, u8 a2) +{ + u16 species; + u32 personality; + u16 letter; + u16 var; + int ret; + const struct MonCoords *coords; + struct BattleSpriteInfo *spriteInfo; + + if (IsContest()) + { + if (shared19348.unk4_0) + { + species = shared19348.unk2; + personality = shared19348.unk10; + } + else + { + species = shared19348.unk0; + personality = shared19348.unk8; + } + if (species == SPECIES_UNOWN) + { + letter = GET_UNOWN_LETTER(personality); + if (!letter) + var = SPECIES_UNOWN; + else + var = letter + SPECIES_UNOWN_B - 1; + coords = &gMonBackPicCoords[var]; + } + else if (species == SPECIES_CASTFORM) + { + coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]]; + } + else if (species <= SPECIES_EGG) + { + coords = &gMonBackPicCoords[species]; + } + else + { + coords = &gMonBackPicCoords[0]; + } + } + else + { + if (GetBattlerSide(battlerId) == B_SIDE_PLAYER) + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + { + species = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + personality = GetMonData(&gPlayerParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY); + } + else + { + species = spriteInfo[battlerId].transformSpecies; + personality = gTransformedPersonalities[battlerId]; + } + if (species == SPECIES_UNOWN) + { + letter = GET_UNOWN_LETTER(personality); + if (!letter) + var = SPECIES_UNOWN; + else + var = letter + SPECIES_UNOWN_B - 1; + coords = &gMonBackPicCoords[var]; + } + else if (species > SPECIES_EGG) + { + coords = &gMonBackPicCoords[0]; + } + else + { + coords = &gMonBackPicCoords[species]; + } + } + else + { + spriteInfo = gBattleSpritesDataPtr->battlerData; + if (!spriteInfo[battlerId].transformSpecies) + { + species = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_SPECIES); + personality = GetMonData(&gEnemyParty[gBattlerPartyIndexes[battlerId]], MON_DATA_PERSONALITY); + } + else + { + species = spriteInfo[battlerId].transformSpecies; + personality = gTransformedPersonalities[battlerId]; + } + if (species == SPECIES_UNOWN) + { + letter = GET_UNOWN_LETTER(personality); + if (!letter) + var = SPECIES_UNOWN; + else + var = letter + SPECIES_UNOWN_B - 1; + coords = &gMonFrontPicCoords[var]; + } + else if (species == SPECIES_CASTFORM) + { + coords = &gCastformFrontSpriteCoords[gBattleMonForms[battlerId]]; + } + else if (species > SPECIES_EGG) + { + coords = &gMonFrontPicCoords[0]; + } + else + { + coords = &gMonFrontPicCoords[species]; + } + } + } + + switch (a2) + { + case 0: + return (coords->coords & 0xf) * 8; + case 1: + return (coords->coords >> 4) * 8; + case 4: + return GetBattlerSpriteCoord(battlerId, 2) - ((coords->coords >> 4) * 4); + case 5: + return GetBattlerSpriteCoord(battlerId, 2) + ((coords->coords >> 4) * 4); + case 2: + return GetBattlerSpriteCoord(battlerId, 3) - ((coords->coords & 0xf) * 4); + case 3: + return GetBattlerSpriteCoord(battlerId, 3) + ((coords->coords & 0xf) * 4); + case 6: + ret = GetBattlerSpriteCoord(battlerId, 1) + 0x1f; + return ret - coords->y_offset; + default: + return 0; + } +} + +void SetAverageBattlerPositions(u8 battlerId, bool8 a2, s16 *x, s16 *y) +{ + u8 v1, v2; + s16 v3, v4; + s16 v5, v6; + + if (!a2) + { + v1 = 0; + v2 = 1; + } + else + { + v1 = 2; + v2 = 3; + } + v3 = GetBattlerSpriteCoord(battlerId, v1); + v4 = GetBattlerSpriteCoord(battlerId, v2); + if (IsDoubleBattle() && !IsContest()) + { + v5 = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), v1); + v6 = GetBattlerSpriteCoord(BATTLE_PARTNER(battlerId), v2); + } + else + { + v5 = v3; + v6 = v4; + } + *x = (v3 + v5) / 2; + *y = (v4 + v6) / 2; +} + +u8 sub_80A89C8(int battlerId, u8 spriteId, int species) +{ + u8 newSpriteId = CreateInvisibleSpriteWithCallback(SpriteCallbackDummy); + gSprites[newSpriteId] = gSprites[spriteId]; + gSprites[newSpriteId].usingSheet = TRUE; + gSprites[newSpriteId].oam.priority = 0; + gSprites[newSpriteId].oam.objMode = 2; + gSprites[newSpriteId].oam.tileNum = gSprites[spriteId].oam.tileNum; + gSprites[newSpriteId].callback = SpriteCallbackDummy; + return newSpriteId; +} + +void sub_80A8A6C(struct Sprite *sprite) +{ + sub_80A6838(sprite); + if (GetBattlerSide(gBattleAnimAttacker)) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + gBattleAnimArgs[3] = -gBattleAnimArgs[3]; + sprite->hFlip = TRUE; + } + else + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->data[5] = gBattleAnimArgs[5]; + StoreSpriteCallbackInData6(sprite, move_anim_8074EE0); + sprite->callback = sub_80A66DC; +} + +void sub_80A8AEC(struct Sprite *sprite) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + sprite->pos1.x -= gBattleAnimArgs[0]; + gBattleAnimArgs[3] *= -1; + } + else + { + sprite->pos1.x += gBattleAnimArgs[0]; + } + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gBattleAnimArgs[3]; + sprite->data[3] = gBattleAnimArgs[4]; + sprite->data[5] = gBattleAnimArgs[5]; + StartSpriteAnim(sprite, gBattleAnimArgs[6]); + StoreSpriteCallbackInData6(sprite, move_anim_8074EE0); + sprite->callback = sub_80A66DC; +} + +void sub_80A8B64(struct Sprite *sprite) +{ + sub_80A6838(sprite); + if (GetBattlerSide(gBattleAnimAttacker)) + sprite->pos1.x -= gBattleAnimArgs[0]; + else + sprite->pos1.x += gBattleAnimArgs[0]; + sprite->pos1.y += gBattleAnimArgs[1]; + sprite->callback = sub_80A67D8; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +void sub_80A8BC4(u8 taskId) +{ + u16 src; + u16 dest; + struct Task *task = &gTasks[taskId]; + + task->data[0] = GetAnimBattlerSpriteId(ANIM_ATTACKER); + task->data[1] = ((GetBattlerSide(gBattleAnimAttacker)) != B_SIDE_PLAYER) ? -8 : 8; + task->data[2] = 0; + task->data[3] = 0; + gSprites[task->data[0]].pos2.x -= task->data[0]; + task->data[4] = AllocSpritePalette(10097); + task->data[5] = 0; + + dest = (task->data[4] + 0x10) * 0x10; + src = (gSprites[task->data[0]].oam.paletteNum + 0x10) * 0x10; + task->data[6] = sub_80A82E4(gBattleAnimAttacker); + if (task->data[6] == 20 || task->data[6] == 40) + task->data[6] = 2; + else + task->data[6] = 3; + CpuCopy32(&gPlttBufferUnfaded[src], &gPlttBufferFaded[dest], 0x20); + BlendPalette(dest, 16, gBattleAnimArgs[1], gBattleAnimArgs[0]); + task->func = sub_80A8CAC; +} + +void sub_80A8CAC(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + switch (task->data[2]) + { + case 0: + sub_80A8D78(task, taskId); + gSprites[task->data[0]].pos2.x += task->data[1]; + if (++task->data[3] == 5) + { + task->data[3]--; + task->data[2]++; + } + break; + case 1: + sub_80A8D78(task, taskId); + gSprites[task->data[0]].pos2.x -= task->data[1]; + if (--task->data[3] == 0) + { + gSprites[task->data[0]].pos2.x = 0; + task->data[2]++; + } + break; + case 2: + if (!task->data[5]) + { + FreeSpritePaletteByTag(ANIM_TAG_BENT_SPOON); + DestroyAnimVisualTask(taskId); + } + break; + } +} + +void sub_80A8D78(struct Task *task, u8 taskId) +{ + s16 spriteId = duplicate_obj_of_side_rel2move_in_transparent_mode(0); + if (spriteId >= 0) + { + gSprites[spriteId].oam.priority = task->data[6]; + gSprites[spriteId].oam.paletteNum = task->data[4]; + gSprites[spriteId].data[0] = 8; + gSprites[spriteId].data[1] = taskId; + gSprites[spriteId].data[2] = spriteId; + gSprites[spriteId].pos2.x = gSprites[task->data[0]].pos2.x; + gSprites[spriteId].callback = sub_80A8DFC; + task->data[5]++; + } +} + +void sub_80A8DFC(struct Sprite *sprite) +{ + if (--sprite->data[0] == 0) + { + gTasks[sprite->data[1]].data[5]--; + obj_delete_but_dont_free_vram(sprite); + } +} + +void sub_80A8E30(struct Sprite *sprite) +{ + sprite->pos1.x = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_X_2); + sprite->pos1.y = GetBattlerSpriteCoord(gBattleAnimAttacker, BATTLER_COORD_3); + if (!GetBattlerSide(gBattleAnimAttacker)) + sprite->data[0] = 5; + else + sprite->data[0] = -10; + sprite->data[1] = -40; + sprite->callback = sub_80A8E88; +} + +void sub_80A8E88(struct Sprite *sprite) +{ + sprite->data[2] += sprite->data[0]; + sprite->data[3] += sprite->data[1]; + sprite->pos2.x = sprite->data[2] / 10; + sprite->pos2.y = sprite->data[3] / 10; + if (sprite->data[1] < -20) + sprite->data[1]++; + if (sprite->pos1.y + sprite->pos2.y < -32) + DestroyAnimSprite(sprite); +} + +void sub_80A8EE4(struct Sprite *sprite) +{ + int x; + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[2] = sprite->pos1.x + gBattleAnimArgs[4]; + sprite->data[4] = sprite->pos1.y + gBattleAnimArgs[5]; + if (!GetBattlerSide(gBattleAnimTarget)) + { + x = (u16)gBattleAnimArgs[4] + 30; + sprite->pos1.x += x; + sprite->pos1.y = gBattleAnimArgs[5] - 20; + } + else + { + x = (u16)gBattleAnimArgs[4] - 30; + sprite->pos1.x += x; + sprite->pos1.y = gBattleAnimArgs[5] - 80; + } + sprite->callback = sub_80A6EEC; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} diff --git a/src/battle_anim_80A9C70.c b/src/battle_anim_80A9C70.c new file mode 100644 index 000000000..9b9218b1c --- /dev/null +++ b/src/battle_anim_80A9C70.c @@ -0,0 +1,360 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "constants/battle_anim.h" +#include "constants/rgb.h" +#include "util.h" +#include "decompress.h" +#include "palette.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" +#include "gpu_regs.h" + +extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; +extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; +extern const u8 *const gBattleAnims_StatusConditions[]; +extern const struct OamData gUnknown_08524904; +extern const struct OamData gUnknown_08524A3C; + +extern void sub_8116EB4(u8 taskId); + +// This file's functions. +static void sub_80A9DB4(u8 taskId); +static void sub_80A9FD0(u8 taskId); +static void sub_80AA020(u8 taskId); +static void sub_80AA0D0(u8 taskId); +static void sub_80AA124(u8 taskId); +static void Task_DoStatusAnimation(u8 taskId); +static void sub_80A9E44(struct Sprite *sprite); +static void sub_80A9E78(struct Sprite *sprite); + +// const rom data +static const struct Subsprite gUnknown_0853EF30[] = +{ + {.x = -16, .y = -16, .shape = ST_OAM_SQUARE, .size = 3, .tileOffset = 0, .priority = 2}, + {.x = -16, .y = 48, .shape = ST_OAM_H_RECTANGLE, .size = 3, .tileOffset = 64, .priority = 2}, + {.x = 48, .y = -16, .shape = ST_OAM_V_RECTANGLE, .size = 3, .tileOffset = 96, .priority = 2}, + {.x = 48, .y = 48, .shape = ST_OAM_SQUARE, .size = 2, .tileOffset = 128, .priority = 2}, +}; + +static const struct SubspriteTable gUnknown_0853EF40[] = +{ + {ARRAY_COUNT(gUnknown_0853EF30), gUnknown_0853EF30}, +}; + +static const struct SpriteTemplate gUnknown_0853EF48 = +{ + .tileTag = ANIM_TAG_ICE_CUBE, + .paletteTag = ANIM_TAG_ICE_CUBE, + .oam = &gUnknown_08524A3C, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy, +}; + +static const struct SpriteTemplate gUnknown_0853EF60 = +{ + .tileTag = ANIM_TAG_136, + .paletteTag = ANIM_TAG_136, + .oam = &gUnknown_08524904, + .anims = gDummySpriteAnimTable, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80A9E44, +}; + +// code +u8 sub_80A9C70(u8 battlerId, bool8 b) +{ + u8 battlerSpriteId = gBattlerSpriteIds[battlerId]; + u8 taskId = CreateTask(sub_80A9DB4, 10); + u8 spriteId2; + u8 i; + + LoadCompressedObjectPicUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_136)]); + LoadCompressedObjectPaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_136)]); + gTasks[taskId].data[0] = battlerId; + if (b) + { + gTasks[taskId].data[1] = RGB_RED; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_0853EF60, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y + 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = -256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + else + { + gTasks[taskId].data[1] = RGB_BLUE; + for (i = 0; i < 10; i++) + { + spriteId2 = CreateSprite(&gUnknown_0853EF60, gSprites[battlerSpriteId].pos1.x, gSprites[battlerSpriteId].pos1.y - 32, 0); + gSprites[spriteId2].data[0] = i * 51; + gSprites[spriteId2].data[1] = 256; + gSprites[spriteId2].invisible = TRUE; + if (i > 4) + gSprites[spriteId2].data[6] = 21; + } + } + gSprites[spriteId2].data[7] = 1; + return taskId; +} + +static void sub_80A9DB4(u8 taskId) +{ + if (gTasks[taskId].data[2] == 2) + { + gTasks[taskId].data[2] = 0; + BlendPalette(0x100 + gTasks[taskId].data[0] * 16, 16, gTasks[taskId].data[4], gTasks[taskId].data[1]); + if (gTasks[taskId].data[5] == 0) + { + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] > 8) + gTasks[taskId].data[5] ^= 1; + } + else + { + u16 var = gTasks[taskId].data[4]; + + gTasks[taskId].data[4]--; + if (gTasks[taskId].data[4] < 0) + { + gTasks[taskId].data[4] = var; + gTasks[taskId].data[5] ^= 1; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 2) + DestroyTask(taskId); + } + } + } + else + { + gTasks[taskId].data[2]++; + } +} + +static void sub_80A9E44(struct Sprite *sprite) +{ + if (sprite->data[6] == 0) + { + sprite->invisible = FALSE; + sprite->callback = sub_80A9E78; + sub_80A9E78(sprite); + } + else + { + sprite->data[6]--; + } +} + +static void sub_80A9E78(struct Sprite *sprite) +{ + sprite->pos2.x = Cos(sprite->data[0], 32); + sprite->pos2.y = Sin(sprite->data[0], 8); + if (sprite->data[0] < 128) + sprite->subpriority = 29; + else + sprite->subpriority = 31; + sprite->data[0] = (sprite->data[0] + 8) & 0xFF; + sprite->data[5] += sprite->data[1]; + sprite->pos2.y += sprite->data[5] >> 8; + sprite->data[2]++; + if (sprite->data[2] == 52) + { + if (sprite->data[7]) + DestroySpriteAndFreeResources(sprite); + else + DestroySprite(sprite); + } +} + +void sub_80A9EF4(u8 taskId) +{ + s16 x = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_X_2) - 32; + s16 y = GetBattlerSpriteCoord(gBattleAnimTarget, BATTLER_COORD_3) - 36; + u8 spriteId; + + if (IsContest()) + x -= 6; + SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_ALL); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(0, 16)); + spriteId = CreateSprite(&gUnknown_0853EF48, x, y, 4); + if (GetSpriteTileStartByTag(ANIM_TAG_ICE_CUBE) == 0xFFFF) + gSprites[spriteId].invisible = TRUE; + SetSubspriteTables(&gSprites[spriteId], gUnknown_0853EF40); + gTasks[taskId].data[15] = spriteId; + gTasks[taskId].func = sub_80A9FD0; +} + +static void sub_80A9FD0(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 10) + { + gTasks[taskId].func = sub_80AA020; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_80AA020(u8 taskId) +{ + u8 palIndex = IndexOfSpritePaletteTag(ANIM_TAG_ICE_CUBE); + + if (gTasks[taskId].data[1]++ > 13) + { + gTasks[taskId].data[2]++; + if (gTasks[taskId].data[2] == 3) + { + u16 temp; + + temp = gPlttBufferFaded[0x100 + palIndex * 16 + 13]; + gPlttBufferFaded[0x100 + palIndex * 16 + 13] = gPlttBufferFaded[0x100 + palIndex * 16 + 14]; + gPlttBufferFaded[0x100 + palIndex * 16 + 14] = gPlttBufferFaded[0x100 + palIndex * 16 + 15]; + gPlttBufferFaded[0x100 + palIndex * 16 + 15] = temp; + + gTasks[taskId].data[2] = 0; + gTasks[taskId].data[3]++; + if (gTasks[taskId].data[3] == 3) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] == 2) + { + gTasks[taskId].data[1] = 9; + gTasks[taskId].func = sub_80AA0D0; + } + } + } + } +} + +static void sub_80AA0D0(u8 taskId) +{ + gTasks[taskId].data[1]--; + if (gTasks[taskId].data[1] == -1) + { + gTasks[taskId].func = sub_80AA124; + gTasks[taskId].data[1] = 0; + } + else + { + u8 var = gTasks[taskId].data[1]; + + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(var, 16 - var)); + } +} + +static void sub_80AA124(u8 taskId) +{ + gTasks[taskId].data[1]++; + if (gTasks[taskId].data[1] == 37) + { + u8 spriteId = gTasks[taskId].data[15]; + + FreeSpriteOamMatrix(&gSprites[spriteId]); + DestroySprite(&gSprites[spriteId]); + } + else if (gTasks[taskId].data[1] == 39) + { + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_BLDALPHA, 0); + DestroyAnimVisualTask(taskId); + } +} + +#define CASE(by, stat) case (STAT_ANIM_##by + stat - 1) + +void AnimTask_StatsChange(u8 taskId) +{ + bool16 goesDown = FALSE; + s16 animStatId = 0; + bool16 sharply = FALSE; + + switch (gBattleSpritesDataPtr->animationData->animArg) + { + CASE(PLUS1, STAT_ATK): goesDown = FALSE; animStatId = 0; break; + CASE(PLUS1, STAT_DEF): goesDown = FALSE; animStatId = 1; break; + CASE(PLUS1, STAT_SPEED): goesDown = FALSE; animStatId = 3; break; + CASE(PLUS1, STAT_SPATK): goesDown = FALSE; animStatId = 5; break; + CASE(PLUS1, STAT_SPDEF): goesDown = FALSE; animStatId = 6; break; + CASE(PLUS1, STAT_ACC): goesDown = FALSE; animStatId = 2; break; + CASE(PLUS1, STAT_EVASION): goesDown = FALSE; animStatId = 4; break; + + CASE(MINUS1, STAT_ATK): goesDown = TRUE; animStatId = 0; break; + CASE(MINUS1, STAT_DEF): goesDown = TRUE; animStatId = 1; break; + CASE(MINUS1, STAT_SPEED): goesDown = TRUE; animStatId = 3; break; + CASE(MINUS1, STAT_SPATK): goesDown = TRUE; animStatId = 5; break; + CASE(MINUS1, STAT_SPDEF): goesDown = TRUE; animStatId = 6; break; + CASE(MINUS1, STAT_ACC): goesDown = TRUE; animStatId = 2; break; + CASE(MINUS1, STAT_EVASION): goesDown = TRUE; animStatId = 4; break; + + CASE(PLUS2, STAT_ATK): goesDown = FALSE; animStatId = 0; sharply = TRUE; break; + CASE(PLUS2, STAT_DEF): goesDown = FALSE; animStatId = 1; sharply = TRUE; break; + CASE(PLUS2, STAT_SPEED): goesDown = FALSE; animStatId = 3; sharply = TRUE; break; + CASE(PLUS2, STAT_SPATK): goesDown = FALSE; animStatId = 5; sharply = TRUE; break; + CASE(PLUS2, STAT_SPDEF): goesDown = FALSE; animStatId = 6; sharply = TRUE; break; + CASE(PLUS2, STAT_ACC): goesDown = FALSE; animStatId = 2; sharply = TRUE; break; + CASE(PLUS2, STAT_EVASION): goesDown = FALSE; animStatId = 4; sharply = TRUE; break; + + CASE(MINUS2, STAT_ATK): goesDown = TRUE; animStatId = 0; sharply = TRUE; break; + CASE(MINUS2, STAT_DEF): goesDown = TRUE; animStatId = 1; sharply = TRUE; break; + CASE(MINUS2, STAT_SPEED): goesDown = TRUE; animStatId = 3; sharply = TRUE; break; + CASE(MINUS2, STAT_SPATK): goesDown = TRUE; animStatId = 5; sharply = TRUE; break; + CASE(MINUS2, STAT_SPDEF): goesDown = TRUE; animStatId = 6; sharply = TRUE; break; + CASE(MINUS2, STAT_ACC): goesDown = TRUE; animStatId = 2; sharply = TRUE; break; + CASE(MINUS2, STAT_EVASION): goesDown = TRUE; animStatId = 4; sharply = TRUE; break; + + case STAT_ANIM_MULTIPLE_PLUS1: goesDown = FALSE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_PLUS2: goesDown = FALSE; animStatId = 0xFF; sharply = TRUE; break; + case STAT_ANIM_MULTIPLE_MINUS1: goesDown = TRUE; animStatId = 0xFF; sharply = FALSE; break; + case STAT_ANIM_MULTIPLE_MINUS2: goesDown = TRUE; animStatId = 0xFF; sharply = TRUE; break; + + default: + DestroyAnimVisualTask(taskId); + return; + } + + gBattleAnimArgs[0] = goesDown; + gBattleAnimArgs[1] = animStatId; + gBattleAnimArgs[2] = 0; + gBattleAnimArgs[3] = 0; + gBattleAnimArgs[4] = sharply; + gTasks[taskId].func = sub_8116EB4; + sub_8116EB4(taskId); +} + +#undef CASE + +void LaunchStatusAnimation(u8 battlerId, u8 statusAnimId) +{ + u8 taskId; + + gBattleAnimAttacker = battlerId; + gBattleAnimTarget = battlerId; + LaunchBattleAnimation(gBattleAnims_StatusConditions, statusAnimId, 0); + taskId = CreateTask(Task_DoStatusAnimation, 10); + gTasks[taskId].data[0] = battlerId; +} + +static void Task_DoStatusAnimation(u8 taskId) +{ + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + gBattleSpritesDataPtr->healthBoxesData[gTasks[taskId].data[0]].statusAnimActive = FALSE; + DestroyTask(taskId); + } +} diff --git a/src/battle_anim_80D51AC.c b/src/battle_anim_80D51AC.c new file mode 100644 index 000000000..1864a1a7a --- /dev/null +++ b/src/battle_anim_80D51AC.c @@ -0,0 +1,1004 @@ +#include "global.h" +#include "battle.h" +#include "battle_anim.h" +#include "sprite.h" +#include "task.h" +#include "trig.h" + +// This file's functions. +void AnimTask_ShakeMonStep(u8 taskId); +void AnimTask_ShakeMon2Step(u8 taskId); +void AnimTask_ShakeMonInPlaceStep(u8 taskId); +void AnimTask_ShakeAndSinkMonStep(u8 taskId); +void sub_80D57B8(u8 taskId); +void DoHorizontalLunge(struct Sprite *sprite); +void ReverseHorizontalLungeDirection(struct Sprite *sprite); +void DoVerticalDip(struct Sprite *sprite); +void ReverseVerticalDipDirection(struct Sprite* sprite); +void SlideMonToOriginalPos(struct Sprite *sprite); +void SlideMonToOriginalPosStep(struct Sprite *sprite); +void SlideMonToOffset(struct Sprite *sprite); +void sub_80D5B48(struct Sprite *sprite); +void sub_80D5C20(struct Sprite *sprite); +void AnimTask_WindUpLungePart1(u8 taskId); +void AnimTask_WindUpLungePart2(u8 taskId); +void AnimTask_SwayMonStep(u8 taskId); +void AnimTask_ScaleMonAndRestoreStep(u8 taskId); +void sub_80D6308(u8 taskId); +void sub_80D646C(u8 taskId); +void sub_80A8B3C(u8 taskId); + +// Task to facilitate simple shaking of a pokemon's picture in battle. +// The shaking alternates between the original position and the target position. +// arg 0: anim battler +// arg 1: x pixel offset +// arg 2: y pixel offset +// arg 3: num times to shake +// arg 4: frame delay +void AnimTask_ShakeMon(u8 taskId) +{ + u8 spriteId; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (spriteId == 0xff) + { + DestroyAnimVisualTask(taskId); + return; + } + gSprites[spriteId].pos2.x = gBattleAnimArgs[1]; + gSprites[spriteId].pos2.y = gBattleAnimArgs[2]; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].data[1] = gBattleAnimArgs[3]; + gTasks[taskId].data[2] = gBattleAnimArgs[4]; + gTasks[taskId].data[3] = gBattleAnimArgs[4]; + gTasks[taskId].data[4] = gBattleAnimArgs[1]; + gTasks[taskId].data[5] = gBattleAnimArgs[2]; + gTasks[taskId].func = AnimTask_ShakeMonStep; + AnimTask_ShakeMonStep(taskId); +} + +void AnimTask_ShakeMonStep(u8 taskId) +{ + if (gTasks[taskId].data[3] == 0) + { + if (gSprites[gTasks[taskId].data[0]].pos2.x == 0) + { + gSprites[gTasks[taskId].data[0]].pos2.x = gTasks[taskId].data[4]; + } + else + { + gSprites[gTasks[taskId].data[0]].pos2.x = 0; + } + if (gSprites[gTasks[taskId].data[0]].pos2.y == 0) + { + gSprites[gTasks[taskId].data[0]].pos2.y = gTasks[taskId].data[5]; + } + else + { + gSprites[gTasks[taskId].data[0]].pos2.y = 0; + } + gTasks[taskId].data[3] = gTasks[taskId].data[2]; + if (--gTasks[taskId].data[1] == 0) + { + gSprites[gTasks[taskId].data[0]].pos2.x = 0; + gSprites[gTasks[taskId].data[0]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + return; + } + } + else + { + gTasks[taskId].data[3]--; + } +} + +// Task to facilitate simple shaking of a pokemon's picture in battle. +// The shaking alternates between the positive and negative versions of the specified pixel offsets. +// arg 0: anim battler +// arg 1: x pixel offset +// arg 2: y pixel offset +// arg 3: num times to shake +// arg 4: frame delay +void AnimTask_ShakeMon2(u8 taskId) +{ + u8 spriteId; + bool8 destroy = FALSE; + u8 battlerId; + + if (gBattleAnimArgs[0] < 4) + { + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (spriteId == 0xff) + { + DestroyAnimVisualTask(taskId); + return; + } + } + else if (gBattleAnimArgs[0] != 8) + { + switch (gBattleAnimArgs[0]) + { + case 4: + battlerId = GetBattlerAtPosition(B_POSITION_PLAYER_LEFT); + break; + case 5: + battlerId = GetBattlerAtPosition(B_POSITION_PLAYER_RIGHT); + break; + case 6: + battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_LEFT); + break; + case 7: + default: + battlerId = GetBattlerAtPosition(B_POSITION_OPPONENT_RIGHT); + break; + } + + if (IsBattlerSpriteVisible(battlerId) == FALSE) + destroy = TRUE; + + spriteId = gBattlerSpriteIds[battlerId]; + } + else + { + spriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + } + + if (destroy) + { + DestroyAnimVisualTask(taskId); + return; + } + + gSprites[spriteId].pos2.x = gBattleAnimArgs[1]; + gSprites[spriteId].pos2.y = gBattleAnimArgs[2]; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].data[1] = gBattleAnimArgs[3]; + gTasks[taskId].data[2] = gBattleAnimArgs[4]; + gTasks[taskId].data[3] = gBattleAnimArgs[4]; + gTasks[taskId].data[4] = gBattleAnimArgs[1]; + gTasks[taskId].data[5] = gBattleAnimArgs[2]; + gTasks[taskId].func = AnimTask_ShakeMon2Step; + gTasks[taskId].func(taskId); +} + +void AnimTask_ShakeMon2Step(u8 taskId) +{ + if (gTasks[taskId].data[3] == 0) + { + if (gSprites[gTasks[taskId].data[0]].pos2.x == gTasks[taskId].data[4]) + gSprites[gTasks[taskId].data[0]].pos2.x = -gTasks[taskId].data[4]; + else + gSprites[gTasks[taskId].data[0]].pos2.x = gTasks[taskId].data[4]; + + if (gSprites[gTasks[taskId].data[0]].pos2.y == gTasks[taskId].data[5]) + gSprites[gTasks[taskId].data[0]].pos2.y = -gTasks[taskId].data[5]; + else + gSprites[gTasks[taskId].data[0]].pos2.y = gTasks[taskId].data[5]; + + gTasks[taskId].data[3] = gTasks[taskId].data[2]; + if (--gTasks[taskId].data[1] == 0) + { + gSprites[gTasks[taskId].data[0]].pos2.x = 0; + gSprites[gTasks[taskId].data[0]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + return; + } + } + else + { + gTasks[taskId].data[3]--; + } +} + +// Task to facilitate simple shaking of a pokemon's picture in battle. +// The shaking alternates between the positive and negative versions of the specified pixel offsets +// with respect to the current location of the mon's picture. +// arg 0: battler +// arg 1: x offset +// arg 2: y offset +// arg 3: num shakes +// arg 4: delay +void AnimTask_ShakeMonInPlace(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (spriteId == 0xff) + { + DestroyAnimVisualTask(taskId); + return; + } + + gSprites[spriteId].pos2.x += gBattleAnimArgs[1]; + gSprites[spriteId].pos2.y += gBattleAnimArgs[2]; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[2] = gBattleAnimArgs[3]; + gTasks[taskId].data[3] = 0; + gTasks[taskId].data[4] = gBattleAnimArgs[4]; + gTasks[taskId].data[5] = gBattleAnimArgs[1] * 2; + gTasks[taskId].data[6] = gBattleAnimArgs[2] * 2; + gTasks[taskId].func = AnimTask_ShakeMonInPlaceStep; + gTasks[taskId].func(taskId); +} + +void AnimTask_ShakeMonInPlaceStep(u8 taskId) +{ + if (gTasks[taskId].data[3] == 0) + { + if (gTasks[taskId].data[1] & 1) + { + gSprites[gTasks[taskId].data[0]].pos2.x += gTasks[taskId].data[5]; + gSprites[gTasks[taskId].data[0]].pos2.y += gTasks[taskId].data[6]; + } + else + { + gSprites[gTasks[taskId].data[0]].pos2.x -= gTasks[taskId].data[5]; + gSprites[gTasks[taskId].data[0]].pos2.y -= gTasks[taskId].data[6]; + } + gTasks[taskId].data[3] = gTasks[taskId].data[4]; + if (++gTasks[taskId].data[1] >= gTasks[taskId].data[2]) + { + if (gTasks[taskId].data[1] & 1) + { + gSprites[gTasks[taskId].data[0]].pos2.x += gTasks[taskId].data[5] / 2; + gSprites[gTasks[taskId].data[0]].pos2.y += gTasks[taskId].data[6] / 2; + } + else + { + gSprites[gTasks[taskId].data[0]].pos2.x -= gTasks[taskId].data[5] / 2; + gSprites[gTasks[taskId].data[0]].pos2.y -= gTasks[taskId].data[6] / 2; + } + DestroyAnimVisualTask(taskId); + return; + } + } + else + { + gTasks[taskId].data[3]--; + } +} + +// Shakes a mon bg horizontally and moves it downward linearly. +// arg 0: battler +// arg 1: x offset +// arg 2: frame delay between each movement +// arg 3: downward speed (subpixel) +// arg 4: duration +void AnimTask_ShakeAndSinkMon(u8 taskId) +{ + u8 spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gSprites[spriteId].pos2.x = gBattleAnimArgs[1]; + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + gTasks[taskId].data[4] = gBattleAnimArgs[4]; + gTasks[taskId].func = AnimTask_ShakeAndSinkMonStep; + gTasks[taskId].func(taskId); +} + +void AnimTask_ShakeAndSinkMonStep(u8 taskId) +{ + s16 x; + u8 spriteId; + spriteId = gTasks[taskId].data[0]; + x = gTasks[taskId].data[1]; + if (gTasks[taskId].data[2] == gTasks[taskId].data[8]++) + { + gTasks[taskId].data[8] = 0; + if (gSprites[spriteId].pos2.x == x) + x = -x; + + gSprites[spriteId].pos2.x += x; + } + + gTasks[taskId].data[1] = x; + gTasks[taskId].data[9] += gTasks[taskId].data[3]; + gSprites[spriteId].pos2.y = gTasks[taskId].data[9] >> 8; + if (--gTasks[taskId].data[4] == 0) + { + DestroyAnimVisualTask(taskId); + return; + } +} + +// Moves a mon bg picture along an elliptical path that begins +// and ends at the mon's origin location. +// arg 0: battler +// arg 1: ellipse width +// arg 2: ellipse height +// arg 3: num loops +// arg 4: speed (valid values are 0-5) +void AnimTask_TranslateMonElliptical(u8 taskId) +{ + u8 i; + u8 spriteId; + u8 wavePeriod; + + wavePeriod = 1; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + if (gBattleAnimArgs[4] > 5) + gBattleAnimArgs[4] = 5; + + for (i = 0; i < gBattleAnimArgs[4]; i++) + { + wavePeriod <<= 1; + } + + gTasks[taskId].data[0] = spriteId; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + gTasks[taskId].data[4] = wavePeriod; + gTasks[taskId].func = sub_80D57B8; + gTasks[taskId].func(taskId); +} + +void sub_80D57B8(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + gSprites[spriteId].pos2.x = Sin(gTasks[taskId].data[5], gTasks[taskId].data[1]); + gSprites[spriteId].pos2.y = -Cos(gTasks[taskId].data[5], gTasks[taskId].data[2]); + gSprites[spriteId].pos2.y += gTasks[taskId].data[2]; + gTasks[taskId].data[5] += gTasks[taskId].data[4]; + gTasks[taskId].data[5] &= 0xff; + + if (gTasks[taskId].data[5] == 0) + gTasks[taskId].data[3]--; + + if (gTasks[taskId].data[3] == 0) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + return; + } +} + +// Moves a mon bg picture along an elliptical path that begins +// and ends at the mon's origin location. Reverses the direction +// of the path if it's not on the player's side of the battle. +// arg 0: battler +// arg 1: ellipse width +// arg 2: ellipse height +// arg 3: num loops +// arg 4: speed (valid values are 0-5) +void AnimTask_TranslateMonEllipticalRespectSide(u8 taskId) +{ + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + + AnimTask_TranslateMonElliptical(taskId); +} + +// Performs a simple horizontal lunge, where the mon moves +// horizontally, and then moves back in the opposite direction. +// arg 0: duration of single lunge direction +// arg 1: x pixel delta that is applied each frame +void DoHorizontalLunge(struct Sprite *sprite) +{ + sprite->invisible = TRUE; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + sprite->data[1] = -gBattleAnimArgs[1]; + else + sprite->data[1] = gBattleAnimArgs[1]; + + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[2] = 0; + sprite->data[3] = gBattlerSpriteIds[gBattleAnimAttacker]; + sprite->data[4] = gBattleAnimArgs[0]; + StoreSpriteCallbackInData6(sprite, ReverseHorizontalLungeDirection); + sprite->callback = sub_80A6630; +} + +void ReverseHorizontalLungeDirection(struct Sprite *sprite) +{ + sprite->data[0] = sprite->data[4]; + sprite->data[1] = -sprite->data[1]; + sprite->callback = sub_80A6630; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Performs a simple vertical dipping motion, where moves vertically, and then +// moves back in the opposite direction. +// arg 0: duration of single dip direction +// arg 1: y pixel delta that is applied each frame +// arg 2: battler +void DoVerticalDip(struct Sprite *sprite) +{ + u8 spriteId; + sprite->invisible = TRUE; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + sprite->data[0] = gBattleAnimArgs[0]; + sprite->data[1] = 0; + sprite->data[2] = gBattleAnimArgs[1]; + sprite->data[3] = spriteId; + sprite->data[4] = gBattleAnimArgs[0]; + StoreSpriteCallbackInData6(sprite, ReverseVerticalDipDirection); + sprite->callback = sub_80A6630; +} + +void ReverseVerticalDipDirection(struct Sprite *sprite) +{ + sprite->data[0] = sprite->data[4]; + sprite->data[2] = -sprite->data[2]; + sprite->callback = sub_80A6630; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); +} + +// Linearly slides a mon's bg picture back to its original sprite position. +// The sprite parameter is a dummy sprite used for facilitating the movement with its callback. +// arg 0: 1 = target or 0 = attacker +// arg 1: direction (0 = horizontal and vertical, 1 = horizontal only, 2 = vertical only) +// arg 2: duration +void SlideMonToOriginalPos(struct Sprite *sprite) +{ + u32 monSpriteId; + if (!gBattleAnimArgs[0]) + monSpriteId = gBattlerSpriteIds[gBattleAnimAttacker]; + else + monSpriteId = gBattlerSpriteIds[gBattleAnimTarget]; + + sprite->data[0] = gBattleAnimArgs[2]; + sprite->data[1] = gSprites[monSpriteId].pos1.x + gSprites[monSpriteId].pos2.x; + sprite->data[2] = gSprites[monSpriteId].pos1.x; + sprite->data[3] = gSprites[monSpriteId].pos1.y + gSprites[monSpriteId].pos2.y; + sprite->data[4] = gSprites[monSpriteId].pos1.y; + sub_80A6E14(sprite); + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = gSprites[monSpriteId].pos2.x; + sprite->data[6] = gSprites[monSpriteId].pos2.y; + sprite->invisible = TRUE; + + if (gBattleAnimArgs[1] == 1) + sprite->data[2] = 0; + else if (gBattleAnimArgs[1] == 2) + sprite->data[1] = 0; + + sprite->data[7] = gBattleAnimArgs[1]; + sprite->data[7] |= monSpriteId << 8; + sprite->callback = SlideMonToOriginalPosStep; +} + +void SlideMonToOriginalPosStep(struct Sprite *sprite) +{ + s8 monSpriteId; + u8 lo; + struct Sprite *monSprite; + + lo = sprite->data[7] & 0xff; + monSpriteId = sprite->data[7] >> 8; + monSprite = &gSprites[monSpriteId]; + if (sprite->data[0] == 0) + { + if (lo < 2) + monSprite->pos2.x = 0; + + if (lo == 2 || lo == 0) + monSprite->pos2.y = 0; + + DestroyAnimSprite(sprite); + } + else + { + sprite->data[0]--; + sprite->data[3] += sprite->data[1]; + sprite->data[4] += sprite->data[2]; + monSprite->pos2.x = (s8)(sprite->data[3] >> 8) + sprite->data[5]; + monSprite->pos2.y = (s8)(sprite->data[4] >> 8) + sprite->data[6]; + } +} + +// Linearly translates a mon to a target offset. The horizontal offset +// is mirrored for the opponent's pokemon, and the vertical offset +// is only mirrored if arg 3 is set to 1. +// arg 0: 0 = attacker, 1 = target +// arg 1: target x pixel offset +// arg 2: target y pixel offset +// arg 3: mirror vertical translation for opposite battle side +// arg 4: duration +void SlideMonToOffset(struct Sprite *sprite) +{ + u8 battler; + u8 monSpriteId; + if (!gBattleAnimArgs[0]) + battler = gBattleAnimAttacker; + else + battler = gBattleAnimTarget; + + monSpriteId = gBattlerSpriteIds[battler]; + if (GetBattlerSide(battler) != B_SIDE_PLAYER) + { + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + if (gBattleAnimArgs[3] == 1) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + } + } + + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[1] = gSprites[monSpriteId].pos1.x; + sprite->data[2] = gSprites[monSpriteId].pos1.x + gBattleAnimArgs[1]; + sprite->data[3] = gSprites[monSpriteId].pos1.y; + sprite->data[4] = gSprites[monSpriteId].pos1.y + gBattleAnimArgs[2]; + sub_80A6E14(sprite); + sprite->data[3] = 0; + sprite->data[4] = 0; + sprite->data[5] = monSpriteId; + sprite->invisible = TRUE; + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + sprite->callback = sub_80A6680; +} + +void sub_80D5B48(struct Sprite *sprite) +{ + u8 spriteId; + u8 battlerId; + sprite->invisible = TRUE; + if (!gBattleAnimArgs[0]) + { + battlerId = gBattleAnimAttacker; + } + else + { + battlerId = gBattleAnimTarget; + } + spriteId = gBattlerSpriteIds[battlerId]; + if (GetBattlerSide(battlerId)) + { + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + if (gBattleAnimArgs[3] == 1) + { + gBattleAnimArgs[2] = -gBattleAnimArgs[2]; + } + } + sprite->data[0] = gBattleAnimArgs[4]; + sprite->data[1] = gSprites[spriteId].pos1.x + gSprites[spriteId].pos2.x; + sprite->data[2] = sprite->data[1] + gBattleAnimArgs[1]; + sprite->data[3] = gSprites[spriteId].pos1.y + gSprites[spriteId].pos2.y; + sprite->data[4] = sprite->data[3] + gBattleAnimArgs[2]; + sub_80A6E14(sprite); + sprite->data[3] = gSprites[spriteId].pos2.x << 8; + sprite->data[4] = gSprites[spriteId].pos2.y << 8; + sprite->data[5] = spriteId; + sprite->data[6] = gBattleAnimArgs[5]; + if (!gBattleAnimArgs[5]) + { + StoreSpriteCallbackInData6(sprite, DestroyAnimSprite); + } + else + { + StoreSpriteCallbackInData6(sprite, sub_80D5C20); + } + sprite->callback = sub_80A6680; +} + + +void sub_80D5C20(struct Sprite *sprite) +{ + gSprites[sprite->data[5]].pos2.x = 0; + gSprites[sprite->data[5]].pos2.y = 0; + DestroyAnimSprite(sprite); +} + +// Task to facilitate a two-part translation animation, in which the sprite +// is first translated in an arc to one position. Then, it "lunges" to a target +// x offset. Used in TAKE_DOWN, for example. +// arg 0: anim bank +// arg 1: horizontal speed (subpixel) +// arg 2: wave amplitude +// arg 3: first duration +// arg 4: delay before starting lunge +// arg 5: target x offset for lunge +// arg 6: lunge duration +void AnimTask_WindUpLunge(u8 taskId) +{ + s16 wavePeriod = 0x8000 / gBattleAnimArgs[3]; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + { + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + gBattleAnimArgs[5] = -gBattleAnimArgs[5]; + } + gTasks[taskId].data[0] = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + gTasks[taskId].data[1] = (gBattleAnimArgs[1] << 8) / gBattleAnimArgs[3]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + gTasks[taskId].data[4] = gBattleAnimArgs[4]; + gTasks[taskId].data[5] = (gBattleAnimArgs[5] << 8) / gBattleAnimArgs[6]; + gTasks[taskId].data[6] = gBattleAnimArgs[6]; + gTasks[taskId].data[7] = wavePeriod; + gTasks[taskId].func = AnimTask_WindUpLungePart1; +} + +void AnimTask_WindUpLungePart1(u8 taskId) +{ + u8 spriteId; + spriteId = gTasks[taskId].data[0]; + gTasks[taskId].data[11] += gTasks[taskId].data[1]; + gSprites[spriteId].pos2.x = gTasks[taskId].data[11] >> 8; + gSprites[spriteId].pos2.y = Sin((u8)(gTasks[taskId].data[10] >> 8), gTasks[taskId].data[2]); + gTasks[taskId].data[10] += gTasks[taskId].data[7]; + if (--gTasks[taskId].data[3] == 0) + { + gTasks[taskId].func = AnimTask_WindUpLungePart2; + } +} + +void AnimTask_WindUpLungePart2(u8 taskId) +{ + u8 spriteId; + if (gTasks[taskId].data[4] > 0) + { + gTasks[taskId].data[4]--; + } + else + { + spriteId = gTasks[taskId].data[0]; + gTasks[taskId].data[12] += gTasks[taskId].data[5]; + gSprites[spriteId].pos2.x = (gTasks[taskId].data[12] >> 8) + (gTasks[taskId].data[11] >> 8); + if (--gTasks[taskId].data[6] == 0) + { + DestroyAnimVisualTask(taskId); + return; + } + } +} + +void sub_80D5DB0(u8 taskId) +{ + u8 spriteId; + switch (gBattleAnimArgs[0]) + { + case 0: + case 1: + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[0]); + break; + case 2: + if (!IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimAttacker))) + { + DestroyAnimVisualTask(taskId); + return; + } + spriteId = gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimAttacker)]; + break; + case 3: + if (!IsBattlerSpriteVisible(BATTLE_PARTNER(gBattleAnimTarget))) + { + DestroyAnimVisualTask(taskId); + return; + } + spriteId = gBattlerSpriteIds[BATTLE_PARTNER(gBattleAnimTarget)]; + break; + default: + DestroyAnimVisualTask(taskId); + return; + } + gTasks[taskId].data[0] = spriteId; + if (GetBattlerSide(gBattleAnimTarget) != B_SIDE_PLAYER) + { + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + } + else + { + gTasks[taskId].data[1] = -gBattleAnimArgs[1]; + } + gTasks[taskId].func = sub_80A8B3C; +} + +void sub_80A8B3C(u8 taskId) +{ + u8 spriteId = gTasks[taskId].data[0]; + gSprites[spriteId].pos2.x += gTasks[taskId].data[1]; + if (gSprites[spriteId].pos2.x + gSprites[spriteId].pos1.x + 0x20 > 0x130u) + { + DestroyAnimVisualTask(taskId); + return; + } +} + +// Task that facilitates translating the mon bg picture back and forth +// in a swaying motion (uses Sine wave). It can sway either horizontally +// or vertically, but not both. +// arg 0: direction (0 = horizontal, 1 = vertical) +// arg 1: wave amplitude +// arg 2: wave period +// arg 3: num sways +// arg 4: which mon (0 = attacker, 1`= target) +void AnimTask_SwayMon(u8 taskId) +{ + u8 spriteId; + if (GetBattlerSide(gBattleAnimAttacker) != B_SIDE_PLAYER) + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[4]); + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].data[3] = gBattleAnimArgs[3]; + gTasks[taskId].data[4] = spriteId; + + if (gBattleAnimArgs[4] == 0) + gTasks[taskId].data[5] = gBattleAnimAttacker; + else + gTasks[taskId].data[5] = gBattleAnimTarget; + + gTasks[taskId].data[12] = 1; + gTasks[taskId].func = AnimTask_SwayMonStep; +} + +void AnimTask_SwayMonStep(u8 taskId) +{ + s16 sineValue; + u8 spriteId; + int waveIndex; + u16 sineIndex; + + spriteId = gTasks[taskId].data[4]; + sineIndex = gTasks[taskId].data[10] + gTasks[taskId].data[2]; + gTasks[taskId].data[10] = sineIndex; + waveIndex = sineIndex >> 8; + sineValue = Sin(waveIndex, gTasks[taskId].data[1]); + + if (gTasks[taskId].data[0] == 0) + { + gSprites[spriteId].pos2.x = sineValue; + } + else + { + if (GetBattlerSide(gTasks[taskId].data[5]) == B_SIDE_PLAYER) + { + gSprites[spriteId].pos2.y = (sineValue >= 0) ? sineValue : -sineValue; + } + else + { + gSprites[spriteId].pos2.y = (sineValue >= 0) ? -sineValue : sineValue; + } + } + + if (((waveIndex >= 0x80u) && (gTasks[taskId].data[11] == 0) && (gTasks[taskId].data[12] == 1)) + || ((waveIndex < 0x7fu) && (gTasks[taskId].data[11] == 1) && (gTasks[taskId].data[12] == 0))) + { + gTasks[taskId].data[11] ^= 1; + gTasks[taskId].data[12] ^= 1; + if (--gTasks[taskId].data[3] == 0) + { + gSprites[spriteId].pos2.x = 0; + gSprites[spriteId].pos2.y = 0; + DestroyAnimVisualTask(taskId); + return; + } + } +} + +// Scales a mon's sprite, and then scales back to its original dimensions. +// arg 0: x scale delta +// arg 1: y scale delta +// arg 2: duration +// arg 3: anim bank +// arg 4: sprite object mode +void AnimTask_ScaleMonAndRestore(u8 taskId) +{ + u8 spriteId; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[3]); + sub_80A7270(spriteId, gBattleAnimArgs[4]); + gTasks[taskId].data[0] = gBattleAnimArgs[0]; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].data[3] = gBattleAnimArgs[2]; + gTasks[taskId].data[4] = spriteId; + gTasks[taskId].data[10] = 0x100; + gTasks[taskId].data[11] = 0x100; + gTasks[taskId].func = AnimTask_ScaleMonAndRestoreStep; +} + +void AnimTask_ScaleMonAndRestoreStep(u8 taskId) +{ + u8 spriteId; + gTasks[taskId].data[10] += gTasks[taskId].data[0]; + gTasks[taskId].data[11] += gTasks[taskId].data[1]; + spriteId = gTasks[taskId].data[4]; + obj_id_set_rotscale(spriteId, gTasks[taskId].data[10], gTasks[taskId].data[11], 0); + if (--gTasks[taskId].data[2] == 0) + { + if (gTasks[taskId].data[3] > 0) + { + gTasks[taskId].data[0] = -gTasks[taskId].data[0]; + gTasks[taskId].data[1] = -gTasks[taskId].data[1]; + gTasks[taskId].data[2] = gTasks[taskId].data[3]; + gTasks[taskId].data[3] = 0; + } + else + { + sub_80A7344(spriteId); + DestroyAnimVisualTask(taskId); + return; + } + } +} + +void sub_80D6134(u8 taskId) +{ + u8 spriteId; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + sub_80A7270(spriteId, 0); + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[2] = gBattleAnimArgs[0]; + if (gBattleAnimArgs[3] != 1) + { + gTasks[taskId].data[3] = 0; + } + else + { + gTasks[taskId].data[3] = gBattleAnimArgs[0] * gBattleAnimArgs[1]; + } + gTasks[taskId].data[4] = gBattleAnimArgs[1]; + gTasks[taskId].data[5] = spriteId; + gTasks[taskId].data[6] = gBattleAnimArgs[3]; + if (IsContest()) + { + gTasks[taskId].data[7] = 1; + } + else + { + if (gBattleAnimArgs[2] == 0) + { + gTasks[taskId].data[7] = !GetBattlerSide(gBattleAnimAttacker); + } + else + { + gTasks[taskId].data[7] = !GetBattlerSide(gBattleAnimTarget); + } + } + if (gTasks[taskId].data[7]) + { + if (!IsContest()) + { + gTasks[taskId].data[3] *= -1; + gTasks[taskId].data[4] *= -1; + } + } + gTasks[taskId].func = sub_80D6308; +} + +void sub_80D622C(u8 taskId) +{ + u8 spriteId; + spriteId = GetAnimBattlerSpriteId(gBattleAnimArgs[2]); + sub_80A7270(spriteId, 0); + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[2] = gBattleAnimArgs[0]; + if (gBattleAnimArgs[2] == 0) + { + if (GetBattlerSide(gBattleAnimAttacker)) + { + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + } + } + else + { + if (GetBattlerSide(gBattleAnimTarget)) + { + gBattleAnimArgs[1] = -gBattleAnimArgs[1]; + } + } + if (gBattleAnimArgs[3] != 1) + { + gTasks[taskId].data[3] = 0; + } + else + { + gTasks[taskId].data[3] = gBattleAnimArgs[0] * gBattleAnimArgs[1]; + } + gTasks[taskId].data[4] = gBattleAnimArgs[1]; + gTasks[taskId].data[5] = spriteId; + gTasks[taskId].data[6] = gBattleAnimArgs[3]; + gTasks[taskId].data[7] = 1; + gTasks[taskId].data[3] *= -1; + gTasks[taskId].data[4] *= -1; + gTasks[taskId].func = sub_80D6308; +} + +void sub_80D6308(u8 taskId) +{ + gTasks[taskId].data[3] += gTasks[taskId].data[4]; + obj_id_set_rotscale(gTasks[taskId].data[5], 0x100, 0x100, gTasks[taskId].data[3]); + if (gTasks[taskId].data[7]) + { + sub_80A73A0(gTasks[taskId].data[5]); + } + if (++gTasks[taskId].data[1] >= gTasks[taskId].data[2]) + { + switch (gTasks[taskId].data[6]) + { + case 1: + sub_80A7344(gTasks[taskId].data[5]); + case 0: + default: + DestroyAnimVisualTask(taskId); + return; + case 2: + gTasks[taskId].data[1] = 0; + gTasks[taskId].data[4] *= -1; + gTasks[taskId].data[6] = 1; + break; + } + } +} + +void sub_80D6388(u8 taskId) +{ + if (!gBattleAnimArgs[0]) + { + gTasks[taskId].data[15] = gAnimMovePower / 12; + if (gTasks[taskId].data[15] < 1) + { + gTasks[taskId].data[15] = 1; + } + if (gTasks[taskId].data[15] > 16) + { + gTasks[taskId].data[15] = 16; + } + } + else + { + gTasks[taskId].data[15] = gAnimMoveDmg / 12; + if (gTasks[taskId].data[15] < 1) + { + gTasks[taskId].data[15] = 1; + } + if (gTasks[taskId].data[15] > 16) + { + gTasks[taskId].data[15] = 16; + } + } + gTasks[taskId].data[14] = gTasks[taskId].data[15] / 2; + gTasks[taskId].data[13] = gTasks[taskId].data[14] + (gTasks[taskId].data[15] & 1); + gTasks[taskId].data[12] = 0; + gTasks[taskId].data[10] = gBattleAnimArgs[3]; + gTasks[taskId].data[11] = gBattleAnimArgs[4]; + gTasks[taskId].data[7] = GetAnimBattlerSpriteId(1); + gTasks[taskId].data[8] = gSprites[gTasks[taskId].data[7]].pos2.x; + gTasks[taskId].data[9] = gSprites[gTasks[taskId].data[7]].pos2.y; + gTasks[taskId].data[0] = 0; + gTasks[taskId].data[1] = gBattleAnimArgs[1]; + gTasks[taskId].data[2] = gBattleAnimArgs[2]; + gTasks[taskId].func = sub_80D646C; +} + +void sub_80D646C(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + if (++task->data[0] > task->data[1]) + { + task->data[0] = 0; + task->data[12] = (task->data[12] + 1) & 1; + if (task->data[10]) + { + if (task->data[12]) + { + gSprites[task->data[7]].pos2.x = task->data[8] + task->data[13]; + } + else + { + gSprites[task->data[7]].pos2.x = task->data[8] - task->data[14]; + } + } + if (task->data[11]) + { + if (task->data[12]) + { + gSprites[task->data[7]].pos2.y = task->data[15]; + } + else + { + gSprites[task->data[7]].pos2.y = 0; + } + } + if (!--task->data[2]) + { + gSprites[task->data[7]].pos2.x = 0; + gSprites[task->data[7]].pos2.y = 0; + DestroyAnimVisualTask(taskId); + return; + } + } +} diff --git a/src/battle_anim_sound_tasks.c b/src/battle_anim_sound_tasks.c index 5a829171e..6993bd2ee 100644 --- a/src/battle_anim_sound_tasks.c +++ b/src/battle_anim_sound_tasks.c @@ -131,7 +131,7 @@ void sub_8158D8C(u8 taskId) if (IsContest()) { if (gBattleAnimArgs[0] == ANIM_ATTACKER) - species = gContestResources->field_18->field_0; + species = gContestResources->field_18->unk0; else DestroyAnimVisualTask(taskId); // UB: function should return upon destroying task. } @@ -177,7 +177,7 @@ void sub_8158E9C(u8 taskId) if (IsContest()) { if (gBattleAnimArgs[0] == ANIM_ATTACKER) - species = gContestResources->field_18->field_0; + species = gContestResources->field_18->unk0; else DestroyAnimVisualTask(taskId); // UB: function should return upon destroying task. } @@ -281,7 +281,7 @@ void sub_81590B8(u8 taskId) pan = BattleAnimAdjustPanning(PAN_SIDE_PLAYER); if (IsContest()) - species = gContestResources->field_18->field_0; + species = gContestResources->field_18->unk0; else species = gAnimBattlerSpecies[gBattleAnimAttacker]; diff --git a/src/battle_controllers.c b/src/battle_controllers.c index 63154ae8b..56ff34528 100644 --- a/src/battle_controllers.c +++ b/src/battle_controllers.c @@ -1,6 +1,7 @@ #include "global.h" #include "battle.h" #include "battle_controllers.h" +#include "cable_club.h" #include "link.h" #include "task.h" #include "battle_ai_script_commands.h" @@ -18,7 +19,6 @@ extern u8 gUnknown_02022D0A; static EWRAM_DATA u8 sBattleBuffersTransferData[0x100] = {}; -extern void task00_08081A90(u8 taskId); // cable_club extern void sub_81B8D64(u8 battlerId, u8 arg1); // party_menu // this file's funcionts diff --git a/src/battle_dome.c b/src/battle_dome.c index 82384b43a..8de1c058c 100644 --- a/src/battle_dome.c +++ b/src/battle_dome.c @@ -68,7 +68,7 @@ extern bool8 sub_81A3610(void); extern u16 sub_81A4FF0(u8); extern u8 GetFrontierTrainerFrontSpriteId(u16); extern u8 GetFrontierOpponentClass(u16); -extern void sub_80F94E8(void); +extern void ReducePlayerPartyToThree(void); extern u8 gUnknown_0203CEF8[]; extern u16 gBattle_BG0_X; @@ -6132,7 +6132,7 @@ static void sub_8194E44(void) static void sub_8194EB4(void) { - sub_80F94E8(); + ReducePlayerPartyToThree(); } static void sub_8194EC0(void) diff --git a/src/battle_factory.c b/src/battle_factory.c index 36c5ed2e8..2c8ab1052 100644 --- a/src/battle_factory.c +++ b/src/battle_factory.c @@ -20,7 +20,7 @@ #include "pokemon_summary_screen.h" #include "sound.h" #include "pokedex.h" -#include "blend_palette.h" +#include "util.h" #include "trainer_pokemon_sprites.h" #include "constants/battle_frontier.h" #include "constants/songs.h" diff --git a/src/battle_gfx_sfx_util.c b/src/battle_gfx_sfx_util.c index b4dcf586d..05958395d 100644 --- a/src/battle_gfx_sfx_util.c +++ b/src/battle_gfx_sfx_util.c @@ -19,7 +19,6 @@ #include "decompress.h" #include "data2.h" #include "palette.h" -#include "blend_palette.h" #include "contest.h" #include "constants/songs.h" #include "constants/rgb.h" @@ -29,7 +28,7 @@ extern struct MusicPlayerInfo gMPlayInfo_SE2; extern struct MusicPlayerInfo gMPlayInfo_BGM; extern const u8 gUnknown_0831C604[]; -extern const u8 * const gBattleAnims_VariousTable[]; +extern const u8 * const gBattleAnims_General[]; extern const u8 * const gBattleAnims_Special[]; extern const struct CompressedSpriteSheet gMonFrontPicTable[]; extern const struct CompressedSpriteSheet gMonBackPicTable[]; @@ -437,7 +436,7 @@ bool8 TryHandleLaunchBattleTableAnimation(u8 activeBattler, u8 atkBattler, u8 de gBattleAnimAttacker = atkBattler; gBattleAnimTarget = defBattler; gBattleSpritesDataPtr->animationData->animArg = argument; - LaunchBattleAnimation(gBattleAnims_VariousTable, tableId, FALSE); + LaunchBattleAnimation(gBattleAnims_General, tableId, FALSE); taskId = CreateTask(Task_ClearBitWhenBattleTableAnimDone, 10); gTasks[taskId].tBattlerId = activeBattler; gBattleSpritesDataPtr->healthBoxesData[gTasks[taskId].tBattlerId].animFromTableActive = 1; @@ -899,14 +898,14 @@ void HandleSpeciesGfxDataChange(u8 battlerAtk, u8 battlerDef, bool8 notTransform if (IsContest()) { position = 0; - targetSpecies = gContestResources->field_18->field_2; - personalityValue = gContestResources->field_18->field_8; - otId = gContestResources->field_18->field_C; + targetSpecies = gContestResources->field_18->unk2; + personalityValue = gContestResources->field_18->unk8; + otId = gContestResources->field_18->unkC; HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[targetSpecies], gMonSpritesGfxPtr->sprites[0], targetSpecies, - gContestResources->field_18->field_10); + gContestResources->field_18->unk10); } else { diff --git a/src/battle_main.c b/src/battle_main.c index 8f5d39055..80ee5c425 100644 --- a/src/battle_main.c +++ b/src/battle_main.c @@ -3061,14 +3061,14 @@ static void BattleStartClearSetData(void) for (i = 0; i < 8; i++) { - *((u8 *)gBattleStruct->mirrorMoves + i) = 0; + *((u8 *)gBattleStruct->lastTakenMove + i) = 0; *((u8 *)gBattleStruct->usedHeldItems + i) = 0; *((u8 *)gBattleStruct->choicedMove + i) = 0; *((u8 *)gBattleStruct->changedItems + i) = 0; - *(i + 0 * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(i + 1 * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(i + 2 * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(i + 3 * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; + *(i + 0 * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(i + 1 * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(i + 2 * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(i + 3 * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; } for (i = 0; i < MAX_BATTLERS_COUNT; i++) @@ -3153,8 +3153,8 @@ void SwitchInClearSetData(void) { gDisableStructs[gActiveBattler].substituteHP = disableStructCopy.substituteHP; gDisableStructs[gActiveBattler].battlerWithSureHit = disableStructCopy.battlerWithSureHit; - gDisableStructs[gActiveBattler].perishSongTimer1 = disableStructCopy.perishSongTimer1; - gDisableStructs[gActiveBattler].perishSongTimer2 = disableStructCopy.perishSongTimer2; + gDisableStructs[gActiveBattler].perishSongTimer = disableStructCopy.perishSongTimer; + gDisableStructs[gActiveBattler].perishSongTimerStartValue = disableStructCopy.perishSongTimerStartValue; gDisableStructs[gActiveBattler].battlerPreventingEscape = disableStructCopy.battlerPreventingEscape; } @@ -3168,16 +3168,16 @@ void SwitchInClearSetData(void) gLastPrintedMoves[gActiveBattler] = 0; gLastHitBy[gActiveBattler] = 0xFF; - *(gBattleStruct->mirrorMoves + gActiveBattler * 2 + 0) = 0; - *(gBattleStruct->mirrorMoves + gActiveBattler * 2 + 1) = 0; - *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; + *(gBattleStruct->lastTakenMove + gActiveBattler * 2 + 0) = 0; + *(gBattleStruct->lastTakenMove + gActiveBattler * 2 + 1) = 0; + *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; gBattleStruct->field_92 &= ~(gBitTable[gActiveBattler]); @@ -3185,11 +3185,11 @@ void SwitchInClearSetData(void) { if (i != gActiveBattler && GetBattlerSide(i) != GetBattlerSide(gActiveBattler)) { - *(gBattleStruct->mirrorMoves + i * 2 + 0) = 0; - *(gBattleStruct->mirrorMoves + i * 2 + 1) = 0; + *(gBattleStruct->lastTakenMove + i * 2 + 0) = 0; + *(gBattleStruct->lastTakenMove + i * 2 + 1) = 0; } - *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; + *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; } *(u8*)((u8*)(&gBattleStruct->choicedMove[gActiveBattler]) + 0) = 0; @@ -3263,16 +3263,16 @@ void FaintClearSetData(void) *(u8*)((u8*)(&gBattleStruct->choicedMove[gActiveBattler]) + 0) = 0; *(u8*)((u8*)(&gBattleStruct->choicedMove[gActiveBattler]) + 1) = 0; - *(gBattleStruct->mirrorMoves + gActiveBattler * 2 + 0) = 0; - *(gBattleStruct->mirrorMoves + gActiveBattler * 2 + 1) = 0; - *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; - *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; + *(gBattleStruct->lastTakenMove + gActiveBattler * 2 + 0) = 0; + *(gBattleStruct->lastTakenMove + gActiveBattler * 2 + 1) = 0; + *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(0 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(1 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(2 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; + *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(3 * 2 + gActiveBattler * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; gBattleStruct->field_92 &= ~(gBitTable[gActiveBattler]); @@ -3280,11 +3280,11 @@ void FaintClearSetData(void) { if (i != gActiveBattler && GetBattlerSide(i) != GetBattlerSide(gActiveBattler)) { - *(gBattleStruct->mirrorMoves + i * 2 + 0) = 0; - *(gBattleStruct->mirrorMoves + i * 2 + 1) = 0; + *(gBattleStruct->lastTakenMove + i * 2 + 0) = 0; + *(gBattleStruct->lastTakenMove + i * 2 + 1) = 0; } - *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = 0; - *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = 0; + *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = 0; + *(i * 8 + gActiveBattler * 2 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = 0; } gBattleResources->flags->flags[gActiveBattler] = 0; @@ -4879,10 +4879,10 @@ static void TurnValuesCleanUp(bool8 var0) if (gDisableStructs[gActiveBattler].isFirstTurn) gDisableStructs[gActiveBattler].isFirstTurn--; - if (gDisableStructs[gActiveBattler].rechargeCounter) + if (gDisableStructs[gActiveBattler].rechargeTimer) { - gDisableStructs[gActiveBattler].rechargeCounter--; - if (gDisableStructs[gActiveBattler].rechargeCounter == 0) + gDisableStructs[gActiveBattler].rechargeTimer--; + if (gDisableStructs[gActiveBattler].rechargeTimer == 0) gBattleMons[gActiveBattler].status2 &= ~(STATUS2_RECHARGE); } } @@ -5318,7 +5318,7 @@ static void HandleAction_UseMove(void) gCurrentMove = gChosenMove = gBattleMons[gBattlerAttacker].moves[gCurrMovePos]; gDisableStructs[gBattlerAttacker].encoredMove = MOVE_NONE; gDisableStructs[gBattlerAttacker].encoredMovePos = 0; - gDisableStructs[gBattlerAttacker].encoreTimer1 = 0; + gDisableStructs[gBattlerAttacker].encoreTimer = 0; *(gBattleStruct->moveTarget + gBattlerAttacker) = GetMoveTarget(gCurrentMove, 0); } else if (gBattleMons[gBattlerAttacker].moves[gCurrMovePos] != gChosenMoveByBattler[gBattlerAttacker]) diff --git a/src/battle_pyramid_bag.c b/src/battle_pyramid_bag.c index 74a4d3f83..e8ff7cce7 100644 --- a/src/battle_pyramid_bag.c +++ b/src/battle_pyramid_bag.c @@ -396,7 +396,7 @@ void sub_81C4F98(u8 a0, void (*callback)(void)) gPyramidBagResources->callback2 = NULL; gPyramidBagResources->unk814 = 0xFF; - gPyramidBagResources->scrollArrowSpriteId = 0xFF; + gPyramidBagResources->scrollIndicatorsTaskId = 0xFF; memset(gPyramidBagResources->itemsSpriteIds, 0xFF, sizeof(gPyramidBagResources->itemsSpriteIds)); memset(gPyramidBagResources->windowIds, 0xFF, sizeof(gPyramidBagResources->windowIds)); @@ -664,16 +664,16 @@ static void PrintItemDescription(s32 listMenuId) static void AddScrollArrow(void) { - if (gPyramidBagResources->scrollArrowSpriteId == 0xFF) - gPyramidBagResources->scrollArrowSpriteId = AddScrollIndicatorArrowPairParameterized(2, 172, 12, 148, gPyramidBagResources->listMenuCount - gPyramidBagResources->listMenuMaxShown, 0xB5E, 0xB5E, &gPyramidBagCursorData.scrollPosition); + if (gPyramidBagResources->scrollIndicatorsTaskId == 0xFF) + gPyramidBagResources->scrollIndicatorsTaskId = AddScrollIndicatorArrowPairParameterized(2, 172, 12, 148, gPyramidBagResources->listMenuCount - gPyramidBagResources->listMenuMaxShown, 0xB5E, 0xB5E, &gPyramidBagCursorData.scrollPosition); } static void RemoveScrollArrow(void) { - if (gPyramidBagResources->scrollArrowSpriteId != 0xFF) + if (gPyramidBagResources->scrollIndicatorsTaskId != 0xFF) { - RemoveScrollIndicatorArrowPair(gPyramidBagResources->scrollArrowSpriteId); - gPyramidBagResources->scrollArrowSpriteId = 0xFF; + RemoveScrollIndicatorArrowPair(gPyramidBagResources->scrollIndicatorsTaskId); + gPyramidBagResources->scrollIndicatorsTaskId = 0xFF; } } diff --git a/src/battle_script_commands.c b/src/battle_script_commands.c index 10b432d8e..685f0db7a 100644 --- a/src/battle_script_commands.c +++ b/src/battle_script_commands.c @@ -3,6 +3,7 @@ #include "constants/battle_move_effects.h" #include "constants/battle_script_commands.h" #include "battle_message.h" +#include "battle_anim.h" #include "battle_ai_script_commands.h" #include "battle_scripts.h" #include "constants/moves.h" @@ -1228,7 +1229,7 @@ static void atk03_ppreduce(void) if (gBattleControllerExecFlags) return; - if (!gSpecialStatuses[gBattlerAttacker].flag20) + if (!gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure) { switch (gBattleMoves[gCurrentMove].target) { @@ -1857,7 +1858,7 @@ static void atk0B_healthbarupdate(void) MarkBattlerForControllerExec(gActiveBattler); if (GetBattlerSide(gActiveBattler) == B_SIDE_PLAYER && gBattleMoveDamage > 0) - gBattleResults.unk5_0 = 1; + gBattleResults.playerMonWasDamaged = TRUE; } } @@ -2729,7 +2730,7 @@ void SetMoveEffect(bool8 primary, u8 certain) break; case MOVE_EFFECT_RECHARGE: gBattleMons[gEffectBattler].status2 |= STATUS2_RECHARGE; - gDisableStructs[gEffectBattler].rechargeCounter = 2; + gDisableStructs[gEffectBattler].rechargeTimer = 2; gLockedMoves[gEffectBattler] = gCurrentMove; gBattlescriptCurrInstr++; break; @@ -2762,7 +2763,7 @@ void SetMoveEffect(bool8 primary, u8 certain) | BATTLE_TYPE_LINK | BATTLE_TYPE_x2000000 | BATTLE_TYPE_SECRET_BASE)) - && (gWishFutureKnock.knockedOffPokes[side] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]])) + && (gWishFutureKnock.knockedOffMons[side] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]])) { gBattlescriptCurrInstr++; } @@ -2884,7 +2885,7 @@ void SetMoveEffect(bool8 primary, u8 certain) gLastUsedItem = gBattleMons[gEffectBattler].item; gBattleMons[gEffectBattler].item = 0; - gWishFutureKnock.knockedOffPokes[side] |= gBitTable[gBattlerPartyIndexes[gEffectBattler]]; + gWishFutureKnock.knockedOffMons[side] |= gBitTable[gBattlerPartyIndexes[gEffectBattler]]; BattleScriptPush(gBattlescriptCurrInstr + 1); gBattlescriptCurrInstr = BattleScript_KnockedOff; @@ -4381,16 +4382,16 @@ static void atk47_setgraphicalstatchangevalues(void) switch (GET_STAT_BUFF_VALUE2(gBattleScripting.statChanger)) { case SET_STAT_BUFF_VALUE(1): // +1 - value = 0xF; + value = STAT_ANIM_PLUS1; break; case SET_STAT_BUFF_VALUE(2): // +2 - value = 0x27; + value = STAT_ANIM_PLUS2; break; case SET_STAT_BUFF_VALUE(1) | STAT_BUFF_NEGATIVE: // -1 - value = 0x16; + value = STAT_ANIM_MINUS1; break; case SET_STAT_BUFF_VALUE(2) | STAT_BUFF_NEGATIVE: // -2 - value = 0x2E; + value = STAT_ANIM_MINUS2; break; } gBattleScripting.animArg1 = GET_STAT_BUFF_ID(gBattleScripting.statChanger) + value - 1; @@ -4412,9 +4413,9 @@ static void atk48_playstatchangeanimation(void) { s16 startingStatAnimId; if (gBattlescriptCurrInstr[3] & ATK48_STAT_BY_TWO) - startingStatAnimId = 0x2D; + startingStatAnimId = STAT_ANIM_MINUS2 - 1; else - startingStatAnimId = 0x15; + startingStatAnimId = STAT_ANIM_MINUS1 - 1; while (statsToCheck != 0) { @@ -4447,18 +4448,18 @@ static void atk48_playstatchangeanimation(void) if (changeableStatsCount > 1) // more than one stat, so the color is gray { if (gBattlescriptCurrInstr[3] & ATK48_STAT_BY_TWO) - statAnimId = 0x3A; + statAnimId = STAT_ANIM_MULTIPLE_MINUS2; else - statAnimId = 0x39; + statAnimId = STAT_ANIM_MULTIPLE_MINUS1; } } else // goes up { s16 startingStatAnimId; if (gBattlescriptCurrInstr[3] & ATK48_STAT_BY_TWO) - startingStatAnimId = 0x26; + startingStatAnimId = STAT_ANIM_PLUS2 - 1; else - startingStatAnimId = 0xE; + startingStatAnimId = STAT_ANIM_PLUS1 - 1; while (statsToCheck != 0) { @@ -4473,9 +4474,9 @@ static void atk48_playstatchangeanimation(void) if (changeableStatsCount > 1) // more than one stat, so the color is gray { if (gBattlescriptCurrInstr[3] & ATK48_STAT_BY_TWO) - statAnimId = 0x38; + statAnimId = STAT_ANIM_MULTIPLE_PLUS2; else - statAnimId = 0x37; + statAnimId = STAT_ANIM_MULTIPLE_PLUS1; } } @@ -4751,16 +4752,16 @@ static void atk49_moveend(void) { u8 target, attacker; - *(gBattleStruct->mirrorMoves + gBattlerTarget * 2 + 0) = gChosenMove; - *(gBattleStruct->mirrorMoves + gBattlerTarget * 2 + 1) = gChosenMove >> 8; + *(gBattleStruct->lastTakenMove + gBattlerTarget * 2 + 0) = gChosenMove; + *(gBattleStruct->lastTakenMove + gBattlerTarget * 2 + 1) = gChosenMove >> 8; target = gBattlerTarget; attacker = gBattlerAttacker; - *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) = gChosenMove; + *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) = gChosenMove; target = gBattlerTarget; attacker = gBattlerAttacker; - *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) = gChosenMove >> 8; + *(attacker * 2 + target * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) = gChosenMove >> 8; } gBattleScripting.atk49_state++; break; @@ -4947,7 +4948,7 @@ static void atk4D_switchindataupdate(void) // check knocked off item i = GetBattlerSide(gActiveBattler); - if (gWishFutureKnock.knockedOffPokes[i] & gBitTable[gBattlerPartyIndexes[gActiveBattler]]) + if (gWishFutureKnock.knockedOffMons[i] & gBitTable[gBattlerPartyIndexes[gActiveBattler]]) { gBattleMons[gActiveBattler].item = 0; } @@ -6936,8 +6937,8 @@ static void atk7C_trymirrormove(void) { if (i != gBattlerAttacker) { - move = *(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 0) - | (*(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->mirrorMoveArrays) + 1) << 8); + move = *(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 0) + | (*(i * 2 + gBattlerAttacker * 8 + (u8*)(gBattleStruct->lastTakenMoveFrom) + 1) << 8); if (move != 0 && move != 0xFFFF) { @@ -6947,8 +6948,8 @@ static void atk7C_trymirrormove(void) } } - move = *(gBattleStruct->mirrorMoves + gBattlerAttacker * 2 + 0) - | (*(gBattleStruct->mirrorMoves + gBattlerAttacker * 2 + 1) << 8); + move = *(gBattleStruct->lastTakenMove + gBattlerAttacker * 2 + 0) + | (*(gBattleStruct->lastTakenMove + gBattlerAttacker * 2 + 1) << 8); if (move != 0 && move != 0xFFFF) { @@ -6967,7 +6968,7 @@ static void atk7C_trymirrormove(void) } else { - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; gBattlescriptCurrInstr++; } } @@ -8032,7 +8033,7 @@ static void atk9B_transformdataexecution(void) gBattleMons[gBattlerAttacker].status2 |= STATUS2_TRANSFORMED; gDisableStructs[gBattlerAttacker].disabledMove = 0; - gDisableStructs[gBattlerAttacker].disableTimer1 = 0; + gDisableStructs[gBattlerAttacker].disableTimer = 0; gDisableStructs[gBattlerAttacker].transformedMonPersonality = gBattleMons[gBattlerTarget].personality; gDisableStructs[gBattlerAttacker].unk18_b = 0; @@ -8206,7 +8207,7 @@ static void atkA1_counterdamagecalculator(void) } else { - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); } } @@ -8229,7 +8230,7 @@ static void atkA2_mirrorcoatdamagecalculator(void) // a copy of atkA1 with the p } else { - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); } } @@ -8249,8 +8250,8 @@ static void atkA3_disablelastusedattack(void) PREPARE_MOVE_BUFFER(gBattleTextBuff1, gBattleMons[gBattlerTarget].moves[i]) gDisableStructs[gBattlerTarget].disabledMove = gBattleMons[gBattlerTarget].moves[i]; - gDisableStructs[gBattlerTarget].disableTimer1 = (Random() & 3) + 2; - gDisableStructs[gBattlerTarget].disableTimer2 = gDisableStructs[gBattlerTarget].disableTimer1; // used to save the random amount of turns? + gDisableStructs[gBattlerTarget].disableTimer = (Random() & 3) + 2; + gDisableStructs[gBattlerTarget].disableTimerStartValue = gDisableStructs[gBattlerTarget].disableTimer; // used to save the random amount of turns? gBattlescriptCurrInstr += 5; } else @@ -8281,8 +8282,8 @@ static void atkA4_trysetencore(void) { gDisableStructs[gBattlerTarget].encoredMove = gBattleMons[gBattlerTarget].moves[i]; gDisableStructs[gBattlerTarget].encoredMovePos = i; - gDisableStructs[gBattlerTarget].encoreTimer1 = (Random() & 3) + 3; - gDisableStructs[gBattlerTarget].encoreTimer2 = gDisableStructs[gBattlerTarget].encoreTimer1; + gDisableStructs[gBattlerTarget].encoreTimer = (Random() & 3) + 3; + gDisableStructs[gBattlerTarget].encoreTimerStartValue = gDisableStructs[gBattlerTarget].encoreTimer; gBattlescriptCurrInstr += 5; } else @@ -8726,7 +8727,7 @@ static void atkB0_trysetspikes(void) if (gSideTimers[targetSide].spikesAmount == 3) { - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); } else @@ -8758,8 +8759,8 @@ static void atkB2_trysetperishsong(void) else { gStatuses3[i] |= STATUS3_PERISH_SONG; - gDisableStructs[i].perishSongTimer1 = 3; - gDisableStructs[i].perishSongTimer2 = 3; + gDisableStructs[i].perishSongTimer = 3; + gDisableStructs[i].perishSongTimerStartValue = 3; } } @@ -8784,19 +8785,19 @@ static void atkB3_rolloutdamagecalculation(void) if (!(gBattleMons[gBattlerAttacker].status2 & STATUS2_MULTIPLETURNS)) // first hit { - gDisableStructs[gBattlerAttacker].rolloutCounter1 = 5; - gDisableStructs[gBattlerAttacker].rolloutCounter2 = 5; + gDisableStructs[gBattlerAttacker].rolloutTimer = 5; + gDisableStructs[gBattlerAttacker].rolloutTimerStartValue = 5; gBattleMons[gBattlerAttacker].status2 |= STATUS2_MULTIPLETURNS; gLockedMoves[gBattlerAttacker] = gCurrentMove; } - if (--gDisableStructs[gBattlerAttacker].rolloutCounter1 == 0) // last hit + if (--gDisableStructs[gBattlerAttacker].rolloutTimer == 0) // last hit { gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_MULTIPLETURNS); } gDynamicBasePower = gBattleMoves[gCurrentMove].power; - for (i = 1; i < (5 - gDisableStructs[gBattlerAttacker].rolloutCounter1); i++) + for (i = 1; i < (5 - gDisableStructs[gBattlerAttacker].rolloutTimer); i++) gDynamicBasePower *= 2; if (gBattleMons[gBattlerAttacker].status2 & STATUS2_DEFENSE_CURL) @@ -9319,8 +9320,8 @@ static void atkCA_setforcedtarget(void) // follow me static void atkCB_setcharge(void) { gStatuses3[gBattlerAttacker] |= STATUS3_CHARGED_UP; - gDisableStructs[gBattlerAttacker].chargeTimer1 = 2; - gDisableStructs[gBattlerAttacker].chargeTimer2 = 2; + gDisableStructs[gBattlerAttacker].chargeTimer = 2; + gDisableStructs[gBattlerAttacker].chargeTimerStartValue = 2; gBattlescriptCurrInstr++; } @@ -9372,9 +9373,9 @@ static void atkCF_jumpifnodamage(void) static void atkD0_settaunt(void) { - if (gDisableStructs[gBattlerTarget].tauntTimer1 == 0) + if (gDisableStructs[gBattlerTarget].tauntTimer == 0) { - gDisableStructs[gBattlerTarget].tauntTimer1 = 2; + gDisableStructs[gBattlerTarget].tauntTimer = 2; gDisableStructs[gBattlerTarget].tauntTimer2 = 2; gBattlescriptCurrInstr += 5; } @@ -9426,8 +9427,8 @@ static void atkD2_tryswapitems(void) // trick | BATTLE_TYPE_FRONTIER | BATTLE_TYPE_SECRET_BASE | BATTLE_TYPE_x2000000)) - && (gWishFutureKnock.knockedOffPokes[sideAttacker] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]] - || gWishFutureKnock.knockedOffPokes[sideTarget] & gBitTable[gBattlerPartyIndexes[gBattlerTarget]])) + && (gWishFutureKnock.knockedOffMons[sideAttacker] & gBitTable[gBattlerPartyIndexes[gBattlerAttacker]] + || gWishFutureKnock.knockedOffMons[sideTarget] & gBitTable[gBattlerPartyIndexes[gBattlerTarget]])) { gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); } @@ -9750,7 +9751,7 @@ static void atkDE_asistattackselect(void) static void atkDF_trysetmagiccoat(void) { gBattlerTarget = gBattlerAttacker; - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; if (gCurrentTurnActionNumber == gBattlersCount - 1) // moves last turn { gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); @@ -9764,7 +9765,7 @@ static void atkDF_trysetmagiccoat(void) static void atkE0_trysetsnatch(void) // snatch { - gSpecialStatuses[gBattlerAttacker].flag20 = 1; + gSpecialStatuses[gBattlerAttacker].ppNotAffectedByPressure = 1; if (gCurrentTurnActionNumber == gBattlersCount - 1) // moves last turn { gBattlescriptCurrInstr = T1_READ_PTR(gBattlescriptCurrInstr + 1); diff --git a/src/battle_setup.c b/src/battle_setup.c index 89a3d9a2c..f9fab3d17 100644 --- a/src/battle_setup.c +++ b/src/battle_setup.c @@ -642,7 +642,7 @@ u8 BattleSetup_GetTerrainId(void) case MAP_TYPE_ROUTE: break; case MAP_TYPE_UNDERGROUND: - if (MetatileBehavior_IsMB_0B(tileBehavior)) + if (MetatileBehavior_IsIndoorEncounter(tileBehavior)) return BATTLE_TERRAIN_BUILDING; if (MetatileBehavior_IsSurfableWaterOrUnderwater(tileBehavior)) return BATTLE_TERRAIN_POND; diff --git a/src/battle_transition.c b/src/battle_transition.c index d1d92cb50..fc8c0eeee 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -19,7 +19,7 @@ #include "gpu_regs.h" #include "decompress.h" #include "bg.h" -#include "blend_palette.h" +#include "util.h" struct TransitionData { diff --git a/src/battle_tv.c b/src/battle_tv.c index 6f9ee414e..535046fd1 100644 --- a/src/battle_tv.c +++ b/src/battle_tv.c @@ -659,7 +659,7 @@ void BattleTv_SetDataBasedOnMove(u16 move, u16 weatherFlags, struct DisableStruc tvPtr->side[atkSide].usedMoveSlot = moveSlot; AddMovePoints(0, moveSlot, gBattleMoves[move].effect, 0); AddPointsBasedOnWeather(weatherFlags, move, moveSlot); - if (disableStructPtr->chargeTimer1 != 0) + if (disableStructPtr->chargeTimer != 0) AddMovePoints(7, move, moveSlot, 0); if (move == MOVE_WISH) diff --git a/src/battle_util.c b/src/battle_util.c index 79ce180ee..1aaffc053 100644 --- a/src/battle_util.c +++ b/src/battle_util.c @@ -216,7 +216,7 @@ void CancelMultiTurnMoves(u8 battler) gStatuses3[battler] &= ~(STATUS3_SEMI_INVULNERABLE); - gDisableStructs[battler].rolloutCounter1 = 0; + gDisableStructs[battler].rolloutTimer = 0; gDisableStructs[battler].furyCutterCounter = 0; } @@ -345,7 +345,7 @@ u8 TrySetCantSelectMoveBattleScript(void) } } - if (gDisableStructs[gActiveBattler].tauntTimer1 != 0 && gBattleMoves[move].power == 0) + if (gDisableStructs[gActiveBattler].tauntTimer != 0 && gBattleMoves[move].power == 0) { gCurrentMove = move; if (gBattleTypeFlags & BATTLE_TYPE_PALACE) @@ -436,11 +436,11 @@ u8 CheckMoveLimitations(u8 battlerId, u8 unusableMoves, u8 check) unusableMoves |= gBitTable[i]; if (gBattleMons[battlerId].moves[i] == gLastMoves[battlerId] && check & MOVE_LIMITATION_TORMENTED && gBattleMons[battlerId].status2 & STATUS2_TORMENT) unusableMoves |= gBitTable[i]; - if (gDisableStructs[battlerId].tauntTimer1 && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[battlerId].moves[i]].power == 0) + if (gDisableStructs[battlerId].tauntTimer && check & MOVE_LIMITATION_TAUNT && gBattleMoves[gBattleMons[battlerId].moves[i]].power == 0) unusableMoves |= gBitTable[i]; if (GetImprisonedMovesCount(battlerId, gBattleMons[battlerId].moves[i]) && check & MOVE_LIMITATION_IMPRISION) unusableMoves |= gBitTable[i]; - if (gDisableStructs[battlerId].encoreTimer1 && gDisableStructs[battlerId].encoredMove != gBattleMons[battlerId].moves[i]) + if (gDisableStructs[battlerId].encoreTimer && gDisableStructs[battlerId].encoredMove != gBattleMons[battlerId].moves[i]) unusableMoves |= gBitTable[i]; if (holdEffect == HOLD_EFFECT_CHOICE_BAND && *choicedMove != 0 && *choicedMove != 0xFFFF && *choicedMove != gBattleMons[battlerId].moves[i]) unusableMoves |= gBitTable[i]; @@ -1018,7 +1018,7 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_DISABLE: // disable - if (gDisableStructs[gActiveBattler].disableTimer1 != 0) + if (gDisableStructs[gActiveBattler].disableTimer != 0) { s32 i; for (i = 0; i < 4; i++) @@ -1029,9 +1029,9 @@ u8 DoBattlerEndTurnEffects(void) if (i == 4) // pokemon does not have the disabled move anymore { gDisableStructs[gActiveBattler].disabledMove = 0; - gDisableStructs[gActiveBattler].disableTimer1 = 0; + gDisableStructs[gActiveBattler].disableTimer = 0; } - else if (--gDisableStructs[gActiveBattler].disableTimer1 == 0) // disable ends + else if (--gDisableStructs[gActiveBattler].disableTimer == 0) // disable ends { gDisableStructs[gActiveBattler].disabledMove = 0; BattleScriptExecute(BattleScript_DisabledNoMore); @@ -1041,18 +1041,18 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_ENCORE: // encore - if (gDisableStructs[gActiveBattler].encoreTimer1 != 0) + if (gDisableStructs[gActiveBattler].encoreTimer != 0) { if (gBattleMons[gActiveBattler].moves[gDisableStructs[gActiveBattler].encoredMovePos] != gDisableStructs[gActiveBattler].encoredMove) // pokemon does not have the encored move anymore { gDisableStructs[gActiveBattler].encoredMove = 0; - gDisableStructs[gActiveBattler].encoreTimer1 = 0; + gDisableStructs[gActiveBattler].encoreTimer = 0; } - else if (--gDisableStructs[gActiveBattler].encoreTimer1 == 0 + else if (--gDisableStructs[gActiveBattler].encoreTimer == 0 || gBattleMons[gActiveBattler].pp[gDisableStructs[gActiveBattler].encoredMovePos] == 0) { gDisableStructs[gActiveBattler].encoredMove = 0; - gDisableStructs[gActiveBattler].encoreTimer1 = 0; + gDisableStructs[gActiveBattler].encoreTimer = 0; BattleScriptExecute(BattleScript_EncoredNoMore); effect++; } @@ -1065,13 +1065,13 @@ u8 DoBattlerEndTurnEffects(void) gBattleStruct->turnEffectsTracker++; break; case ENDTURN_CHARGE: // charge - if (gDisableStructs[gActiveBattler].chargeTimer1 && --gDisableStructs[gActiveBattler].chargeTimer1 == 0) + if (gDisableStructs[gActiveBattler].chargeTimer && --gDisableStructs[gActiveBattler].chargeTimer == 0) gStatuses3[gActiveBattler] &= ~STATUS3_CHARGED_UP; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_TAUNT: // taunt - if (gDisableStructs[gActiveBattler].tauntTimer1) - gDisableStructs[gActiveBattler].tauntTimer1--; + if (gDisableStructs[gActiveBattler].tauntTimer) + gDisableStructs[gActiveBattler].tauntTimer--; gBattleStruct->turnEffectsTracker++; break; case ENDTURN_YAWN: // yawn @@ -1167,8 +1167,8 @@ bool8 HandleWishPerishSongOnTurnEnd(void) gBattleStruct->wishPerishSongBattlerId++; if (gStatuses3[gActiveBattler] & STATUS3_PERISH_SONG) { - PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff1, 1, gDisableStructs[gActiveBattler].perishSongTimer1); - if (gDisableStructs[gActiveBattler].perishSongTimer1 == 0) + PREPARE_BYTE_NUMBER_BUFFER(gBattleTextBuff1, 1, gDisableStructs[gActiveBattler].perishSongTimer); + if (gDisableStructs[gActiveBattler].perishSongTimer == 0) { gStatuses3[gActiveBattler] &= ~STATUS3_PERISH_SONG; gBattleMoveDamage = gBattleMons[gActiveBattler].hp; @@ -1176,7 +1176,7 @@ bool8 HandleWishPerishSongOnTurnEnd(void) } else { - gDisableStructs[gActiveBattler].perishSongTimer1--; + gDisableStructs[gActiveBattler].perishSongTimer--; gBattlescriptCurrInstr = BattleScript_PerishSongCountGoesDown; } BattleScriptExecute(gBattlescriptCurrInstr); @@ -1420,7 +1420,7 @@ u8 AtkCanceller_UnableToUseMove(void) if (gBattleMons[gBattlerAttacker].status2 & STATUS2_RECHARGE) { gBattleMons[gBattlerAttacker].status2 &= ~(STATUS2_RECHARGE); - gDisableStructs[gBattlerAttacker].rechargeCounter = 0; + gDisableStructs[gBattlerAttacker].rechargeTimer = 0; CancelMultiTurnMoves(gBattlerAttacker); gBattlescriptCurrInstr = BattleScript_MoveUsedMustRecharge; gHitMarker |= HITMARKER_UNABLE_TO_USE_MOVE; @@ -1453,7 +1453,7 @@ u8 AtkCanceller_UnableToUseMove(void) gBattleStruct->atkCancellerTracker++; break; case CANCELLER_TAUNTED: // taunt - if (gDisableStructs[gBattlerAttacker].tauntTimer1 && gBattleMoves[gCurrentMove].power == 0) + if (gDisableStructs[gBattlerAttacker].tauntTimer && gBattleMoves[gCurrentMove].power == 0) { gProtectStructs[gBattlerAttacker].usedTauntedMove = 1; CancelMultiTurnMoves(gBattlerAttacker); diff --git a/src/blend_palette.c b/src/blend_palette.c deleted file mode 100644 index c9503388f..000000000 --- a/src/blend_palette.c +++ /dev/null @@ -1,19 +0,0 @@ -#include "global.h" -#include "palette.h" - -void BlendPalette(u16 palOffset, u16 numEntries, u8 coeff, u16 blendColor) -{ - u16 i; - for (i = 0; i < numEntries; i++) - { - u16 index = i + palOffset; - struct PlttData *data1 = (struct PlttData *)&gPlttBufferUnfaded[index]; - s8 r = data1->r; - s8 g = data1->g; - s8 b = data1->b; - struct PlttData *data2 = (struct PlttData *)&blendColor; - gPlttBufferFaded[index] = ((r + (((data2->r - r) * coeff) >> 4)) << 0) - | ((g + (((data2->g - g) * coeff) >> 4)) << 5) - | ((b + (((data2->b - b) * coeff) >> 4)) << 10); - } -} diff --git a/src/cable_club.c b/src/cable_club.c new file mode 100644 index 000000000..c54df5f24 --- /dev/null +++ b/src/cable_club.c @@ -0,0 +1,1299 @@ +#include "global.h" +#include "main.h" +#include "battle.h" +#include "battle_records.h" +#include "battle_setup.h" +#include "cable_club.h" +#include "data2.h" +#include "event_data.h" +#include "field_message_box.h" +#include "field_specials.h" +#include "field_weather.h" +#include "international_string_util.h" +#include "link.h" +#include "link_rfu.h" +#include "load_save.h" +#include "m4a.h" +#include "menu.h" +#include "overworld.h" +#include "palette.h" +#include "rom_8011DC0.h" +#include "script.h" +#include "script_pokemon_util_80F87D8.h" +#include "sound.h" +#include "start_menu.h" +#include "string_util.h" +#include "strings.h" +#include "task.h" +#include "trade.h" +#include "trainer_card.h" +#include "window.h" +#include "constants/songs.h" + +extern u8 gUnknown_02032298[2]; +extern u8 gUnknown_0203CEF8[]; + +static const struct WindowTemplate gUnknown_08550594 = { + .priority = 0, + .tilemapLeft = 16, + .tilemapTop = 11, + .width = 11, + .height = 2, + .paletteNum = 15, + .baseBlock = 0x0125, +}; +static const u8 *const gTrainerCardColorNames[] = { + gText_BronzeCard, + gText_CopperCard, + gText_SilverCard, + gText_GoldCard +}; + +static void sub_80B2634(u8 taskId); +static void sub_80B2688(u8 taskId); +static void sub_80B270C(u8 taskId); +static void sub_80B275C(u8 taskId); +static void sub_80B2804(u8 taskId); +static void sub_80B28A8(u8 taskId); +static void sub_80B2918(u8 taskId); +static void sub_80B2A08(u8 taskId); +static void sub_80B2C30(u8 taskId); +static void sub_80B2CB0(u8 taskId); +static void sub_80B2CEC(u8 taskId); +static void sub_80B2D2C(u8 taskId); +static bool8 sub_80B2D6C(u8 taskId); +static void sub_80B2EE4(u8 taskId); +static void sub_80B3144(u8 taskId); +static void sub_80B3194(u8 taskId); +static void sub_80B31E8(u8 taskId); +static void sub_80B3220(u8 taskId); + +static void sub_80B236C(u8 arg0, u8 arg1) +{ + if (FindTaskIdByFunc(sub_80B2634) == 0xFF) + { + u8 taskId1; + + taskId1 = CreateTask(sub_80B2634, 80); + gTasks[taskId1].data[1] = arg0; + gTasks[taskId1].data[2] = arg1; + } +} + +static void sub_80B23B0(u16 windowId, u32 value) +{ + u8 xPos; + + ConvertIntToDecimalStringN(gStringVar1, value, STR_CONV_MODE_LEFT_ALIGN, 1); + SetStandardWindowBorderStyle(windowId, 0); + StringExpandPlaceholders(gStringVar4, gText_XPLink); + xPos = GetStringCenterAlignXOffset(1, gStringVar4, 88); + AddTextPrinterParameterized(windowId, 1, gStringVar4, xPos, 1, 0xFF, NULL); + CopyWindowToVram(windowId, 3); +} + +static void sub_80B241C(u16 windowId) +{ + sub_819746C(windowId, FALSE); + CopyWindowToVram(windowId, 3); +} + +static void sub_80B243C(u8 taskId, u8 arg1) +{ + s16 *data = gTasks[taskId].data; + + if (arg1 != data[3]) + { + if (arg1 <= 1) + sub_80B241C(data[5]); + else + sub_80B23B0(data[5], arg1); + data[3] = arg1; + } +} + +static u32 sub_80B2478(u8 lower, u8 upper) +{ + int playerCount; + + switch (GetLinkPlayerDataExchangeStatusTimed(lower, upper)) + { + case EXCHANGE_COMPLETE: + return 1; + case EXCHANGE_IN_PROGRESS: + return 3; + case EXCHANGE_STAT_4: + return 7; + case EXCHANGE_STAT_5: + return 9; + case EXCHANGE_STAT_6: + ConvertIntToDecimalStringN(gStringVar1, GetLinkPlayerCount_2(), STR_CONV_MODE_LEFT_ALIGN, 1); + return 4; + case EXCHANGE_STAT_7: + return 10; + case EXCHANGE_TIMED_OUT: + default: + return 0; + } +} + +static bool32 sub_80B24F8(u8 taskId) +{ + if (HasLinkErrorOccurred() == TRUE) + { + gTasks[taskId].func = sub_80B2D2C; + return TRUE; + } + return FALSE; +} + +static bool32 sub_80B252C(u8 taskId) +{ + if ((gMain.newKeys & B_BUTTON) + && IsLinkConnectionEstablished() == FALSE) + { + gLinkType = 0; + gTasks[taskId].func = sub_80B2CEC; + return TRUE; + } + return FALSE; +} + +static bool32 sub_80B2578(u8 taskId) +{ + if (IsLinkConnectionEstablished()) + SetSuppressLinkErrorMessage(TRUE); + + if (gMain.newKeys & B_BUTTON) + { + gLinkType = 0; + gTasks[taskId].func = sub_80B2CEC; + return TRUE; + } + return FALSE; +} + +static bool32 sub_80B25CC(u8 taskId) +{ + if (GetSioMultiSI() == 1) + { + gTasks[taskId].func = sub_80B2D2C; + return TRUE; + } + return FALSE; +} + +static void sub_80B2600(u8 taskId) +{ + gTasks[taskId].data[0]++; + if (gTasks[taskId].data[0] == 10) + { + sub_800A4D8(2); + DestroyTask(taskId); + } +} + +static void sub_80B2634(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (data[0] == 0) + { + OpenLinkTimed(); + sub_800AB98(); + ResetLinkPlayers(); + data[5] = AddWindow(&gUnknown_08550594); + } + else if (data[0] > 9) + { + gTasks[taskId].func = sub_80B2688; + } + data[0]++; +} + +static void sub_80B2688(u8 taskId) +{ + u32 playerCount = GetLinkPlayerCount_2(); + + if (sub_80B252C(taskId) == TRUE + || sub_80B2578(taskId) == TRUE + || playerCount < 2) + return; + + SetSuppressLinkErrorMessage(TRUE); + gTasks[taskId].data[3] = 0; + if (IsLinkMaster() == TRUE) + { + PlaySE(SE_PIN); + ShowFieldAutoScrollMessage(gText_ConfirmLinkWhenPlayersReady); + gTasks[taskId].func = sub_80B270C; + } + else + { + PlaySE(SE_BOO); + ShowFieldAutoScrollMessage(gText_AwaitingLinkup); + gTasks[taskId].func = sub_80B2918; + } +} + +static void sub_80B270C(u8 taskId) +{ + if (sub_80B252C(taskId) == TRUE + || sub_80B25CC(taskId) == TRUE + || sub_80B24F8(taskId) == TRUE) + return; + + if (GetFieldMessageBoxMode() == FIELD_MESSAGE_BOX_HIDDEN) + { + gTasks[taskId].data[3] = 0; + gTasks[taskId].func = sub_80B275C; + } +} + +static void sub_80B275C(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + s32 linkPlayerCount = GetLinkPlayerCount_2(); + + if (sub_80B252C(taskId) == TRUE + || sub_80B25CC(taskId) == TRUE + || sub_80B24F8(taskId) == TRUE) + return; + + sub_80B243C(taskId, linkPlayerCount); + + if (!(gMain.newKeys & A_BUTTON)) + return; + + if (linkPlayerCount < data[1]) + return; + + sub_800AA04(linkPlayerCount); + sub_80B241C(data[5]); + ConvertIntToDecimalStringN(gStringVar1, linkPlayerCount, STR_CONV_MODE_LEFT_ALIGN, 1); + ShowFieldAutoScrollMessage(gText_ConfirmStartLinkWithXPlayers); + gTasks[taskId].func = sub_80B2804; +} + +static void sub_80B2804(u8 taskId) +{ + if (sub_80B252C(taskId) == TRUE + || sub_80B25CC(taskId) == TRUE + || sub_80B24F8(taskId) == TRUE) + return; + + if (GetFieldMessageBoxMode() == FIELD_MESSAGE_BOX_HIDDEN) + { + if (sub_800AA48() != GetLinkPlayerCount_2()) + { + ShowFieldAutoScrollMessage(gText_ConfirmLinkWhenPlayersReady); + gTasks[taskId].func = sub_80B270C; + } + else if (gMain.heldKeys & B_BUTTON) + { + ShowFieldAutoScrollMessage(gText_ConfirmLinkWhenPlayersReady); + gTasks[taskId].func = sub_80B270C; + } + else if (gMain.heldKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + sub_800A620(); + gTasks[taskId].func = sub_80B28A8; + } + } +} + +static void sub_80B28A8(u8 taskId) +{ + u8 local1 = gTasks[taskId].data[1]; + u8 local2 = gTasks[taskId].data[2]; + + if (sub_80B24F8(taskId) == TRUE + || sub_80B2D6C(taskId) == TRUE) + return; + + if (GetLinkPlayerCount_2() != sub_800AA48()) + { + gTasks[taskId].func = sub_80B2D2C; + } + else + { + gSpecialVar_Result = sub_80B2478(local1, local2); + if (gSpecialVar_Result != 0) + gTasks[taskId].func = sub_80B2A08; + } +} + +static void sub_80B2918(u8 taskId) +{ + u8 local1, local2; + struct TrainerCard *card; + + local1 = gTasks[taskId].data[1]; + local2 = gTasks[taskId].data[2]; + + if (sub_80B252C(taskId) == TRUE + || sub_80B24F8(taskId) == TRUE) + return; + + gSpecialVar_Result = sub_80B2478(local1, local2); + if (gSpecialVar_Result == 0) + return; + if (gSpecialVar_Result == 3 || gSpecialVar_Result == 4) + { + sub_800AC34(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + else if (gSpecialVar_Result == 7 || gSpecialVar_Result == 9) + { + CloseLink(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + else + { + gFieldLinkPlayerCount = GetLinkPlayerCount_2(); + gUnknown_03005DB4 = GetMultiplayerId(); + sub_800AA04(gFieldLinkPlayerCount); + card = (struct TrainerCard *)gBlockSendBuffer; + TrainerCard_GenerateCardForPlayer(card); + card->monSpecies[0] = GetMonData(&gPlayerParty[gUnknown_0203CEF8[0] - 1], MON_DATA_SPECIES, NULL); + card->monSpecies[1] = GetMonData(&gPlayerParty[gUnknown_0203CEF8[1] - 1], MON_DATA_SPECIES, NULL); + gTasks[taskId].func = sub_80B2C30; + } +} + +static void sub_80B2A08(u8 taskId) +{ + struct TrainerCard *card; + + if (sub_80B24F8(taskId) == TRUE) + return; + + if (gSpecialVar_Result == 4) + { + if (!Link_AnyPartnersPlayingRubyOrSapphire()) + { + sub_800AC34(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + else + { + CloseLink(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + } + else if (gSpecialVar_Result == 3) + { + sub_800AC34(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + else if (gSpecialVar_Result == 7 || gSpecialVar_Result == 9) + { + CloseLink(); + HideFieldMessageBox(); + gTasks[taskId].func = sub_80B2CB0; + } + else + { + gFieldLinkPlayerCount = GetLinkPlayerCount_2(); + gUnknown_03005DB4 = GetMultiplayerId(); + sub_800AA04(gFieldLinkPlayerCount); + card = (struct TrainerCard *)gBlockSendBuffer; + TrainerCard_GenerateCardForPlayer(card); + card->monSpecies[0] = GetMonData(&gPlayerParty[gUnknown_0203CEF8[0] - 1], MON_DATA_SPECIES, NULL); + card->monSpecies[1] = GetMonData(&gPlayerParty[gUnknown_0203CEF8[1] - 1], MON_DATA_SPECIES, NULL); + gTasks[taskId].func = sub_80B2C30; + sub_800A4D8(2); + } +} + +bool32 sub_80B2AF4(u16 *arg0, u16 *arg1) +{ + int i; + int j; + bool32 result = FALSE; + int k = 0; + + gStringVar1[0] = EOS; + gStringVar2[0] = EOS; + + for (i = 0; i < 2; i++) + { + for (j = 0; j < 2; j++) + { + if (arg0[i] == arg1[j]) + { + if (k == 0) + { + StringCopy(gStringVar1, gSpeciesNames[arg0[i]]); + result = TRUE; + } + + if (k == 1) + { + StringCopy(gStringVar2, gSpeciesNames[arg0[i]]); + result = TRUE; + } + + k++; + } + } + } + + gSpecialVar_0x8005 = k; + + return result; +} + +static void task_map_chg_seq_0807EC34(u16 *a0, u32 taskId) +{ + struct TrainerCard *trainerCards = gTrainerCards; + + if (*a0 == 1) + { + if (gLinkType == 0x2266 || gLinkType == 0x2277) + { + if (sub_80B2AF4(trainerCards[0].monSpecies, trainerCards[1].monSpecies)) + { + *a0 = 11; + sub_800AC34(); + gTasks[taskId].func = sub_80B2CB0; + } + else + { + sub_80B241C(gTasks[taskId].data[5]); + EnableBothScriptContexts(); + DestroyTask(taskId); + } + } + else + { + sub_80B241C(gTasks[taskId].data[5]); + EnableBothScriptContexts(); + DestroyTask(taskId); + } + } + else + { + sub_800AC34(); + gTasks[taskId].func = sub_80B2CB0; + } +} + +static void sub_80B2C30(u8 taskId) +{ + u8 index; + struct TrainerCard *trainerCards; + + if (sub_80B24F8(taskId) == TRUE) + return; + + if (GetBlockReceivedStatus() != sub_800A9A8()) + return; + + for (index = 0; index < GetLinkPlayerCount(); index++) + { + sub_80C3120(&gTrainerCards[index], gBlockRecvBuffer[index], gLinkPlayers[index].version); + } + + SetSuppressLinkErrorMessage(FALSE); + ResetBlockReceivedFlags(); + task_map_chg_seq_0807EC34(&gSpecialVar_Result, taskId); +} + +static void sub_80B2CB0(u8 taskId) +{ + if (gReceivedRemoteLinkPlayers == FALSE) + { + sub_80B241C(gTasks[taskId].data[5]); + EnableBothScriptContexts(); + RemoveWindow(gTasks[taskId].data[5]); + DestroyTask(taskId); + } +} + +static void sub_80B2CEC(u8 taskId) +{ + gSpecialVar_Result = 5; + sub_80B241C(gTasks[taskId].data[5]); + sub_8098374(); + RemoveWindow(gTasks[taskId].data[5]); + EnableBothScriptContexts(); + DestroyTask(taskId); +} + +static void sub_80B2D2C(u8 taskId) +{ + gSpecialVar_Result = 6; + sub_80B241C(gTasks[taskId].data[5]); + RemoveWindow(gTasks[taskId].data[5]); + HideFieldMessageBox(); + EnableBothScriptContexts(); + DestroyTask(taskId); +} + +static bool8 sub_80B2D6C(u8 taskId) +{ + gTasks[taskId].data[4]++; + if (gTasks[taskId].data[4] > 600) + { + gTasks[taskId].func = sub_80B2D2C; + return TRUE; + } + + return FALSE; +} + +void sub_80B2DA4(u8 arg0) +{ + u8 r3 = 2; + u8 r2 = 2; + + switch (gSpecialVar_0x8004) + { + case 1: + r3 = 2; + gLinkType = 0x2233; + break; + case 2: + r3 = 2; + gLinkType = 0x2244; + break; + case 5: + r3 = 4; + r2 = 4; + gLinkType = 0x2255; + break; + case 9: + r3 = 2; + if (gSaveBlock2Ptr->frontier.lvlMode == 0) + { + gLinkType = 0x2266; + } + else + { + gLinkType = 0x2277; + } + break; + } + + sub_80B236C(r3, r2); +} + +void sub_80B2E4C(void) +{ + gLinkType = 0x1133; + gBattleTypeFlags = 0; + sub_80B236C(2, 2); +} + +void sub_80B2E74(void) +{ + gSpecialVar_Result = 0; + gLinkType = 0x3311; + gBattleTypeFlags = 0; + sub_80B236C(2, 4); +} + +void sub_80B2EA8(void) +{ + u32 taskId = FindTaskIdByFunc(sub_80B2EE4); + + if (taskId == 0xFF) + { + taskId = CreateTask(sub_80B2EE4, 80); + gTasks[taskId].data[0] = 0; + } +} + +static void sub_80B2EE4(u8 taskId) +{ + int playerCount; + int i; + + switch (gTasks[taskId].data[0]) + { + case 0: + if (gSpecialVar_Result == 1) + { + bool32 unk = FALSE; + bool32 isEnglishRSLinked = FALSE; + bool32 isJapaneseEmeraldLinked = FALSE; + + playerCount = GetLinkPlayerCount(); + for (i = 0; i < playerCount; i++) + { + u32 version = (u8)gLinkPlayers[i].version; + u32 language = gLinkPlayers[i].language; + + if (version == VERSION_RUBY || version == VERSION_SAPPHIRE) + { + if (language == LANGUAGE_JAPANESE) + { + unk = TRUE; + break; + } + else + { + isEnglishRSLinked = TRUE; + } + } + else if (version == VERSION_EMERALD) + { + if (language == LANGUAGE_JAPANESE) + { + isJapaneseEmeraldLinked = TRUE; + } + } + } + + if (isEnglishRSLinked && isJapaneseEmeraldLinked) + { + unk = TRUE; + } + + if (unk) + { + gSpecialVar_Result = 12; + sub_800AD10(); + gTasks[taskId].data[0] = 1; + return; + } + } + EnableBothScriptContexts(); + DestroyTask(taskId); + break; + case 1: + if (gReceivedRemoteLinkPlayers == FALSE) + { + EnableBothScriptContexts(); + DestroyTask(taskId); + } + break; + } +} + +void sub_80B2FD8(void) +{ + gLinkType = 0x4411; + gBattleTypeFlags = 0; + sub_80B236C(2, 4); +} + +void sub_80B3000(void) +{ + gLinkType = 0x6601; + gBattleTypeFlags = 0; + sub_80B236C(4, 4); +} + +void sub_80B3028(void) +{ + gLinkType = 0x6602; + gBattleTypeFlags = 0; + sub_80B236C(2, 4); +} + +u8 sub_80B3050(void) +{ + if (FuncIsActiveTask(sub_80B3144) != FALSE) + return 0xFF; + + switch (gSpecialVar_0x8004) + { + case 1: + gLinkType = 0x2233; + break; + case 2: + gLinkType = 0x2244; + break; + case 5: + gLinkType = 0x2255; + break; + case 9: + if (gSaveBlock2Ptr->frontier.lvlMode == 0) + { + gLinkType = 0x2266; + } + else + { + gLinkType = 0x2277; + } + break; + case 3: + gLinkType = 0x1111; + break; + case 4: + gLinkType = 0x3322; + break; + } + + return CreateTask(sub_80B3144, 80); +} + +static void sub_80B3144(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + if (data[0] == 0) + { + OpenLink(); + ResetLinkPlayers(); + CreateTask(task00_08081A90, 80); + } + else if (data[0] >= 10) + { + gTasks[taskId].func = sub_80B3194; + } + data[0]++; +} + +static void sub_80B3194(u8 taskId) +{ + if (GetLinkPlayerCount_2() >= 2) + { + if (IsLinkMaster() == TRUE) + gTasks[taskId].func = sub_80B31E8; + else + gTasks[taskId].func = sub_80B3220; + } +} + +static void sub_80B31E8(u8 taskId) +{ + if (sub_800AA48() == GetLinkPlayerCount_2()) + { + sub_800A620(); + gTasks[taskId].func = sub_80B3220; + } +} + +static void sub_80B3220(u8 taskId) +{ + if (gReceivedRemoteLinkPlayers == TRUE + && IsLinkPlayerDataExchangeComplete() == TRUE) + { + sub_800AB18(); + sub_8009F18(); + DestroyTask(taskId); + } +} + +void sub_80B3254(void) +{ + SaveGame(); +} + +static void sub_80B3260(int a0) +{ + switch (a0) + { + case 1: + gBattleTypeFlags = BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER; + break; + case 2: + gBattleTypeFlags = BATTLE_TYPE_DOUBLE | BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER; + break; + case 5: + ReducePlayerPartyToThree(); + gBattleTypeFlags = BATTLE_TYPE_DOUBLE | BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_MULTI; + break; + case 9: + gBattleTypeFlags = BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_DOUBLE | BATTLE_TYPE_LINK | BATTLE_TYPE_TRAINER | BATTLE_TYPE_MULTI; + break; + } +} + +static void sub_80B32B4(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + FadeScreen(1, 0); + gLinkType = 0x2211; + ClearLinkCallback_2(); + task->data[0]++; + break; + case 1: + if (!gPaletteFade.active) + task->data[0]++; + break; + case 2: + task->data[1]++; + if (task->data[1] > 20) + task->data[0]++; + break; + case 3: + sub_800AC34(); + task->data[0]++; + break; + case 4: + if (!gReceivedRemoteLinkPlayers) + task->data[0]++; + break; + case 5: + if (gLinkPlayers[0].trainerId & 1) + PlayMapChosenOrBattleBGM(MUS_BATTLE32); + else + PlayMapChosenOrBattleBGM(MUS_BATTLE20); + + sub_80B3260(gSpecialVar_0x8004); + overworld_free_bg_tilemaps(); + gTrainerBattleOpponent_A = 0x800; + SetMainCallback2(CB2_InitBattle); + gMain.savedCallback = sub_80B360C; + DestroyTask(taskId); + break; + } +} + +static void sub_80B33BC(u8 taskId) +{ + int i; + s16* data = gTasks[taskId].data; + + switch (data[0]) + { + case 0: + FadeScreen(1, 0); + gLinkType = 0x2211; + ClearLinkCallback_2(); + data[0] = 1; + break; + case 1: + if (!gPaletteFade.active) + data[0] = 2; + break; + case 2: + SendBlock(0, &gLocalLinkPlayer, sizeof(gLocalLinkPlayer)); + data[0] = 3; + break; + case 3: + if (GetBlockReceivedStatus() == sub_800A9D8()) + { + for (i = 0; i < GetLinkPlayerCount(); i++) + { + struct LinkPlayer *player = (struct LinkPlayer *)gBlockRecvBuffer[i]; + gLinkPlayers[i] = *player; + sub_800B524(&gLinkPlayers[i]); + ResetBlockReceivedFlag(i); + } + data[0] = 4; + } + break; + case 4: + data[1]++; + if (data[1] > 20) + data[0] = 5; + break; + case 5: + sub_800ADF8(); + data[0] = 6; + break; + case 6: + if (sub_800A520()) + { + data[0] = 7; + } + break; + case 7: + if (gLinkPlayers[0].trainerId & 1) + PlayMapChosenOrBattleBGM(MUS_BATTLE32); + else + PlayMapChosenOrBattleBGM(MUS_BATTLE20); + + gLinkPlayers[0].linkType = 0x2211; + sub_80B3260(gSpecialVar_0x8004); + overworld_free_bg_tilemaps(); + gTrainerBattleOpponent_A = 0x800; + SetMainCallback2(CB2_InitBattle); + gMain.savedCallback = sub_80B360C; + DestroyTask(taskId); + break; + } +} + +static void sub_80B3554(void) +{ + u8 playerCount; + int i; + bool32 r4; + + switch (gMain.state) + { + case 0: + playerCount = GetLinkPlayerCount(); + r4 = FALSE; + for (i = 0; i < playerCount; i++) + { + u32 version = (u8)gLinkPlayers[i].version; + if (version == VERSION_FIRE_RED || version == VERSION_LEAF_GREEN) + { + r4 = TRUE; + break; + } + } + + if (r4) + { + gMain.state = 2; + } + else + { + sub_800AC34(); + gMain.state = 1; + } + break; + case 1: + if (gReceivedRemoteLinkPlayers == FALSE) + { + SetMainCallback2(CB2_ReturnToField); + } + break; + case 2: + SetMainCallback2(CB2_ReturnToField); + break; + } + RunTasks(); +} + +void sub_80B360C(void) +{ + gBattleTypeFlags &= ~BATTLE_TYPE_20; + Overworld_ResetMapMusic(); + LoadPlayerParty(); + SavePlayerBag(); + sub_813BF10(); + + if (gSpecialVar_0x8004 == 1 || gSpecialVar_0x8004 == 2) + { + UpdatePlayerLinkBattleRecords(gUnknown_03005DB4 ^ 1); + if (gWirelessCommType) + { + switch (gBattleOutcome) + { + case B_OUTCOME_WON: + sub_801B990(0, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId); + break; + case B_OUTCOME_LOST: + sub_801B990(1, gLinkPlayers[GetMultiplayerId() ^ 1].trainerId); + break; + } + } + } + + if (InUnionRoom() == TRUE) + { + gMain.savedCallback = sub_80B3554; + } + else + { + gMain.savedCallback = c2_8056854; + } + + SetMainCallback2(sub_80A0514); +} + +void sub_80B36EC(void) +{ + if (gSpecialVar_0x8004 == 1 || gSpecialVar_0x8004 == 2 || gSpecialVar_0x8004 == 5 || gSpecialVar_0x8004 == 9) + { + LoadPlayerParty(); + SavePlayerBag(); + } + copy_saved_warp2_bank_and_enter_x_to_warp1(0x7F); +} + +void sub_80B371C(void) +{ + sub_80872B0(); +} + +static void sub_80B3728(u8 taskId) +{ + struct Task* task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + ShowFieldMessage(gText_PleaseWaitForLink); + task->data[0] = 1; + break; + case 1: + if (IsFieldMessageBoxHidden()) + { + sub_8087288(); + sub_8009628(gSpecialVar_0x8005); + task->data[0] = 2; + } + break; + case 2: + switch (sub_8087214()) + { + case 0: + break; + case 1: + HideFieldMessageBox(); + task->data[0] = 0; + sub_80872C4(); + SwitchTaskToFollowupFunc(taskId); + break; + case 2: + task->data[0] = 3; + break; + } + break; + case 3: + sub_808729C(); + sub_8197AE8(TRUE); + DestroyTask(taskId); + EnableBothScriptContexts(); + break; + } +} + +void sub_80B37D4(TaskFunc followupFunc) +{ + u8 taskId = CreateTask(sub_80B3728, 80); + SetTaskFuncWithFollowupFunc(taskId, sub_80B3728, followupFunc); + ScriptContext1_Stop(); +} + +static void sub_80B37FC(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + switch (task->data[0]) + { + case 0: + ScriptContext2_Enable(); + FadeScreen(1, 0); + ClearLinkCallback_2(); + task->data[0]++; + break; + case 1: + if (!gPaletteFade.active) + task->data[0]++; + break; + case 2: + gUnknown_02032298[0] = 0; + gUnknown_02032298[1] = 0; + m4aMPlayAllStop(); + sub_800AC34(); + task->data[0]++; + break; + case 3: + if (!gReceivedRemoteLinkPlayers) + { + SetMainCallback2(sub_80773AC); + DestroyTask(taskId); + } + break; + } +} + +static void sub_80B3894(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + switch (data[0]) + { + case 0: + ScriptContext2_Enable(); + FadeScreen(1, 0); + Rfu_set_zero(); + data[0]++; + break; + case 1: + if (!gPaletteFade.active) + data[0]++; + break; + case 2: + gUnknown_02032298[0] = 0; + gUnknown_02032298[1] = 0; + m4aMPlayAllStop(); + sub_800ADF8(); + data[0]++; + break; + case 3: + if (sub_800A520()) + { + sub_8013F78(); + DestroyTask(taskId); + } + break; + } +} + +void sub_80B3924(void) +{ + if (gWirelessCommType != 0) + { + sub_80B37D4(sub_80B3894); + } + else + { + sub_80B37D4(sub_80B37FC); + } +} + +static void sub_80B3950(void) +{ + CreateTask(sub_80B37FC, 80); +} + +void nullsub_37(void) +{ + +} + +void sub_80B3968(void) +{ + gLinkType = 0x2211; + + if (gWirelessCommType != 0) + { + sub_80B37D4(sub_80B33BC); + } + else + { + sub_80B37D4(sub_80B32B4); + } +} + +static void sub_80B39A4(void) +{ + u8 taskId = CreateTask(sub_80B3728, 80); + ScriptContext1_Stop(); +} + +void sp02A_crash_sound(void) +{ + TrainerCard_ShowLinkCard(gSpecialVar_0x8006, CB2_ReturnToFieldContinueScriptPlayMapMusic); +} + +bool32 sub_80B39D4(u8 linkPlayerIndex) +{ + u32 trainerCardColorIndex; + + gSpecialVar_0x8006 = linkPlayerIndex; + StringCopy(gStringVar1, gLinkPlayers[linkPlayerIndex].name); + + trainerCardColorIndex = sub_80C4904(linkPlayerIndex); + if (trainerCardColorIndex == 0) + return FALSE; + + StringCopy(gStringVar2, gTrainerCardColorNames[trainerCardColorIndex - 1]); + return TRUE; +} + +void task00_08081A90(u8 taskId) +{ + struct Task *task = &gTasks[taskId]; + + task->data[0]++; + if (task->data[0] > 300) + { + CloseLink(); + SetMainCallback2(CB2_LinkError); + DestroyTask(taskId); + } + + if (gReceivedRemoteLinkPlayers) + { + if (gWirelessCommType == 0) + { + if (!sub_800AA60()) + { + CloseLink(); + SetMainCallback2(CB2_LinkError); + } + DestroyTask(taskId); + } + else + { + DestroyTask(taskId); + } + } +} + +static void sub_80B3AAC(u8 taskId) +{ + if (!gReceivedRemoteLinkPlayers) + { + EnableBothScriptContexts(); + DestroyTask(taskId); + } +} + +static void sub_80B3AD0(u8 taskId) +{ + sub_800AC34(); + gTasks[taskId].func = sub_80B3AAC; +} + +void sub_80B3AF8(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + switch (data[0]) + { + case 0: + if (gWirelessCommType != 0) + { + DestroyTask(taskId); + } + else + { + OpenLink(); + CreateTask(task00_08081A90, 1); + data[0]++; + } + break; + case 1: + if (++data[1] > 11) + { + data[1] = 0; + data[0]++; + } + break; + case 2: + if (GetLinkPlayerCount_2() >= sub_800AA48()) + { + if (IsLinkMaster()) + { + if (++data[1] > 30) + { + sub_800A620(); + data[0]++; + } + } + else + { + data[0]++; + } + } + break; + case 3: + if (gReceivedRemoteLinkPlayers == TRUE && IsLinkPlayerDataExchangeComplete() == TRUE) + { + DestroyTask(taskId); + } + break; + } +} + +void sub_80B3BC4(void) +{ + if (gWirelessCommType == 0) + { + gLinkType = 0x2288; + } +} diff --git a/src/contest.c b/src/contest.c index 910637387..473f77f9c 100644 --- a/src/contest.c +++ b/src/contest.c @@ -10,7 +10,6 @@ #include "constants/flags.h" #include "battle.h" #include "battle_anim.h" -#include "blend_palette.h" #include "contest.h" #include "data2.h" #include "decompress.h" @@ -2535,7 +2534,7 @@ u8 sub_80DB174(u16 species, u32 otId, u32 personality, u32 index) LoadCompressedPalette(GetFrontSpritePalFromSpeciesAndPersonality(species, otId, personality), 0x120, 0x20); SetMultiuseSpriteTemplateToPokemon(species, 0); - spriteId = CreateSprite(&gMultiuseSpriteTemplate, 0x70, sub_80A600C(2, species, 0), 30); + spriteId = CreateSprite(&gMultiuseSpriteTemplate, 0x70, GetBattlerSpriteFinal_Y(2, species, FALSE), 30); gSprites[spriteId].oam.paletteNum = 2; gSprites[spriteId].oam.priority = 2; gSprites[spriteId].subpriority = sub_80A82E4(2); diff --git a/src/data/field_event_obj/event_object_graphics.h b/src/data/field_event_obj/event_object_graphics.h index a99d5a779..4b65e694f 100755 --- a/src/data/field_event_obj/event_object_graphics.h +++ b/src/data/field_event_obj/event_object_graphics.h @@ -71,36 +71,36 @@ const u16 gEventObjectPalette4[] = INCBIN_U16("graphics/event_objects/palettes/f const u16 gEventObjectPalette5[] = INCBIN_U16("graphics/event_objects/palettes/field_object_palette_05.gbapal"); const u16 gEventObjectPalette6[] = INCBIN_U16("graphics/event_objects/palettes/field_object_palette_06.gbapal"); const u16 gEventObjectPalette7[] = INCBIN_U16("graphics/event_objects/palettes/field_object_palette_07.gbapal"); -const u32 gEventObjectPic_LittleBoy1[] = INCBIN_U32("graphics/event_objects/pics/people/little_boy_1.4bpp"); -const u32 gEventObjectPic_LittleGirl1[] = INCBIN_U32("graphics/event_objects/pics/people/little_girl_1.4bpp"); +const u32 gEventObjectPic_NinjaBoy[] = INCBIN_U32("graphics/event_objects/pics/people/ninja_boy.4bpp"); +const u32 gEventObjectPic_Twin[] = INCBIN_U32("graphics/event_objects/pics/people/twin.4bpp"); const u32 gEventObjectPic_Boy1[] = INCBIN_U32("graphics/event_objects/pics/people/boy_1.4bpp"); const u32 gEventObjectPic_Girl1[] = INCBIN_U32("graphics/event_objects/pics/people/girl_1.4bpp"); const u32 gEventObjectPic_Boy2[] = INCBIN_U32("graphics/event_objects/pics/people/boy_2.4bpp"); const u32 gEventObjectPic_Girl2[] = INCBIN_U32("graphics/event_objects/pics/people/girl_2.4bpp"); -const u32 gEventObjectPic_LittleBoy2[] = INCBIN_U32("graphics/event_objects/pics/people/little_boy_2.4bpp"); -const u32 gEventObjectPic_LittleGirl2[] = INCBIN_U32("graphics/event_objects/pics/people/little_girl_2.4bpp"); +const u32 gEventObjectPic_LittleBoy[] = INCBIN_U32("graphics/event_objects/pics/people/little_boy.4bpp"); +const u32 gEventObjectPic_LittleGirl[] = INCBIN_U32("graphics/event_objects/pics/people/little_girl.4bpp"); const u32 gEventObjectPic_Boy3[] = INCBIN_U32("graphics/event_objects/pics/people/boy_3.4bpp"); const u32 gEventObjectPic_Girl3[] = INCBIN_U32("graphics/event_objects/pics/people/girl_3.4bpp"); -const u32 gEventObjectPic_Boy4[] = INCBIN_U32("graphics/event_objects/pics/people/boy_4.4bpp"); +const u32 gEventObjectPic_RichBoy[] = INCBIN_U32("graphics/event_objects/pics/people/rich_boy.4bpp"); const u32 gEventObjectPic_Woman1[] = INCBIN_U32("graphics/event_objects/pics/people/woman_1.4bpp"); const u32 gEventObjectPic_FatMan[] = INCBIN_U32("graphics/event_objects/pics/people/fat_man.4bpp"); -const u32 gEventObjectPic_Woman2[] = INCBIN_U32("graphics/event_objects/pics/people/woman_2.4bpp"); +const u32 gEventObjectPic_PokefanF[] = INCBIN_U32("graphics/event_objects/pics/people/pokefan_f.4bpp"); const u32 gEventObjectPic_Man1[] = INCBIN_U32("graphics/event_objects/pics/people/man_1.4bpp"); -const u32 gEventObjectPic_Woman3[] = INCBIN_U32("graphics/event_objects/pics/people/woman_3.4bpp"); -const u32 gEventObjectPic_OldMan1[] = INCBIN_U32("graphics/event_objects/pics/people/old_man_1.4bpp"); -const u32 gEventObjectPic_OldWoman1[] = INCBIN_U32("graphics/event_objects/pics/people/old_woman_1.4bpp"); +const u32 gEventObjectPic_Woman2[] = INCBIN_U32("graphics/event_objects/pics/people/woman_2.4bpp"); +const u32 gEventObjectPic_ExpertM[] = INCBIN_U32("graphics/event_objects/pics/people/expert_m.4bpp"); +const u32 gEventObjectPic_ExpertF[] = INCBIN_U32("graphics/event_objects/pics/people/expert_f.4bpp"); const u32 gEventObjectPic_Man2[] = INCBIN_U32("graphics/event_objects/pics/people/man_2.4bpp"); +const u32 gEventObjectPic_Woman3[] = INCBIN_U32("graphics/event_objects/pics/people/woman_3.4bpp"); +const u32 gEventObjectPic_PokefanM[] = INCBIN_U32("graphics/event_objects/pics/people/pokefan_m.4bpp"); const u32 gEventObjectPic_Woman4[] = INCBIN_U32("graphics/event_objects/pics/people/woman_4.4bpp"); -const u32 gEventObjectPic_Man3[] = INCBIN_U32("graphics/event_objects/pics/people/man_3.4bpp"); -const u32 gEventObjectPic_Woman5[] = INCBIN_U32("graphics/event_objects/pics/people/woman_5.4bpp"); const u32 gEventObjectPic_Cook[] = INCBIN_U32("graphics/event_objects/pics/people/cook.4bpp"); -const u32 gEventObjectPic_Woman6[] = INCBIN_U32("graphics/event_objects/pics/people/woman_6.4bpp"); -const u32 gEventObjectPic_OldMan2[] = INCBIN_U32("graphics/event_objects/pics/people/old_man_2.4bpp"); -const u32 gEventObjectPic_OldWoman2[] = INCBIN_U32("graphics/event_objects/pics/people/old_woman_2.4bpp"); +const u32 gEventObjectPic_LinkReceptionist[] = INCBIN_U32("graphics/event_objects/pics/people/link_receptionist.4bpp"); +const u32 gEventObjectPic_OldMan[] = INCBIN_U32("graphics/event_objects/pics/people/old_man.4bpp"); +const u32 gEventObjectPic_OldWoman[] = INCBIN_U32("graphics/event_objects/pics/people/old_woman.4bpp"); const u32 gEventObjectPic_Camper[] = INCBIN_U32("graphics/event_objects/pics/people/camper.4bpp"); const u32 gEventObjectPic_Picnicker[] = INCBIN_U32("graphics/event_objects/pics/people/picnicker.4bpp"); -const u32 gEventObjectPic_Man4[] = INCBIN_U32("graphics/event_objects/pics/people/man_4.4bpp"); -const u32 gEventObjectPic_Woman7[] = INCBIN_U32("graphics/event_objects/pics/people/woman_7.4bpp"); +const u32 gEventObjectPic_Man3[] = INCBIN_U32("graphics/event_objects/pics/people/man_3.4bpp"); +const u32 gEventObjectPic_Woman5[] = INCBIN_U32("graphics/event_objects/pics/people/woman_5.4bpp"); const u32 gEventObjectPic_Youngster[] = INCBIN_U32("graphics/event_objects/pics/people/youngster.4bpp"); const u32 gEventObjectPic_BugCatcher[] = INCBIN_U32("graphics/event_objects/pics/people/bug_catcher.4bpp"); const u32 gEventObjectPic_PsychicM[] = INCBIN_U32("graphics/event_objects/pics/people/psychic_m.4bpp"); @@ -124,8 +124,8 @@ const u32 gEventObjectPic_TuberM[] = INCBIN_U32("graphics/event_objects/pics/peo const u32 gEventObjectPic_Hiker[] = INCBIN_U32("graphics/event_objects/pics/people/hiker.4bpp"); const u32 gEventObjectPic_CyclingTriathleteM[] = INCBIN_U32("graphics/event_objects/pics/people/cycling_triathlete_m.4bpp"); const u32 gEventObjectPic_CyclingTriathleteF[] = INCBIN_U32("graphics/event_objects/pics/people/cycling_triathlete_f.4bpp"); +const u32 gEventObjectPic_Man4[] = INCBIN_U32("graphics/event_objects/pics/people/man_4.4bpp"); const u32 gEventObjectPic_Man5[] = INCBIN_U32("graphics/event_objects/pics/people/man_5.4bpp"); -const u32 gEventObjectPic_Man6[] = INCBIN_U32("graphics/event_objects/pics/people/man_6.4bpp"); const u32 gEventObjectPic_Nurse[] = INCBIN_U32("graphics/event_objects/pics/people/nurse.4bpp"); const u32 gEventObjectPic_ItemBall[] = INCBIN_U32("graphics/event_objects/pics/misc/item_ball.4bpp"); const u32 gEventObjectPic_ProfBirch[] = INCBIN_U32("graphics/event_objects/pics/people/prof_birch.4bpp"); @@ -139,7 +139,7 @@ const u32 gEventObjectPic_Teala[] = INCBIN_U32("graphics/event_objects/pics/peop const u32 gEventObjectPic_Artist[] = INCBIN_U32("graphics/event_objects/pics/people/artist.4bpp"); const u32 gEventObjectPic_Cameraman[] = INCBIN_U32("graphics/event_objects/pics/people/cameraman.4bpp"); const u32 gEventObjectPic_Scientist2[] = INCBIN_U32("graphics/event_objects/pics/people/scientist_2.4bpp"); -const u32 gEventObjectPic_Man7[] = INCBIN_U32("graphics/event_objects/pics/people/man_7.4bpp"); +const u32 gEventObjectPic_DevonEmployee[] = INCBIN_U32("graphics/event_objects/pics/people/devon_employee.4bpp"); const u32 gEventObjectPic_AquaMemberM[] = INCBIN_U32("graphics/event_objects/pics/people/team_aqua/aqua_member_m.4bpp"); const u32 gEventObjectPic_AquaMemberF[] = INCBIN_U32("graphics/event_objects/pics/people/team_aqua/aqua_member_f.4bpp"); const u32 gEventObjectPic_MagmaMemberM[] = INCBIN_U32("graphics/event_objects/pics/people/team_magma/magma_member_m.4bpp"); @@ -162,8 +162,8 @@ const u32 gEventObjectPic_Wally[] = INCBIN_U32("graphics/event_objects/pics/peop const u32 gEventObjectPic_RubySapphireLittleBoy[] = INCBIN_U32("graphics/event_objects/pics/people/rs_little_boy.4bpp"); const u32 gEventObjectPic_HotSpringsOldWoman[] = INCBIN_U32("graphics/event_objects/pics/people/hot_springs_old_woman.4bpp"); const u32 gEventObjectPic_LatiasLatios[] = INCBIN_U32("graphics/event_objects/pics/pokemon/latias_latios.4bpp"); -const u32 gEventObjectPic_Boy5[] = INCBIN_U32("graphics/event_objects/pics/people/boy_5.4bpp"); -const u32 gEventObjectPic_ContestOldMan[] = INCBIN_U32("graphics/event_objects/pics/people/contest_old_man.4bpp"); +const u32 gEventObjectPic_GameboyKid[] = INCBIN_U32("graphics/event_objects/pics/people/gameboy_kid.4bpp"); +const u32 gEventObjectPic_ContestJudge[] = INCBIN_U32("graphics/event_objects/pics/people/contest_judge.4bpp"); const u32 gEventObjectPic_Archie[] = INCBIN_U32("graphics/event_objects/pics/people/team_aqua/archie.4bpp"); const u32 gEventObjectPic_Maxie[] = INCBIN_U32("graphics/event_objects/pics/people/team_magma/maxie.4bpp"); const u32 gEventObjectPic_Kyogre[] = INCBIN_U32("graphics/event_objects/pics/pokemon/kyogre.4bpp"); diff --git a/src/data/field_event_obj/event_object_graphics_info.h b/src/data/field_event_obj/event_object_graphics_info.h index fd8bb78ce..ebc324b08 100755 --- a/src/data/field_event_obj/event_object_graphics_info.h +++ b/src/data/field_event_obj/event_object_graphics_info.h @@ -7,36 +7,36 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanAcroBike = const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanSurfing = {0xFFFF, EVENT_OBJ_PAL_TAG_8, EVENT_OBJ_PAL_TAG_NONE, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, TRUE, TRACKS_FOOT, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Surfing, gEventObjectPicTable_BrendanSurfing, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanFieldMove = {0xFFFF, EVENT_OBJ_PAL_TAG_8, EVENT_OBJ_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_FieldMove, gEventObjectPicTable_BrendanFieldMove, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_QuintyPlump = {0xFFFF, EVENT_OBJ_PAL_TAG_12, EVENT_OBJ_PAL_TAG_NONE, 512, 32, 32, 10, SHADOW_SIZE_L, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_QuintyPlump, gEventObjectPicTable_QuintyPlump, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy1 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleBoy1, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl1 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleGirl1, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_NinjaBoy = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_NinjaBoy, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Twin = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Twin, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy1 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Boy1, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl1 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Girl1, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy2 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Boy2, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl2 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Girl2, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy2 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleBoy2, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl2 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleGirl2, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleBoy, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LittleGirl, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy3 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Boy3, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl3 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Girl3, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy4 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Boy4, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_RichBoy = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_RichBoy, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman1 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman1, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_FatMan = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_FatMan, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman2 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman2, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PokefanF = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_PokefanF, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man1 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man1, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman3 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman3, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan1 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldMan1, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman1 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldWoman1, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman2 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman2, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ExpertM = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ExpertM, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ExpertF = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ExpertF, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man2 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man2, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman4 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman4, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man3 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man3, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman5 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman5, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman3 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman3, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PokefanM = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_PokefanM, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman4 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman4, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Cook = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Cook, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman6 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman6, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan2 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldMan2, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman2 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldWoman2, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LinkReceptionist = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LinkReceptionist, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldMan, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_OldWoman, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Camper = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Camper, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Picnicker = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Picnicker, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man4 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man4, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman7 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman7, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man3 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man3, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman5 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Woman5, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Youngster = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Youngster, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BugCatcher = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_BugCatcher, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PsychicM = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_PsychicM, gDummySpriteAffineAnimTable}; @@ -66,8 +66,8 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BerryTree = {0xFFF const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BerryTreeEarlyStages = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 16, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_BerryTree, gEventObjectPicTable_PechaBerryTree, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BerryTreeLateStages = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_BerryTree, gEventObjectPicTable_PechaBerryTree, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ProfBirch = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ProfBirch, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man5 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man5, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man6 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man6, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man4 = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man4, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man5 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man5, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ReporterM = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ReporterM, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ReporterF = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ReporterF, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Bard = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_MauvilleOldMan1, gDummySpriteAffineAnimTable}; @@ -118,7 +118,7 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MayUnderwater = {0 const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MovingBox = {0xFFFF, EVENT_OBJ_PAL_TAG_19, EVENT_OBJ_PAL_TAG_NONE, 128, 16, 16, 10, SHADOW_SIZE_S, TRUE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_16x16, gEventObjectSpriteOamTables_16x16, gEventObjectImageAnimTable_Inanimate, gEventObjectPicTable_MovingBox, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_CableCar = {0xFFFF, EVENT_OBJ_PAL_TAG_20, EVENT_OBJ_PAL_TAG_NONE, 2048, 64, 64, 10, SHADOW_SIZE_M, TRUE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_64x64, gEventObjectSpriteOamTables_64x64, gEventObjectImageAnimTable_Inanimate, gEventObjectPicTable_CableCar, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Scientist2 = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Scientist2, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man7 = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Man7, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_DevonEmployee = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_DevonEmployee, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_AquaMemberM = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_AquaMemberM, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_AquaMemberF = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 5, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_AquaMemberF, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MagmaMemberM = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_MagmaMemberM, gDummySpriteAffineAnimTable}; @@ -191,8 +191,8 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BigRegiceDoll = {0 const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BigRegisteelDoll = {0xFFFF, EVENT_OBJ_PAL_TAG_3, EVENT_OBJ_PAL_TAG_NONE, 512, 32, 32, 5, SHADOW_SIZE_M, TRUE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Inanimate, gEventObjectPicTable_BigRegisteelDoll, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Latias = {0xFFFF, EVENT_OBJ_PAL_TAG_1, EVENT_OBJ_PAL_TAG_NONE, 512, 32, 32, 3, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LatiasLatios, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Latios = {0xFFFF, EVENT_OBJ_PAL_TAG_0, EVENT_OBJ_PAL_TAG_NONE, 512, 32, 32, 2, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_NONE, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_LatiasLatios, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy5 = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_Boy5, gDummySpriteAffineAnimTable}; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ContestOldMan = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ContestOldMan, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_GameboyKid = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_GameboyKid, gDummySpriteAffineAnimTable}; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ContestJudge = {0xFFFF, EVENT_OBJ_PAL_TAG_2, EVENT_OBJ_PAL_TAG_NONE, 256, 16, 32, 4, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_ContestJudge, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanWatering = {0xFFFF, EVENT_OBJ_PAL_TAG_8, EVENT_OBJ_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_BrendanWatering, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MayWatering = {0xFFFF, EVENT_OBJ_PAL_TAG_17, EVENT_OBJ_PAL_TAG_10, 512, 32, 32, 0, SHADOW_SIZE_M, FALSE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_32x32, gEventObjectSpriteOamTables_32x32, gEventObjectImageAnimTable_Standard, gEventObjectPicTable_MayWatering, gDummySpriteAffineAnimTable}; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanDecorating = {0xFFFF, EVENT_OBJ_PAL_TAG_8, EVENT_OBJ_PAL_TAG_10, 256, 16, 32, 10, SHADOW_SIZE_M, TRUE, FALSE, TRACKS_FOOT, &gEventObjectBaseOam_16x32, gEventObjectSpriteOamTables_16x32, gEventObjectImageAnimTable_Inanimate, gEventObjectPicTable_BrendanDecorating, gDummySpriteAffineAnimTable}; diff --git a/src/data/field_event_obj/event_object_graphics_info_pointers.h b/src/data/field_event_obj/event_object_graphics_info_pointers.h index c0ca57b60..3f726e30e 100755 --- a/src/data/field_event_obj/event_object_graphics_info_pointers.h +++ b/src/data/field_event_obj/event_object_graphics_info_pointers.h @@ -6,36 +6,36 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanMachBike; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanSurfing; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanFieldMove; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_QuintyPlump; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy1; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl1; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_NinjaBoy; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Twin; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy1; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl1; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy2; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl2; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy2; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl2; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleBoy; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LittleGirl; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy3; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Girl3; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy4; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_RichBoy; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman1; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_FatMan; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman2; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PokefanF; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man1; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman3; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan1; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman1; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman2; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ExpertM; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ExpertF; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man2; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman3; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PokefanM; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman4; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man3; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman5; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Cook; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman6; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan2; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman2; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_LinkReceptionist; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldMan; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_OldWoman; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Camper; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Picnicker; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man4; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman7; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man3; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Woman5; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Youngster; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BugCatcher; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_PsychicM; @@ -66,8 +66,8 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BerryTreeEarlyStag const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BerryTreeLateStages; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanAcroBike; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ProfBirch; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man4; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man5; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man6; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ReporterM; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ReporterF; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Bard; @@ -117,7 +117,7 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MayUnderwater; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MovingBox; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_CableCar; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Scientist2; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Man7; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_DevonEmployee; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_AquaMemberM; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_AquaMemberF; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MagmaMemberM; @@ -190,8 +190,8 @@ const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BigRegiceDoll; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BigRegisteelDoll; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Latias; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Latios; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_Boy5; -const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ContestOldMan; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_GameboyKid; +const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_ContestJudge; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanWatering; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_MayWatering; const struct EventObjectGraphicsInfo gEventObjectGraphicsInfo_BrendanDecorating; @@ -255,36 +255,36 @@ const struct EventObjectGraphicsInfo *const gEventObjectGraphicsInfoPointers[] = &gEventObjectGraphicsInfo_BrendanSurfing, &gEventObjectGraphicsInfo_BrendanFieldMove, &gEventObjectGraphicsInfo_QuintyPlump, - &gEventObjectGraphicsInfo_LittleBoy1, - &gEventObjectGraphicsInfo_LittleGirl1, + &gEventObjectGraphicsInfo_NinjaBoy, + &gEventObjectGraphicsInfo_Twin, &gEventObjectGraphicsInfo_Boy1, &gEventObjectGraphicsInfo_Girl1, &gEventObjectGraphicsInfo_Boy2, &gEventObjectGraphicsInfo_Girl2, - &gEventObjectGraphicsInfo_LittleBoy2, - &gEventObjectGraphicsInfo_LittleGirl2, + &gEventObjectGraphicsInfo_LittleBoy, + &gEventObjectGraphicsInfo_LittleGirl, &gEventObjectGraphicsInfo_Boy3, &gEventObjectGraphicsInfo_Girl3, - &gEventObjectGraphicsInfo_Boy4, + &gEventObjectGraphicsInfo_RichBoy, &gEventObjectGraphicsInfo_Woman1, &gEventObjectGraphicsInfo_FatMan, - &gEventObjectGraphicsInfo_Woman2, + &gEventObjectGraphicsInfo_PokefanF, &gEventObjectGraphicsInfo_Man1, - &gEventObjectGraphicsInfo_Woman3, - &gEventObjectGraphicsInfo_OldMan1, - &gEventObjectGraphicsInfo_OldWoman1, + &gEventObjectGraphicsInfo_Woman2, + &gEventObjectGraphicsInfo_ExpertM, + &gEventObjectGraphicsInfo_ExpertF, &gEventObjectGraphicsInfo_Man2, + &gEventObjectGraphicsInfo_Woman3, + &gEventObjectGraphicsInfo_PokefanM, &gEventObjectGraphicsInfo_Woman4, - &gEventObjectGraphicsInfo_Man3, - &gEventObjectGraphicsInfo_Woman5, &gEventObjectGraphicsInfo_Cook, - &gEventObjectGraphicsInfo_Woman6, - &gEventObjectGraphicsInfo_OldMan2, - &gEventObjectGraphicsInfo_OldWoman2, + &gEventObjectGraphicsInfo_LinkReceptionist, + &gEventObjectGraphicsInfo_OldMan, + &gEventObjectGraphicsInfo_OldWoman, &gEventObjectGraphicsInfo_Camper, &gEventObjectGraphicsInfo_Picnicker, - &gEventObjectGraphicsInfo_Man4, - &gEventObjectGraphicsInfo_Woman7, + &gEventObjectGraphicsInfo_Man3, + &gEventObjectGraphicsInfo_Woman5, &gEventObjectGraphicsInfo_Youngster, &gEventObjectGraphicsInfo_BugCatcher, &gEventObjectGraphicsInfo_PsychicM, @@ -315,8 +315,8 @@ const struct EventObjectGraphicsInfo *const gEventObjectGraphicsInfoPointers[] = &gEventObjectGraphicsInfo_BerryTreeLateStages, &gEventObjectGraphicsInfo_BrendanAcroBike, &gEventObjectGraphicsInfo_ProfBirch, + &gEventObjectGraphicsInfo_Man4, &gEventObjectGraphicsInfo_Man5, - &gEventObjectGraphicsInfo_Man6, &gEventObjectGraphicsInfo_ReporterM, &gEventObjectGraphicsInfo_ReporterF, &gEventObjectGraphicsInfo_Bard, @@ -366,7 +366,7 @@ const struct EventObjectGraphicsInfo *const gEventObjectGraphicsInfoPointers[] = &gEventObjectGraphicsInfo_MovingBox, &gEventObjectGraphicsInfo_CableCar, &gEventObjectGraphicsInfo_Scientist2, - &gEventObjectGraphicsInfo_Man7, + &gEventObjectGraphicsInfo_DevonEmployee, &gEventObjectGraphicsInfo_AquaMemberM, &gEventObjectGraphicsInfo_AquaMemberF, &gEventObjectGraphicsInfo_MagmaMemberM, @@ -439,8 +439,8 @@ const struct EventObjectGraphicsInfo *const gEventObjectGraphicsInfoPointers[] = &gEventObjectGraphicsInfo_BigRegisteelDoll, &gEventObjectGraphicsInfo_Latias, &gEventObjectGraphicsInfo_Latios, - &gEventObjectGraphicsInfo_Boy5, - &gEventObjectGraphicsInfo_ContestOldMan, + &gEventObjectGraphicsInfo_GameboyKid, + &gEventObjectGraphicsInfo_ContestJudge, &gEventObjectGraphicsInfo_BrendanWatering, &gEventObjectGraphicsInfo_MayWatering, &gEventObjectGraphicsInfo_BrendanDecorating, diff --git a/src/data/field_event_obj/event_object_pic_tables.h b/src/data/field_event_obj/event_object_pic_tables.h index 40a6ad61c..bd1ad1a25 100755 --- a/src/data/field_event_obj/event_object_pic_tables.h +++ b/src/data/field_event_obj/event_object_pic_tables.h @@ -109,28 +109,28 @@ const struct SpriteFrameImage gEventObjectPicTable_QuintyPlump[] = { overworld_frame(gEventObjectPic_QuintyPlump, 4, 4, 6), }; -const struct SpriteFrameImage gEventObjectPicTable_LittleBoy1[] = { - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 0), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 1), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 2), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 3), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 4), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 5), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 6), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 7), - overworld_frame(gEventObjectPic_LittleBoy1, 2, 2, 8), -}; - -const struct SpriteFrameImage gEventObjectPicTable_LittleGirl1[] = { - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 0), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 1), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 2), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 3), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 4), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 5), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 6), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 7), - overworld_frame(gEventObjectPic_LittleGirl1, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_NinjaBoy[] = { + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 0), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 1), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 2), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 3), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 4), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 5), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 6), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 7), + overworld_frame(gEventObjectPic_NinjaBoy, 2, 2, 8), +}; + +const struct SpriteFrameImage gEventObjectPicTable_Twin[] = { + overworld_frame(gEventObjectPic_Twin, 2, 4, 0), + overworld_frame(gEventObjectPic_Twin, 2, 4, 1), + overworld_frame(gEventObjectPic_Twin, 2, 4, 2), + overworld_frame(gEventObjectPic_Twin, 2, 4, 3), + overworld_frame(gEventObjectPic_Twin, 2, 4, 4), + overworld_frame(gEventObjectPic_Twin, 2, 4, 5), + overworld_frame(gEventObjectPic_Twin, 2, 4, 6), + overworld_frame(gEventObjectPic_Twin, 2, 4, 7), + overworld_frame(gEventObjectPic_Twin, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Boy1[] = { @@ -181,28 +181,28 @@ const struct SpriteFrameImage gEventObjectPicTable_Girl2[] = { overworld_frame(gEventObjectPic_Girl2, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_LittleBoy2[] = { - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 0), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 1), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 2), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 3), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 4), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 5), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 6), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 7), - overworld_frame(gEventObjectPic_LittleBoy2, 2, 2, 8), +const struct SpriteFrameImage gEventObjectPicTable_LittleBoy[] = { + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 0), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 1), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 2), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 3), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 4), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 5), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 6), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 7), + overworld_frame(gEventObjectPic_LittleBoy, 2, 2, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_LittleGirl2[] = { - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 0), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 1), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 2), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 3), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 4), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 5), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 6), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 7), - overworld_frame(gEventObjectPic_LittleGirl2, 2, 2, 8), +const struct SpriteFrameImage gEventObjectPicTable_LittleGirl[] = { + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 0), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 1), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 2), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 3), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 4), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 5), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 6), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 7), + overworld_frame(gEventObjectPic_LittleGirl, 2, 2, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Boy3[] = { @@ -229,16 +229,16 @@ const struct SpriteFrameImage gEventObjectPicTable_Girl3[] = { overworld_frame(gEventObjectPic_Girl3, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Boy4[] = { - overworld_frame(gEventObjectPic_Boy4, 2, 4, 0), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 1), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 2), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 3), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 4), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 5), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 6), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 7), - overworld_frame(gEventObjectPic_Boy4, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_RichBoy[] = { + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 0), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 1), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 2), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 3), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 4), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 5), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 6), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 7), + overworld_frame(gEventObjectPic_RichBoy, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Woman1[] = { @@ -265,16 +265,16 @@ const struct SpriteFrameImage gEventObjectPicTable_FatMan[] = { overworld_frame(gEventObjectPic_FatMan, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Woman2[] = { - overworld_frame(gEventObjectPic_Woman2, 2, 4, 0), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 1), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 2), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 3), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 4), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 5), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 6), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 7), - overworld_frame(gEventObjectPic_Woman2, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_PokefanF[] = { + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 0), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 1), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 2), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 3), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 4), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 5), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 6), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 7), + overworld_frame(gEventObjectPic_PokefanF, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Man1[] = { @@ -289,40 +289,40 @@ const struct SpriteFrameImage gEventObjectPicTable_Man1[] = { overworld_frame(gEventObjectPic_Man1, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Woman3[] = { - overworld_frame(gEventObjectPic_Woman3, 2, 4, 0), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 1), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 2), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 3), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 4), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 5), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 6), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 7), - overworld_frame(gEventObjectPic_Woman3, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_Woman2[] = { + overworld_frame(gEventObjectPic_Woman2, 2, 4, 0), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 1), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 2), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 3), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 4), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 5), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 6), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 7), + overworld_frame(gEventObjectPic_Woman2, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_OldMan1[] = { - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 0), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 1), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 2), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 3), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 4), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 5), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 6), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 7), - overworld_frame(gEventObjectPic_OldMan1, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_ExpertM[] = { + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 0), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 1), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 2), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 3), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 4), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 5), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 6), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 7), + overworld_frame(gEventObjectPic_ExpertM, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_OldWoman1[] = { - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 0), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 1), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 2), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 3), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 4), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 5), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 6), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 7), - overworld_frame(gEventObjectPic_OldWoman1, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_ExpertF[] = { + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 0), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 1), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 2), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 3), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 4), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 5), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 6), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 7), + overworld_frame(gEventObjectPic_ExpertF, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Man2[] = { @@ -337,6 +337,30 @@ const struct SpriteFrameImage gEventObjectPicTable_Man2[] = { overworld_frame(gEventObjectPic_Man2, 2, 4, 8), }; +const struct SpriteFrameImage gEventObjectPicTable_Woman3[] = { + overworld_frame(gEventObjectPic_Woman3, 2, 4, 0), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 1), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 2), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 3), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 4), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 5), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 6), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 7), + overworld_frame(gEventObjectPic_Woman3, 2, 4, 8), +}; + +const struct SpriteFrameImage gEventObjectPicTable_PokefanM[] = { + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 0), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 1), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 2), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 3), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 4), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 5), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 6), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 7), + overworld_frame(gEventObjectPic_PokefanM, 2, 4, 8), +}; + const struct SpriteFrameImage gEventObjectPicTable_Woman4[] = { overworld_frame(gEventObjectPic_Woman4, 2, 4, 0), overworld_frame(gEventObjectPic_Woman4, 2, 4, 1), @@ -349,30 +373,6 @@ const struct SpriteFrameImage gEventObjectPicTable_Woman4[] = { overworld_frame(gEventObjectPic_Woman4, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Man3[] = { - overworld_frame(gEventObjectPic_Man3, 2, 4, 0), - overworld_frame(gEventObjectPic_Man3, 2, 4, 1), - overworld_frame(gEventObjectPic_Man3, 2, 4, 2), - overworld_frame(gEventObjectPic_Man3, 2, 4, 3), - overworld_frame(gEventObjectPic_Man3, 2, 4, 4), - overworld_frame(gEventObjectPic_Man3, 2, 4, 5), - overworld_frame(gEventObjectPic_Man3, 2, 4, 6), - overworld_frame(gEventObjectPic_Man3, 2, 4, 7), - overworld_frame(gEventObjectPic_Man3, 2, 4, 8), -}; - -const struct SpriteFrameImage gEventObjectPicTable_Woman5[] = { - overworld_frame(gEventObjectPic_Woman5, 2, 4, 0), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 1), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 2), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 3), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 4), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 5), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 6), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 7), - overworld_frame(gEventObjectPic_Woman5, 2, 4, 8), -}; - const struct SpriteFrameImage gEventObjectPicTable_Cook[] = { overworld_frame(gEventObjectPic_Cook, 2, 4, 0), overworld_frame(gEventObjectPic_Cook, 2, 4, 1), @@ -385,40 +385,40 @@ const struct SpriteFrameImage gEventObjectPicTable_Cook[] = { overworld_frame(gEventObjectPic_Cook, 2, 4, 2), }; -const struct SpriteFrameImage gEventObjectPicTable_Woman6[] = { - overworld_frame(gEventObjectPic_Woman6, 2, 4, 0), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 1), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 2), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 3), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 4), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 5), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 6), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 7), - overworld_frame(gEventObjectPic_Woman6, 2, 4, 8), -}; - -const struct SpriteFrameImage gEventObjectPicTable_OldMan2[] = { - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 0), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 1), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 2), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 0), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 0), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 1), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 1), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 2), - overworld_frame(gEventObjectPic_OldMan2, 2, 4, 2), -}; - -const struct SpriteFrameImage gEventObjectPicTable_OldWoman2[] = { - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 0), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 1), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 2), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 3), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 4), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 5), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 6), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 7), - overworld_frame(gEventObjectPic_OldWoman2, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_LinkReceptionist[] = { + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 0), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 1), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 2), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 3), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 4), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 5), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 6), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 7), + overworld_frame(gEventObjectPic_LinkReceptionist, 2, 4, 8), +}; + +const struct SpriteFrameImage gEventObjectPicTable_OldMan[] = { + overworld_frame(gEventObjectPic_OldMan, 2, 4, 0), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 1), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 2), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 0), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 0), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 1), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 1), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 2), + overworld_frame(gEventObjectPic_OldMan, 2, 4, 2), +}; + +const struct SpriteFrameImage gEventObjectPicTable_OldWoman[] = { + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 0), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 1), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 2), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 3), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 4), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 5), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 6), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 7), + overworld_frame(gEventObjectPic_OldWoman, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Camper[] = { @@ -445,28 +445,28 @@ const struct SpriteFrameImage gEventObjectPicTable_Picnicker[] = { overworld_frame(gEventObjectPic_Picnicker, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Man4[] = { - overworld_frame(gEventObjectPic_Man4, 2, 4, 0), - overworld_frame(gEventObjectPic_Man4, 2, 4, 1), - overworld_frame(gEventObjectPic_Man4, 2, 4, 2), - overworld_frame(gEventObjectPic_Man4, 2, 4, 3), - overworld_frame(gEventObjectPic_Man4, 2, 4, 4), - overworld_frame(gEventObjectPic_Man4, 2, 4, 5), - overworld_frame(gEventObjectPic_Man4, 2, 4, 6), - overworld_frame(gEventObjectPic_Man4, 2, 4, 7), - overworld_frame(gEventObjectPic_Man4, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_Man3[] = { + overworld_frame(gEventObjectPic_Man3, 2, 4, 0), + overworld_frame(gEventObjectPic_Man3, 2, 4, 1), + overworld_frame(gEventObjectPic_Man3, 2, 4, 2), + overworld_frame(gEventObjectPic_Man3, 2, 4, 3), + overworld_frame(gEventObjectPic_Man3, 2, 4, 4), + overworld_frame(gEventObjectPic_Man3, 2, 4, 5), + overworld_frame(gEventObjectPic_Man3, 2, 4, 6), + overworld_frame(gEventObjectPic_Man3, 2, 4, 7), + overworld_frame(gEventObjectPic_Man3, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Woman7[] = { - overworld_frame(gEventObjectPic_Woman7, 2, 4, 0), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 1), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 2), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 3), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 4), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 5), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 6), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 7), - overworld_frame(gEventObjectPic_Woman7, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_Woman5[] = { + overworld_frame(gEventObjectPic_Woman5, 2, 4, 0), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 1), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 2), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 3), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 4), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 5), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 6), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 7), + overworld_frame(gEventObjectPic_Woman5, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_Youngster[] = { @@ -762,6 +762,18 @@ const struct SpriteFrameImage gEventObjectPicTable_ProfBirch[] = { overworld_frame(gEventObjectPic_ProfBirch, 2, 4, 8), }; +const struct SpriteFrameImage gEventObjectPicTable_Man4[] = { + overworld_frame(gEventObjectPic_Man4, 2, 4, 0), + overworld_frame(gEventObjectPic_Man4, 2, 4, 1), + overworld_frame(gEventObjectPic_Man4, 2, 4, 2), + overworld_frame(gEventObjectPic_Man4, 2, 4, 3), + overworld_frame(gEventObjectPic_Man4, 2, 4, 4), + overworld_frame(gEventObjectPic_Man4, 2, 4, 5), + overworld_frame(gEventObjectPic_Man4, 2, 4, 6), + overworld_frame(gEventObjectPic_Man4, 2, 4, 7), + overworld_frame(gEventObjectPic_Man4, 2, 4, 8), +}; + const struct SpriteFrameImage gEventObjectPicTable_Man5[] = { overworld_frame(gEventObjectPic_Man5, 2, 4, 0), overworld_frame(gEventObjectPic_Man5, 2, 4, 1), @@ -774,18 +786,6 @@ const struct SpriteFrameImage gEventObjectPicTable_Man5[] = { overworld_frame(gEventObjectPic_Man5, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Man6[] = { - overworld_frame(gEventObjectPic_Man6, 2, 4, 0), - overworld_frame(gEventObjectPic_Man6, 2, 4, 1), - overworld_frame(gEventObjectPic_Man6, 2, 4, 2), - overworld_frame(gEventObjectPic_Man6, 2, 4, 3), - overworld_frame(gEventObjectPic_Man6, 2, 4, 4), - overworld_frame(gEventObjectPic_Man6, 2, 4, 5), - overworld_frame(gEventObjectPic_Man6, 2, 4, 6), - overworld_frame(gEventObjectPic_Man6, 2, 4, 7), - overworld_frame(gEventObjectPic_Man6, 2, 4, 8), -}; - const struct SpriteFrameImage gEventObjectPicTable_ReporterM[] = { overworld_frame(gEventObjectPic_ReporterM, 2, 4, 0), overworld_frame(gEventObjectPic_ReporterM, 2, 4, 1), @@ -1122,16 +1122,16 @@ const struct SpriteFrameImage gEventObjectPicTable_Scientist2[] = { overworld_frame(gEventObjectPic_Scientist2, 2, 4, 8), }; -const struct SpriteFrameImage gEventObjectPicTable_Man7[] = { - overworld_frame(gEventObjectPic_Man7, 2, 4, 0), - overworld_frame(gEventObjectPic_Man7, 2, 4, 1), - overworld_frame(gEventObjectPic_Man7, 2, 4, 2), - overworld_frame(gEventObjectPic_Man7, 2, 4, 3), - overworld_frame(gEventObjectPic_Man7, 2, 4, 4), - overworld_frame(gEventObjectPic_Man7, 2, 4, 5), - overworld_frame(gEventObjectPic_Man7, 2, 4, 6), - overworld_frame(gEventObjectPic_Man7, 2, 4, 7), - overworld_frame(gEventObjectPic_Man7, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_DevonEmployee[] = { + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 0), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 1), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 2), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 3), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 4), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 5), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 6), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 7), + overworld_frame(gEventObjectPic_DevonEmployee, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_AquaMemberM[] = { @@ -1632,28 +1632,28 @@ const struct SpriteFrameImage gEventObjectPicTable_LatiasLatios[] = { overworld_frame(gEventObjectPic_LatiasLatios, 4, 4, 2), }; -const struct SpriteFrameImage gEventObjectPicTable_Boy5[] = { - overworld_frame(gEventObjectPic_Boy5, 2, 4, 0), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 1), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 2), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 0), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 0), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 1), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 1), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 2), - overworld_frame(gEventObjectPic_Boy5, 2, 4, 2), -}; - -const struct SpriteFrameImage gEventObjectPicTable_ContestOldMan[] = { - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 0), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 1), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 2), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 3), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 4), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 5), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 6), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 7), - overworld_frame(gEventObjectPic_ContestOldMan, 2, 4, 8), +const struct SpriteFrameImage gEventObjectPicTable_GameboyKid[] = { + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 0), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 1), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 2), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 0), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 0), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 1), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 1), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 2), + overworld_frame(gEventObjectPic_GameboyKid, 2, 4, 2), +}; + +const struct SpriteFrameImage gEventObjectPicTable_ContestJudge[] = { + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 0), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 1), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 2), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 3), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 4), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 5), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 6), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 7), + overworld_frame(gEventObjectPic_ContestJudge, 2, 4, 8), }; const struct SpriteFrameImage gEventObjectPicTable_BrendanWatering[] = { diff --git a/src/data/field_event_obj/field_effect_objects.h b/src/data/field_event_obj/field_effect_objects.h index 15fc73343..33fe66fe2 100755 --- a/src/data/field_event_obj/field_effect_objects.h +++ b/src/data/field_event_obj/field_effect_objects.h @@ -32,13 +32,13 @@ const struct SpriteFrameImage gFieldEffectObjectPicTable_ShadowExtraLarge[] = { obj_frame_tiles(gFieldEffectObjectPic_ShadowExtraLarge), }; -const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowSmall = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_8x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowSmall, gDummySpriteAffineAnimTable, oamc_shadow}; +const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowSmall = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_8x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowSmall, gDummySpriteAffineAnimTable, UpdateShadowFieldEffect}; -const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowMedium = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowMedium, gDummySpriteAffineAnimTable, oamc_shadow}; +const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowMedium = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowMedium, gDummySpriteAffineAnimTable, UpdateShadowFieldEffect}; -const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowLarge = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_32x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowLarge, gDummySpriteAffineAnimTable, oamc_shadow}; +const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowLarge = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_32x8, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowLarge, gDummySpriteAffineAnimTable, UpdateShadowFieldEffect}; -const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowExtraLarge = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_64x32, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowExtraLarge, gDummySpriteAffineAnimTable, oamc_shadow}; +const struct SpriteTemplate gFieldEffectObjectTemplate_ShadowExtraLarge = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_64x32, gFieldEffectObjectImageAnimTable_Shadow, gFieldEffectObjectPicTable_ShadowExtraLarge, gDummySpriteAffineAnimTable, UpdateShadowFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_TallGrass[] = { overworld_frame(gFieldEffectObjectPic_TallGrass, 2, 2, 0), @@ -63,7 +63,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_TallGrass[] = gFieldEffectObjectImageAnim_850CA84, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_TallGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_TallGrass, gFieldEffectObjectPicTable_TallGrass, gDummySpriteAffineAnimTable, unc_grass_normal}; +const struct SpriteTemplate gFieldEffectObjectTemplate_TallGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_TallGrass, gFieldEffectObjectPicTable_TallGrass, gDummySpriteAffineAnimTable, UpdateTallGrassFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Ripple[] = { overworld_frame(gFieldEffectObjectPic_Ripple, 2, 2, 0), @@ -116,7 +116,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_Ash[] = gFieldEffectObjectImageAnim_850CB48, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_Ash = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_Ash, gFieldEffectObjectPicTable_Ash, gDummySpriteAffineAnimTable, sub_8155460}; +const struct SpriteTemplate gFieldEffectObjectTemplate_Ash = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_Ash, gFieldEffectObjectPicTable_Ash, gDummySpriteAffineAnimTable, UpdateAshFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_SurfBlob[] = { overworld_frame(gFieldEffectObjectPic_SurfBlob, 4, 4, 0), @@ -156,7 +156,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_SurfBlob[] = gFieldEffectObjectImageAnim_850CBAC, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_SurfBlob = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_32x32, gFieldEffectObjectImageAnimTable_SurfBlob, gFieldEffectObjectPicTable_SurfBlob, gDummySpriteAffineAnimTable, sub_8155658}; +const struct SpriteTemplate gFieldEffectObjectTemplate_SurfBlob = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_32x32, gFieldEffectObjectImageAnimTable_SurfBlob, gFieldEffectObjectPicTable_SurfBlob, gDummySpriteAffineAnimTable, UpdateSurfBlobFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Arrow[] = { overworld_frame(gFieldEffectObjectPic_Arrow, 2, 2, 0), @@ -289,7 +289,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_SandFootprints[] = gFieldEffectObjectImageAnim_850CD30, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_SandFootprints = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_SandFootprints, gFieldEffectObjectPicTable_SandFootprints, gDummySpriteAffineAnimTable, sub_8154C60}; +const struct SpriteTemplate gFieldEffectObjectTemplate_SandFootprints = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_SandFootprints, gFieldEffectObjectPicTable_SandFootprints, gDummySpriteAffineAnimTable, UpdateFootprintsTireTracksFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_DeepSandFootprints[] = { overworld_frame(gFieldEffectObjectPic_DeepSandFootprints, 2, 2, 0), @@ -329,7 +329,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_DeepSandFootprints[] gFieldEffectObjectImageAnim_850CD8C, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_DeepSandFootprints = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_DeepSandFootprints, gFieldEffectObjectPicTable_DeepSandFootprints, gDummySpriteAffineAnimTable, sub_8154C60}; +const struct SpriteTemplate gFieldEffectObjectTemplate_DeepSandFootprints = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_DeepSandFootprints, gFieldEffectObjectPicTable_DeepSandFootprints, gDummySpriteAffineAnimTable, UpdateFootprintsTireTracksFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_BikeTireTracks[] = { overworld_frame(gFieldEffectObjectPic_BikeTireTracks, 2, 2, 0), @@ -399,7 +399,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_BikeTireTracks[] = gFieldEffectObjectImageAnim_850CE18, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_BikeTireTracks = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_BikeTireTracks, gFieldEffectObjectPicTable_BikeTireTracks, gDummySpriteAffineAnimTable, sub_8154C60}; +const struct SpriteTemplate gFieldEffectObjectTemplate_BikeTireTracks = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_BikeTireTracks, gFieldEffectObjectPicTable_BikeTireTracks, gDummySpriteAffineAnimTable, UpdateFootprintsTireTracksFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_BikeHopBigSplash[] = { overworld_frame(gFieldEffectObjectPic_BikeHopBigSplash, 2, 2, 0), @@ -455,7 +455,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_Splash[] = gFieldEffectObjectImageAnim_850CEC8, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_Splash = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Splash, gFieldEffectObjectPicTable_Splash, gDummySpriteAffineAnimTable, sub_8154D90}; +const struct SpriteTemplate gFieldEffectObjectTemplate_Splash = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Splash, gFieldEffectObjectPicTable_Splash, gDummySpriteAffineAnimTable, UpdateSplashFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_BikeHopSmallSplash[] = { overworld_frame(gFieldEffectObjectPic_BikeHopSmallSplash, 2, 1, 0), @@ -502,7 +502,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_LongGrass[] = gFieldEffectObjectImageAnim_850CF70, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_LongGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_LongGrass, gFieldEffectObjectPicTable_LongGrass, gDummySpriteAffineAnimTable, unc_grass_tall}; +const struct SpriteTemplate gFieldEffectObjectTemplate_LongGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_LongGrass, gFieldEffectObjectPicTable_LongGrass, gDummySpriteAffineAnimTable, UpdateLongGrassFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Unknown16[] = { overworld_frame(gFieldEffectObjectPic_Unknown16, 2, 2, 0), @@ -631,7 +631,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_Unknown29[] = gFieldEffectObjectImageAnim_850D160, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_Unknown29 = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Unknown29, gFieldEffectObjectPicTable_Unknown29, gDummySpriteAffineAnimTable, sub_81559BC}; +const struct SpriteTemplate gFieldEffectObjectTemplate_Unknown29 = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x8, gFieldEffectObjectImageAnimTable_Unknown29, gFieldEffectObjectPicTable_Unknown29, gDummySpriteAffineAnimTable, UpdateSandPileFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Unknown20[] = { overworld_frame(gFieldEffectObjectPic_Unknown20, 2, 2, 0), @@ -769,7 +769,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_TreeDisguise[] = gFieldEffectObjectImageAnim_850D384, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_TreeDisguise = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_TreeDisguise, gFieldEffectObjectPicTable_TreeDisguise, gDummySpriteAffineAnimTable, sub_8155C88}; +const struct SpriteTemplate gFieldEffectObjectTemplate_TreeDisguise = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_TreeDisguise, gFieldEffectObjectPicTable_TreeDisguise, gDummySpriteAffineAnimTable, UpdateDisguiseFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_MountainDisguise[] = { overworld_frame(gFieldEffectObjectPic_MountainDisguise, 2, 4, 0), @@ -805,7 +805,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_MountainDisguise[] = gFieldEffectObjectImageAnim_850D404, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_MountainDisguise = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_MountainDisguise, gFieldEffectObjectPicTable_MountainDisguise, gDummySpriteAffineAnimTable, sub_8155C88}; +const struct SpriteTemplate gFieldEffectObjectTemplate_MountainDisguise = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_MountainDisguise, gFieldEffectObjectPicTable_MountainDisguise, gDummySpriteAffineAnimTable, UpdateDisguiseFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_SandDisguisePlaceholder[] = { overworld_frame(gFieldEffectObjectPic_SandDisguisePlaceholder, 2, 4, 0), @@ -817,7 +817,7 @@ const struct SpriteFrameImage gFieldEffectObjectPicTable_SandDisguisePlaceholder overworld_frame(gFieldEffectObjectPic_SandDisguisePlaceholder, 2, 4, 6), }; -const struct SpriteTemplate gFieldEffectObjectTemplate_SandDisguisePlaceholder = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_TreeDisguise, gFieldEffectObjectPicTable_SandDisguisePlaceholder, gDummySpriteAffineAnimTable, sub_8155C88}; +const struct SpriteTemplate gFieldEffectObjectTemplate_SandDisguisePlaceholder = {0xFFFF, 0xFFFF, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_TreeDisguise, gFieldEffectObjectPicTable_SandDisguisePlaceholder, gDummySpriteAffineAnimTable, UpdateDisguiseFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Bird[] = { obj_frame_tiles(gFieldEffectObjectPic_Bird), @@ -853,7 +853,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_ShortGrass[] = gFieldEffectObjectImageAnim_850D4D0, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_ShortGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_ShortGrass, gFieldEffectObjectPicTable_ShortGrass, gDummySpriteAffineAnimTable, sub_8154A10}; +const struct SpriteTemplate gFieldEffectObjectTemplate_ShortGrass = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_ShortGrass, gFieldEffectObjectPicTable_ShortGrass, gDummySpriteAffineAnimTable, UpdateShortGrassFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_HotSpringsWater[] = { obj_frame_tiles(gFieldEffectObjectPic_HotSpringsWater), @@ -870,7 +870,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_HotSpringsWater[] = gFieldEffectObjectImageAnim_850D500, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_HotSpringsWater = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_HotSpringsWater, gFieldEffectObjectPicTable_HotSpringsWater, gDummySpriteAffineAnimTable, sub_8155158}; +const struct SpriteTemplate gFieldEffectObjectTemplate_HotSpringsWater = {0xFFFF, 0x1005, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_HotSpringsWater, gFieldEffectObjectPicTable_HotSpringsWater, gDummySpriteAffineAnimTable, UpdateHotSpringsWaterFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_JumpOutOfAsh[] = { overworld_frame(gFieldEffectObjectPic_JumpOutOfAsh, 2, 2, 0), @@ -953,7 +953,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_Bubbles[] = gFieldEffectObjectImageAnim_850D624, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_Bubbles = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_Bubbles, gFieldEffectObjectPicTable_Bubbles, gDummySpriteAffineAnimTable, sub_8155AEC}; +const struct SpriteTemplate gFieldEffectObjectTemplate_Bubbles = {0xFFFF, 0x1004, &gEventObjectBaseOam_16x32, gFieldEffectObjectImageAnimTable_Bubbles, gFieldEffectObjectPicTable_Bubbles, gDummySpriteAffineAnimTable, UpdateBubblesFieldEffect}; const struct SpriteFrameImage gFieldEffectObjectPicTable_Unknown35[] = { overworld_frame(gFieldEffectObjectPic_Unknown35, 2, 2, 0), @@ -973,7 +973,7 @@ const union AnimCmd *const gFieldEffectObjectImageAnimTable_Unknown35[] = gFieldEffectObjectImageAnim_850D674, }; -const struct SpriteTemplate gFieldEffectObjectTemplate_Unknown35 = {0xFFFF, 0x100F, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_Unknown35, gFieldEffectObjectPicTable_Unknown35, gDummySpriteAffineAnimTable, sub_8155E50}; +const struct SpriteTemplate gFieldEffectObjectTemplate_Unknown35 = {0xFFFF, 0x100F, &gEventObjectBaseOam_16x16, gFieldEffectObjectImageAnimTable_Unknown35, gFieldEffectObjectPicTable_Unknown35, gDummySpriteAffineAnimTable, UpdateSparkleFieldEffect}; const struct SpritePalette gFieldEffectObjectPaletteInfo3 = {gFieldEffectObjectPalette3, 0x100F}; diff --git a/src/data/pokemon_graphics/back_pic_coordinates.h b/src/data/pokemon_graphics/back_pic_coordinates.h index f54b409e4..877bf3475 100644 --- a/src/data/pokemon_graphics/back_pic_coordinates.h +++ b/src/data/pokemon_graphics/back_pic_coordinates.h @@ -1,4 +1,4 @@ -const struct MonCoords gUnknown_083021D8[] = +const struct MonCoords gMonBackPicCoords[] = { {0x88, 0x00}, // SPECIES_NONE {0x64, 0x10}, // SPECIES_BULBASAUR diff --git a/src/decoration.c b/src/decoration.c index 94edbe956..796cc794a 100644 --- a/src/decoration.c +++ b/src/decoration.c @@ -1171,7 +1171,7 @@ void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor) { decLeft = mapX + j; behavior = GetBehaviorByMetatileId(0x200 + gDecorations[decor].tiles[i * decWidth + j]); - if (MetatileBehavior_IsMB_B9(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12))) + if (MetatileBehavior_IsSecretBaseImpassable(behavior) == TRUE || (gDecorations[decor].permission != DECORPERM_PASS_FLOOR && (behavior >> 12))) { flags = 0xc00; } @@ -1179,7 +1179,7 @@ void sub_8127B90(u16 mapX, u16 mapY, u8 decWidth, u8 decHeight, u16 decor) { flags = 0x000; } - if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE) + if (gDecorations[decor].permission != DECORPERM_NA_WALL && MetatileBehavior_IsSecretBaseNorthWall(MapGridGetMetatileBehaviorAt(decLeft, decBottom)) == TRUE) { v0 = 1; } @@ -1446,7 +1446,7 @@ void sub_8128414(u8 taskId) bool8 sub_8128484(u8 behaviorAt, u16 behaviorBy) { - if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE || behaviorBy != 0) + if (MetatileBehavior_IsBlockDecoration(behaviorAt) != TRUE || behaviorBy != 0) { return FALSE; } @@ -1464,9 +1464,9 @@ bool8 sub_81284AC(u8 taskId, s16 x, s16 y, u16 decor) bool8 sub_81284F4(u16 behaviorAt, const struct Decoration *decoration) { - if (MetatileBehavior_IsMB_B3(behaviorAt) != TRUE) + if (MetatileBehavior_IsBlockDecoration(behaviorAt) != TRUE) { - if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsMB_C2(behaviorAt) == TRUE) + if (decoration->id == DECOR_SOLID_BOARD && MetatileBehavior_IsSecretBaseHole(behaviorAt) == TRUE) { return TRUE; } @@ -1548,7 +1548,7 @@ bool8 sub_812853C(u8 taskId, const struct Decoration *decoration) curX = gTasks[taskId].data[0] + j; behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY); behaviorBy = GetBehaviorByMetatileId(0x200 + decoration->tiles[j]) & 0xf000; - if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsMB_B7(behaviorAt)) + if (!MetatileBehavior_IsNormal(behaviorAt) && !MetatileBehavior_IsSecretBaseNorthWall(behaviorAt)) { return FALSE; } @@ -1570,7 +1570,7 @@ bool8 sub_812853C(u8 taskId, const struct Decoration *decoration) for (j=0; j<mapX; j++) { curX = gTasks[taskId].data[0] + j; - if (!MetatileBehavior_IsMB_B7(MapGridGetMetatileBehaviorAt(curX, curY))) + if (!MetatileBehavior_IsSecretBaseNorthWall(MapGridGetMetatileBehaviorAt(curX, curY))) { return FALSE; } @@ -1589,14 +1589,14 @@ bool8 sub_812853C(u8 taskId, const struct Decoration *decoration) behaviorAt = MapGridGetMetatileBehaviorAt(curX, curY); if (decoration->shape == DECORSHAPE_1x2) { - if (!MetatileBehavior_IsMB_C3(behaviorAt)) + if (!MetatileBehavior_IsLargeMatCenter(behaviorAt)) { return FALSE; } } - else if (!MetatileBehavior_IsMB_B5(behaviorAt)) + else if (!MetatileBehavior_IsSecretBaseLargeMatEdge(behaviorAt)) { - if (!MetatileBehavior_IsMB_C3(behaviorAt)) + if (!MetatileBehavior_IsLargeMatCenter(behaviorAt)) { return FALSE; } @@ -2385,7 +2385,7 @@ void sub_8129C74(u8 taskId) { data = gTasks[taskId].data; behavior = MapGridGetMetatileBehaviorAt(data[0], data[1]); - if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsMB_C5(behavior) == TRUE) + if (MetatileBehavior_IsSecretBasePC(behavior) == TRUE || MetatileBehavior_IsPlayerRoomPCOn(behavior) == TRUE) { gSprites[sDecor_CameraSpriteObjectIdx1].invisible = FALSE; gSprites[sDecor_CameraSpriteObjectIdx1].callback = SpriteCallbackDummy; diff --git a/src/easy_chat.c b/src/easy_chat.c index fbf4c0e70..7d25d1430 100644 --- a/src/easy_chat.c +++ b/src/easy_chat.c @@ -352,7 +352,7 @@ void easy_chat_input_maybe(void) words = &gSaveBlock1Ptr->lilycoveLady.quiz.unk_014; break; case 19: - words = (u16 *)&gSaveBlock2Ptr->field_DC[0].field_0[0x28]; + words = gSaveBlock2Ptr->apprentices[0].easyChatWords; break; case 20: words = sub_801B058(); diff --git a/src/event_object_movement.c b/src/event_object_movement.c index 2b85e751f..8c5c92473 100644 --- a/src/event_object_movement.c +++ b/src/event_object_movement.c @@ -1868,7 +1868,7 @@ static void sub_808E1B8(u8 eventObjectId, s16 x, s16 y) if (eventObject->movementType == 0x0b) { SetPlayerAvatarEventObjectIdAndObjectId(eventObjectId, spriteId); - eventObject->warpArrowSpriteId = sub_8154228(); + eventObject->warpArrowSpriteId = CreateWarpArrowSprite(); } if (subspriteTables != NULL) { @@ -2024,7 +2024,7 @@ const struct EventObjectGraphicsInfo *GetEventObjectGraphicsInfo(u8 graphicsId) } if (graphicsId >= NUM_OBJECT_GRAPHICS_INFO) { - graphicsId = EVENT_OBJ_GFX_LITTLE_BOY_1; + graphicsId = EVENT_OBJ_GFX_NINJA_BOY; } return gEventObjectGraphicsInfoPointers[graphicsId]; } @@ -7721,7 +7721,7 @@ static void GetGroundEffectFlags_Tracks(struct EventObject *eventObj, u32 *flags *flags |= GROUND_EFFECT_FLAG_DEEP_SAND; } else if (MetatileBehavior_IsSandOrDeepSand(eventObj->previousMetatileBehavior) - || MetatileBehavior_IsUnusedFootprintMetatile(eventObj->previousMetatileBehavior)) + || MetatileBehavior_IsFootprints(eventObj->previousMetatileBehavior)) { *flags |= GROUND_EFFECT_FLAG_SAND; } @@ -8206,7 +8206,7 @@ void GroundEffect_JumpOnTallGrass(struct EventObject *eventObj, struct Sprite *s gFieldEffectArguments[3] = 2; FieldEffectStart(FLDEFF_JUMP_TALL_GRASS); - spriteId = sub_81546C8( + spriteId = FindTallGrassFieldEffectSpriteId( eventObj->localId, eventObj->mapNum, eventObj->mapGroup, eventObj->currentCoords.x, eventObj->currentCoords.y); if (spriteId == MAX_SPRITES) @@ -8843,14 +8843,14 @@ void sub_8097B78(u8 var1, u8 var2) StartSpriteAnim(&gSprites[spriteId], GetFaceDirectionAnimNum(var2)); } -void sub_8097BB4(u8 var1, u8 var2) +void sub_8097BB4(u8 var1, u8 graphicsId) { int spriteId = sub_8097B2C(var1); if(spriteId != MAX_SPRITES) { struct Sprite *sprite = &gSprites[spriteId]; - const struct EventObjectGraphicsInfo *gfxInfo = GetEventObjectGraphicsInfo(var2); + const struct EventObjectGraphicsInfo *gfxInfo = GetEventObjectGraphicsInfo(graphicsId); u16 tileNum = sprite->oam.tileNum; sprite->oam = *gfxInfo->oam; diff --git a/src/evolution_scene.c b/src/evolution_scene.c index 91ac90b1b..c00aaeb15 100644 --- a/src/evolution_scene.c +++ b/src/evolution_scene.c @@ -25,7 +25,7 @@ #include "gpu_regs.h" #include "bg.h" #include "link.h" -#include "blend_palette.h" +#include "util.h" #include "trig.h" struct EvoInfo diff --git a/src/field_effect_helpers.c b/src/field_effect_helpers.c new file mode 100755 index 000000000..3534e0a71 --- /dev/null +++ b/src/field_effect_helpers.c @@ -0,0 +1,1776 @@ +#include "global.h" +#include "event_object_movement.h" +#include "field_camera.h" +#include "field_effect.h" +#include "field_effect_helpers.h" +#include "field_weather.h" +#include "fieldmap.h" +#include "gpu_regs.h" +#include "metatile_behavior.h" +#include "sound.h" +#include "sprite.h" +#include "trig.h" +#include "constants/songs.h" + +#define EVENT_OBJ_PAL_TAG_NONE 0x11FF // duplicate of define in event_object_movement.c + +void UpdateObjectReflectionSprite(struct Sprite *); +void LoadObjectReflectionPalette(struct EventObject *eventObject, struct Sprite *sprite); +void LoadObjectHighBridgeReflectionPalette(struct EventObject *, u8); +void LoadObjectRegularReflectionPalette(struct EventObject *, u8); +void sub_81561FC(struct Sprite *, u8, u8); +void FadeFootprintsTireTracks_Step0(struct Sprite *); +void FadeFootprintsTireTracks_Step1(struct Sprite *); +void UpdateFeetInFlowingWaterFieldEffect(struct Sprite *); +void UpdateAshFieldEffect_Step0(struct Sprite *); +void UpdateAshFieldEffect_Step1(struct Sprite *); +void UpdateAshFieldEffect_Step2(struct Sprite *); +void sub_81556B0(struct EventObject *, struct Sprite *); +void sub_81556E8(struct EventObject *, struct Sprite *); +void sub_815577C(struct EventObject *, struct Sprite *, struct Sprite *); +void sub_8155850(struct Sprite *); +u32 ShowDisguiseFieldEffect(u8, u8, u8); + +void SetUpReflection(struct EventObject *eventObject, struct Sprite *sprite, bool8 stillReflection) +{ + struct Sprite *reflectionSprite; + + reflectionSprite = &gSprites[CreateCopySpriteAt(sprite, sprite->pos1.x, sprite->pos1.y, 0x98)]; + reflectionSprite->callback = UpdateObjectReflectionSprite; + reflectionSprite->oam.priority = 3; + reflectionSprite->oam.paletteNum = gReflectionEffectPaletteMap[reflectionSprite->oam.paletteNum]; + reflectionSprite->usingSheet = TRUE; + reflectionSprite->anims = gDummySpriteAnimTable; + StartSpriteAnim(reflectionSprite, 0); + reflectionSprite->affineAnims = gDummySpriteAffineAnimTable; + reflectionSprite->affineAnimBeginning = TRUE; + reflectionSprite->subspriteMode = SUBSPRITES_OFF; + reflectionSprite->data[0] = sprite->data[0]; + reflectionSprite->data[1] = eventObject->localId; + reflectionSprite->data[7] = stillReflection; + LoadObjectReflectionPalette(eventObject, reflectionSprite); + + if (!stillReflection) + reflectionSprite->oam.affineMode = ST_OAM_AFFINE_NORMAL; +} + +static s16 GetReflectionVerticalOffset(struct EventObject *eventObject) +{ + return GetEventObjectGraphicsInfo(eventObject->graphicsId)->height - 2; +} + +void LoadObjectReflectionPalette(struct EventObject *eventObject, struct Sprite *sprite) +{ + u8 bridgeType; + u16 bridgeReflectionVerticalOffsets[] = { 12, 28, 44 }; + sprite->data[2] = 0; + if (!GetEventObjectGraphicsInfo(eventObject->graphicsId)->disableReflectionPaletteLoad && ((bridgeType = MetatileBehavior_GetBridgeSth(eventObject->previousMetatileBehavior)) || (bridgeType = MetatileBehavior_GetBridgeSth(eventObject->currentMetatileBehavior)))) + { + sprite->data[2] = bridgeReflectionVerticalOffsets[bridgeType - 1]; + LoadObjectHighBridgeReflectionPalette(eventObject, sprite->oam.paletteNum); + } + else + { + LoadObjectRegularReflectionPalette(eventObject, sprite->oam.paletteNum); + } +} + +void LoadObjectRegularReflectionPalette(struct EventObject *eventObject, u8 paletteIndex) +{ + const struct EventObjectGraphicsInfo *graphicsInfo; + + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + if (graphicsInfo->paletteTag2 != EVENT_OBJ_PAL_TAG_NONE) + { + if (graphicsInfo->paletteSlot == 0) + { + LoadPlayerObjectReflectionPalette(graphicsInfo->paletteTag1, paletteIndex); + } + else if (graphicsInfo->paletteSlot == 10) + { + LoadSpecialObjectReflectionPalette(graphicsInfo->paletteTag1, paletteIndex); + } + else + { + PatchObjectPalette(GetObjectPaletteTag(paletteIndex), paletteIndex); + } + UpdateSpritePaletteWithWeather(paletteIndex); + } +} + +// When walking on a bridge high above water (Route 120), the reflection is a solid dark blue color. +// This is so the sprite blends in with the dark water metatile underneath the bridge. +void LoadObjectHighBridgeReflectionPalette(struct EventObject *eventObject, u8 paletteNum) +{ + const struct EventObjectGraphicsInfo *graphicsInfo; + + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + if (graphicsInfo->paletteTag2 != EVENT_OBJ_PAL_TAG_NONE) + { + PatchObjectPalette(graphicsInfo->paletteTag2, paletteNum); + UpdateSpritePaletteWithWeather(paletteNum); + } +} + +void UpdateObjectReflectionSprite(struct Sprite *reflectionSprite) +{ + struct EventObject *eventObject; + struct Sprite *mainSprite; + + eventObject = &gEventObjects[reflectionSprite->data[0]]; + mainSprite = &gSprites[eventObject->spriteId]; + if (!eventObject->active || !eventObject->hasReflection || eventObject->localId != reflectionSprite->data[1]) + { + reflectionSprite->inUse = FALSE; + } + else + { + reflectionSprite->oam.paletteNum = gReflectionEffectPaletteMap[mainSprite->oam.paletteNum]; + reflectionSprite->oam.shape = mainSprite->oam.shape; + reflectionSprite->oam.size = mainSprite->oam.size; + reflectionSprite->oam.matrixNum = mainSprite->oam.matrixNum | 0x10; + reflectionSprite->oam.tileNum = mainSprite->oam.tileNum; + reflectionSprite->subspriteTables = mainSprite->subspriteTables; + reflectionSprite->subspriteTableNum = mainSprite->subspriteTableNum; + reflectionSprite->invisible = mainSprite->invisible; + reflectionSprite->pos1.x = mainSprite->pos1.x; + // reflectionSprite->data[2] holds an additional vertical offset, used by the high bridges on Route 120 + reflectionSprite->pos1.y = mainSprite->pos1.y + GetReflectionVerticalOffset(eventObject) + reflectionSprite->data[2]; + reflectionSprite->centerToCornerVecX = mainSprite->centerToCornerVecX; + reflectionSprite->centerToCornerVecY = mainSprite->centerToCornerVecY; + reflectionSprite->pos2.x = mainSprite->pos2.x; + reflectionSprite->pos2.y = -mainSprite->pos2.y; + reflectionSprite->coordOffsetEnabled = mainSprite->coordOffsetEnabled; + + if (eventObject->unk3_3 == TRUE) + reflectionSprite->invisible = TRUE; + + // Check if the reflection is not still. + if (reflectionSprite->data[7] == FALSE) + { + // Sets the reflection sprite's rot/scale matrix to the appropriate + // matrix based on whether or not the main sprite is horizontally flipped. + // If the sprite is facing to the east, then it is flipped, and its matrixNum is 8. + reflectionSprite->oam.matrixNum = 0; + if (mainSprite->oam.matrixNum & 0x8) + reflectionSprite->oam.matrixNum = 1; + } + } +} + +extern const struct SpriteTemplate *const gFieldEffectObjectTemplatePointers[]; + +u8 CreateWarpArrowSprite(void) +{ + u8 spriteId; + struct Sprite *sprite; + + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[8], 0, 0, 0x52); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->oam.priority = 1; + sprite->coordOffsetEnabled = TRUE; + sprite->invisible = TRUE; + } + return spriteId; +} + +void SetSpriteInvisible(u8 spriteId) +{ + gSprites[spriteId].invisible = TRUE; +} + +void ShowWarpArrowSprite(u8 spriteId, u8 direction, s16 x, s16 y) +{ + s16 x2; + s16 y2; + struct Sprite *sprite; + + sprite = &gSprites[spriteId]; + if (sprite->invisible || sprite->data[0] != x || sprite->data[1] != y) + { + sub_8093038(x, y, &x2, &y2); + sprite = &gSprites[spriteId]; + sprite->pos1.x = x2 + 8; + sprite->pos1.y = y2 + 8; + sprite->invisible = FALSE; + sprite->data[0] = x; + sprite->data[1] = y; + StartSpriteAnim(sprite, direction - 1); + } +} + +const u8 gShadowEffectTemplateIds[] = { + 0, + 1, + 2, + 3 +}; + +const u16 gShadowVerticalOffsets[] = { + 4, + 4, + 4, + 16 +}; + +u32 FldEff_Shadow(void) +{ + u8 eventObjectId; + const struct EventObjectGraphicsInfo *graphicsInfo; + u8 spriteId; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + graphicsInfo = GetEventObjectGraphicsInfo(gEventObjects[eventObjectId].graphicsId); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[gShadowEffectTemplateIds[graphicsInfo->shadowSize]], 0, 0, 0x94); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].coordOffsetEnabled = TRUE; + gSprites[spriteId].data[0] = gFieldEffectArguments[0]; + gSprites[spriteId].data[1] = gFieldEffectArguments[1]; + gSprites[spriteId].data[2] = gFieldEffectArguments[2]; + gSprites[spriteId].data[3] = (graphicsInfo->height >> 1) - gShadowVerticalOffsets[graphicsInfo->shadowSize]; + } + return 0; +} + +void UpdateShadowFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + struct EventObject *eventObject; + struct Sprite *linkedSprite; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId)) + { + FieldEffectStop(sprite, FLDEFF_SHADOW); + } + else + { + eventObject = &gEventObjects[eventObjectId]; + linkedSprite = &gSprites[eventObject->spriteId]; + sprite->oam.priority = linkedSprite->oam.priority; + sprite->pos1.x = linkedSprite->pos1.x; + sprite->pos1.y = linkedSprite->pos1.y + sprite->data[3]; + if (!eventObject->active || !eventObject->hasShadow + || MetatileBehavior_IsPokeGrass(eventObject->currentMetatileBehavior) + || MetatileBehavior_IsSurfableWaterOrUnderwater(eventObject->currentMetatileBehavior) + || MetatileBehavior_IsSurfableWaterOrUnderwater(eventObject->previousMetatileBehavior) + || MetatileBehavior_IsReflective(eventObject->currentMetatileBehavior) + || MetatileBehavior_IsReflective(eventObject->previousMetatileBehavior)) + { + FieldEffectStop(sprite, FLDEFF_SHADOW); + } + } +} + +u32 FldEff_TallGrass(void) +{ + s16 x; + s16 y; + u8 spriteId; + struct Sprite *sprite; + + x = gFieldEffectArguments[0]; + y = gFieldEffectArguments[1]; + sub_80930E0(&x, &y, 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[4], x, y, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = gFieldEffectArguments[0]; + sprite->data[2] = gFieldEffectArguments[1]; + sprite->data[3] = gFieldEffectArguments[4]; + sprite->data[4] = gFieldEffectArguments[5]; + sprite->data[5] = gFieldEffectArguments[6]; + if (gFieldEffectArguments[7]) + { + SeekSpriteAnim(sprite, 4); + } + } + return 0; +} + +void UpdateTallGrassFieldEffect(struct Sprite *sprite) +{ + u8 mapNum; + u8 mapGroup; + u8 metatileBehavior; + u8 localId; + u8 eventObjectId; + struct EventObject *eventObject; + + mapNum = sprite->data[5] >> 8; + mapGroup = sprite->data[5]; + if (gCamera.active && (gSaveBlock1Ptr->location.mapNum != mapNum || gSaveBlock1Ptr->location.mapGroup != mapGroup)) + { + sprite->data[1] -= gCamera.x; + sprite->data[2] -= gCamera.y; + sprite->data[5] = ((u8)gSaveBlock1Ptr->location.mapNum << 8) | (u8)gSaveBlock1Ptr->location.mapGroup; + } + localId = sprite->data[3] >> 8; + mapNum = sprite->data[3]; + mapGroup = sprite->data[4]; + metatileBehavior = MapGridGetMetatileBehaviorAt(sprite->data[1], sprite->data[2]); + if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId) || !MetatileBehavior_IsTallGrass(metatileBehavior) || (sprite->data[7] && sprite->animEnded)) + { + FieldEffectStop(sprite, FLDEFF_TALL_GRASS); + } + else + { + eventObject = &gEventObjects[eventObjectId]; + if ((eventObject->currentCoords.x != sprite->data[1] || eventObject->currentCoords.y != sprite->data[2]) && (eventObject->previousCoords.x != sprite->data[1] || eventObject->previousCoords.y != sprite->data[2])) + sprite->data[7] = TRUE; + + metatileBehavior = 0; + if (sprite->animCmdIndex == 0) + metatileBehavior = 4; + + UpdateEventObjectSpriteVisibility(sprite, 0); + sub_81561FC(sprite, sprite->data[0], metatileBehavior); + } +} + +u32 FldEff_JumpTallGrass(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[10], gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = 12; + } + return 0; +} + +u8 FindTallGrassFieldEffectSpriteId(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) +{ + struct Sprite *sprite; + u8 i; + + for (i = 0; i < MAX_SPRITES; i ++) + { + if (gSprites[i].inUse) + { + sprite = &gSprites[i]; + if (sprite->callback == UpdateTallGrassFieldEffect && (x == sprite->data[1] && y == sprite->data[2]) && (localId == (u8)(sprite->data[3] >> 8) && mapNum == (sprite->data[3] & 0xFF) && mapGroup == sprite->data[4])) + return i; + } + } + + return MAX_SPRITES; +} + +u32 FldEff_LongGrass(void) +{ + s16 x; + s16 y; + u8 spriteId; + struct Sprite *sprite; + + x = gFieldEffectArguments[0]; + y = gFieldEffectArguments[1]; + sub_80930E0(&x, &y, 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[15], x, y, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = ZCoordToPriority(gFieldEffectArguments[2]); + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = gFieldEffectArguments[0]; + sprite->data[2] = gFieldEffectArguments[1]; + sprite->data[3] = gFieldEffectArguments[4]; + sprite->data[4] = gFieldEffectArguments[5]; + sprite->data[5] = gFieldEffectArguments[6]; + if (gFieldEffectArguments[7]) + { + SeekSpriteAnim(sprite, 6); + } + } + return 0; +} + +void UpdateLongGrassFieldEffect(struct Sprite *sprite) +{ + u8 mapNum; + u8 mapGroup; + u8 metatileBehavior; + u8 localId; + u8 eventObjectId; + struct EventObject *eventObject; + + mapNum = sprite->data[5] >> 8; + mapGroup = sprite->data[5]; + if (gCamera.active && (gSaveBlock1Ptr->location.mapNum != mapNum || gSaveBlock1Ptr->location.mapGroup != mapGroup)) + { + sprite->data[1] -= gCamera.x; + sprite->data[2] -= gCamera.y; + sprite->data[5] = ((u8)gSaveBlock1Ptr->location.mapNum << 8) | (u8)gSaveBlock1Ptr->location.mapGroup; + } + localId = sprite->data[3] >> 8; + mapNum = sprite->data[3]; + mapGroup = sprite->data[4]; + metatileBehavior = MapGridGetMetatileBehaviorAt(sprite->data[1], sprite->data[2]); + if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId) || !MetatileBehavior_IsLongGrass(metatileBehavior) || (sprite->data[7] && sprite->animEnded)) + { + FieldEffectStop(sprite, FLDEFF_LONG_GRASS); + } + else + { + eventObject = &gEventObjects[eventObjectId]; + if ((eventObject->currentCoords.x != sprite->data[1] || eventObject->currentCoords.y != sprite->data[2]) && (eventObject->previousCoords.x != sprite->data[1] || eventObject->previousCoords.y != sprite->data[2])) + { + sprite->data[7] = TRUE; + } + UpdateEventObjectSpriteVisibility(sprite, 0); + sub_81561FC(sprite, sprite->data[0], 0); + } +} + +u32 FldEff_JumpLongGrass(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[16], gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = 18; + } + return 0; +} + +u32 FldEff_ShortGrass(void) +{ + u8 eventObjectId; + struct EventObject *eventObject; + u8 spriteId; + struct Sprite *sprite; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + eventObject = &gEventObjects[eventObjectId]; + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[30], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &(gSprites[spriteId]); + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gSprites[eventObject->spriteId].oam.priority; + sprite->data[0] = gFieldEffectArguments[0]; + sprite->data[1] = gFieldEffectArguments[1]; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->data[3] = gSprites[eventObject->spriteId].pos1.x; + sprite->data[4] = gSprites[eventObject->spriteId].pos1.y; + } + return 0; +} + +void UpdateShortGrassFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + s16 x; + s16 y; + const struct EventObjectGraphicsInfo *graphicsInfo; + struct Sprite *linkedSprite; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId) || !gEventObjects[eventObjectId].inShortGrass) + { + FieldEffectStop(sprite, FLDEFF_SHORT_GRASS); + } + else + { + graphicsInfo = GetEventObjectGraphicsInfo(gEventObjects[eventObjectId].graphicsId); + linkedSprite = &gSprites[gEventObjects[eventObjectId].spriteId]; + y = linkedSprite->pos1.y; + x = linkedSprite->pos1.x; + if (x != sprite->data[3] || y != sprite->data[4]) + { + sprite->data[3] = x; + sprite->data[4] = y; + if (sprite->animEnded) + { + StartSpriteAnim(sprite, 0); + } + } + sprite->pos1.x = x; + sprite->pos1.y = y; + sprite->pos2.y = (graphicsInfo->height >> 1) - 8; + sprite->subpriority = linkedSprite->subpriority - 1; + sprite->oam.priority = linkedSprite->oam.priority; + UpdateEventObjectSpriteVisibility(sprite, linkedSprite->invisible); + } +} + +u32 FldEff_SandFootprints(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[11], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[7] = FLDEFF_SAND_FOOTPRINTS; + StartSpriteAnim(sprite, gFieldEffectArguments[4]); + } + return 0; +} + +u32 FldEff_DeepSandFootprints(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[23], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[7] = FLDEFF_DEEP_SAND_FOOTPRINTS; + StartSpriteAnim(sprite, gFieldEffectArguments[4]); + } + return spriteId; +} + +u32 FldEff_BikeTireTracks(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[27], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[7] = FLDEFF_BIKE_TIRE_TRACKS; + StartSpriteAnim(sprite, gFieldEffectArguments[4]); + } + return spriteId; +} + +void (*const gFadeFootprintsTireTracksFuncs[])(struct Sprite *) = { + FadeFootprintsTireTracks_Step0, + FadeFootprintsTireTracks_Step1 +}; + +void UpdateFootprintsTireTracksFieldEffect(struct Sprite *sprite) +{ + gFadeFootprintsTireTracksFuncs[sprite->data[0]](sprite); +} + +void FadeFootprintsTireTracks_Step0(struct Sprite *sprite) +{ + // Wait 40 frames before the flickering starts. + if (++sprite->data[1] > 40) + sprite->data[0] = 1; + + UpdateEventObjectSpriteVisibility(sprite, FALSE); +} + +void FadeFootprintsTireTracks_Step1(struct Sprite *sprite) +{ + sprite->invisible ^= 1; + sprite->data[1]++; + UpdateEventObjectSpriteVisibility(sprite, sprite->invisible); + if (sprite->data[1] > 56) + { + FieldEffectStop(sprite, sprite->data[7]); + } +} + +u32 FldEff_Splash(void) +{ + u8 eventObjectId; + struct EventObject *eventObject; + u8 spriteId; + struct Sprite *sprite; + const struct EventObjectGraphicsInfo *graphicsInfo; + struct Sprite *linkedSprite; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + eventObject = &gEventObjects[eventObjectId]; + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[13], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + linkedSprite = &gSprites[eventObject->spriteId]; + sprite->oam.priority = linkedSprite->oam.priority; + sprite->data[0] = gFieldEffectArguments[0]; + sprite->data[1] = gFieldEffectArguments[1]; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->pos2.y = (graphicsInfo->height >> 1) - 4; + PlaySE(SE_MIZU); + } + return 0; +} + +void UpdateSplashFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + + if (sprite->animEnded || TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId)) + { + FieldEffectStop(sprite, FLDEFF_SPLASH); + } + else + { + sprite->pos1.x = gSprites[gEventObjects[eventObjectId].spriteId].pos1.x; + sprite->pos1.y = gSprites[gEventObjects[eventObjectId].spriteId].pos1.y; + UpdateEventObjectSpriteVisibility(sprite, FALSE); + } +} + +u32 FldEff_JumpSmallSplash(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[14], gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = FLDEFF_JUMP_SMALL_SPLASH; + } + return 0; +} + +u32 FldEff_JumpBigSplash(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[12], gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = FLDEFF_JUMP_BIG_SPLASH; + } + return 0; +} + +u32 FldEff_FeetInFlowingWater(void) +{ + u8 eventObjectId; + struct EventObject *eventObject; + u8 spriteId; + struct Sprite *sprite; + const struct EventObjectGraphicsInfo *graphicsInfo; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + eventObject = &gEventObjects[eventObjectId]; + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[13], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + sprite = &gSprites[spriteId]; + sprite->callback = UpdateFeetInFlowingWaterFieldEffect; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gSprites[eventObject->spriteId].oam.priority; + sprite->data[0] = gFieldEffectArguments[0]; + sprite->data[1] = gFieldEffectArguments[1]; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->data[3] = -1; + sprite->data[4] = -1; + sprite->pos2.y = (graphicsInfo->height >> 1) - 4; + StartSpriteAnim(sprite, 1); + } + return 0; +} + +void UpdateFeetInFlowingWaterFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + struct Sprite *linkedSprite; + struct EventObject *eventObject; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId) || !gEventObjects[eventObjectId].inShallowFlowingWater) + { + FieldEffectStop(sprite, FLDEFF_FEET_IN_FLOWING_WATER); + } + else + { + eventObject = &gEventObjects[eventObjectId]; + linkedSprite = &gSprites[eventObject->spriteId]; + sprite->pos1.x = linkedSprite->pos1.x; + sprite->pos1.y = linkedSprite->pos1.y; + sprite->subpriority = linkedSprite->subpriority; + UpdateEventObjectSpriteVisibility(sprite, FALSE); + if (eventObject->currentCoords.x != sprite->data[3] || eventObject->currentCoords.y != sprite->data[4]) + { + sprite->data[3] = eventObject->currentCoords.x; + sprite->data[4] = eventObject->currentCoords.y; + if (!sprite->invisible) + { + PlaySE(SE_MIZU); + } + } + } +} + +u32 FldEff_Ripple(void) +{ + u8 spriteId; + struct Sprite *sprite; + + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[5], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = FLDEFF_RIPPLE; + } + return 0; +} + +u32 FldEff_HotSpringsWater(void) +{ + u8 eventObjectId; + struct EventObject *eventObject; + u8 spriteId; + struct Sprite *sprite; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + eventObject = &gEventObjects[eventObjectId]; + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[31], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gSprites[eventObject->spriteId].oam.priority; + sprite->data[0] = gFieldEffectArguments[0]; + sprite->data[1] = gFieldEffectArguments[1]; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->data[3] = gSprites[eventObject->spriteId].pos1.x; + sprite->data[4] = gSprites[eventObject->spriteId].pos1.y; + } + return 0; +} + +void UpdateHotSpringsWaterFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + const struct EventObjectGraphicsInfo *graphicsInfo; + struct Sprite *linkedSprite; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId) || !gEventObjects[eventObjectId].inHotSprings) + { + FieldEffectStop(sprite, FLDEFF_HOT_SPRINGS_WATER); + } + else + { + graphicsInfo = GetEventObjectGraphicsInfo(gEventObjects[eventObjectId].graphicsId); + linkedSprite = &gSprites[gEventObjects[eventObjectId].spriteId]; + sprite->pos1.x = linkedSprite->pos1.x; + sprite->pos1.y = (graphicsInfo->height >> 1) + linkedSprite->pos1.y - 8; + sprite->subpriority = linkedSprite->subpriority - 1; + UpdateEventObjectSpriteVisibility(sprite, FALSE); + } +} + +u32 FldEff_Unknown19(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[17], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = FLDEFF_UNKNOWN_19; + } + return 0; +} + +u32 FldEff_Unknown20(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[18], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = FLDEFF_UNKNOWN_20; + } + return 0; +} + +u32 FldEff_Unknown21(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[19], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = FLDEFF_UNKNOWN_21; + } + return 0; +} + +u32 FldEff_Unknown22(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[20], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = FLDEFF_UNKNOWN_22; + } + return 0; +} + +void StartAshFieldEffect(s16 x, s16 y, u16 c, s16 d) +{ + gFieldEffectArguments[0] = x; + gFieldEffectArguments[1] = y; + gFieldEffectArguments[2] = 0x52; + gFieldEffectArguments[3] = 1; + gFieldEffectArguments[4] = c; + gFieldEffectArguments[5] = d; + FieldEffectStart(FLDEFF_ASH); +} + +u32 FldEff_Ash(void) +{ + s16 x; + s16 y; + u8 spriteId; + struct Sprite *sprite; + + x = gFieldEffectArguments[0]; + y = gFieldEffectArguments[1]; + sub_80930E0(&x, &y, 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[6], x, y, gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[1] = gFieldEffectArguments[0]; + sprite->data[2] = gFieldEffectArguments[1]; + sprite->data[3] = gFieldEffectArguments[4]; + sprite->data[4] = gFieldEffectArguments[5]; + } + return 0; +} + +void (*const gAshFieldEffectFuncs[])(struct Sprite *) = { + UpdateAshFieldEffect_Step0, + UpdateAshFieldEffect_Step1, + UpdateAshFieldEffect_Step2 +}; + +void UpdateAshFieldEffect(struct Sprite *sprite) +{ + gAshFieldEffectFuncs[sprite->data[0]](sprite); +} + +void UpdateAshFieldEffect_Step0(struct Sprite *sprite) +{ + sprite->invisible = TRUE; + sprite->animPaused = TRUE; + if (--sprite->data[4] == 0) + sprite->data[0] = 1; +} + +void UpdateAshFieldEffect_Step1(struct Sprite *sprite) +{ + sprite->invisible = FALSE; + sprite->animPaused = FALSE; + MapGridSetMetatileIdAt(sprite->data[1], sprite->data[2], sprite->data[3]); + CurrentMapDrawMetatileAt(sprite->data[1], sprite->data[2]); + gEventObjects[gPlayerAvatar.eventObjectId].triggerGroundEffectsOnMove = TRUE; + sprite->data[0] = 2; +} + +void UpdateAshFieldEffect_Step2(struct Sprite *sprite) +{ + UpdateEventObjectSpriteVisibility(sprite, FALSE); + if (sprite->animEnded) + FieldEffectStop(sprite, FLDEFF_ASH); +} + +u32 FldEff_SurfBlob(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[7], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x96); + if (spriteId !=MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.paletteNum = 0; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->data[3] = -1; + sprite->data[6] = -1; + sprite->data[7] = -1; + } + FieldEffectActiveListRemove(FLDEFF_SURF_BLOB); + return spriteId; +} + +void sub_81555AC(u8 spriteId, u8 value) +{ + gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF) | (value & 0xF); +} + +void sub_81555D8(u8 spriteId, u8 value) +{ + gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF0) | ((value & 0xF) << 4); +} + +void sub_8155604(u8 spriteId, u8 value, s16 data1) +{ + gSprites[spriteId].data[0] = (gSprites[spriteId].data[0] & ~0xF00) | ((value & 0xF) << 8); + gSprites[spriteId].data[1] = data1; +} + +u8 sub_8155638(struct Sprite *sprite) +{ + return sprite->data[0] & 0xF; +} + +u8 sub_8155640(struct Sprite *sprite) +{ + return (sprite->data[0] & 0xF0) >> 4; +} + +u8 sub_815564C(struct Sprite *sprite) +{ + return (sprite->data[0] & 0xF00) >> 8; +} + +void UpdateSurfBlobFieldEffect(struct Sprite *sprite) +{ + struct EventObject *eventObject; + struct Sprite *linkedSprite; + + eventObject = &gEventObjects[sprite->data[2]]; + linkedSprite = &gSprites[eventObject->spriteId]; + sub_81556B0(eventObject, sprite); + sub_81556E8(eventObject, sprite); + sub_815577C(eventObject, linkedSprite, sprite); + sprite->oam.priority = linkedSprite->oam.priority; +} + +void sub_81556B0(struct EventObject *eventObject, struct Sprite *sprite) +{ + u8 surfBlobDirectionAnims[] = { + 0, // DIR_NONE + 0, // DIR_SOUTH + 1, // DIR_NORTH + 2, // DIR_WEST + 3, // DIR_EAST + 0, + 0, + 1, + 1, + }; + + if (sub_8155640(sprite) == 0) + StartSpriteAnimIfDifferent(sprite, surfBlobDirectionAnims[eventObject->movementDirection]); +} + +#ifdef NONMATCHING +void sub_81556E8(struct EventObject *eventObject, struct Sprite *sprite) +{ + s16 x; + s16 y; + u8 i; + + x = eventObject->currentCoords.x; + y = eventObject->currentCoords.y; + if (sprite->pos2.y == 0 && (x != sprite->data[6] || y != sprite->data[7])) + { + sprite->data[5] = sprite->pos2.y; + for (sprite->data[6] = x, sprite->data[7] = y, i = DIR_SOUTH; i <= DIR_EAST; i ++, x = sprite->data[6], y = sprite->data[7]) + { + MoveCoords(i, &x, &y); + if (MapGridGetZCoordAt(x, y) == 3) + { + sprite->data[5] ++; + break; + } + } + } +} +#else +NAKED void sub_81556E8(struct EventObject *eventObject, struct Sprite *sprite) +{ + asm_unified("push {r4-r7,lr}\n\ + mov r7, r8\n\ + push {r7}\n\ + sub sp, 0x4\n\ + adds r4, r1, 0\n\ + ldrh r2, [r0, 0x10]\n\ + mov r1, sp\n\ + strh r2, [r1]\n\ + ldrh r1, [r0, 0x12]\n\ + mov r0, sp\n\ + adds r0, 0x2\n\ + strh r1, [r0]\n\ + movs r2, 0x26\n\ + ldrsh r3, [r4, r2]\n\ + mov r8, r0\n\ + cmp r3, 0\n\ + bne _08155770\n\ + mov r0, sp\n\ + movs r5, 0\n\ + ldrsh r2, [r0, r5]\n\ + movs r5, 0x3A\n\ + ldrsh r0, [r4, r5]\n\ + cmp r2, r0\n\ + bne _08155724\n\ + lsls r0, r1, 16\n\ + asrs r0, 16\n\ + movs r5, 0x3C\n\ + ldrsh r1, [r4, r5]\n\ + cmp r0, r1\n\ + beq _08155770\n\ +_08155724:\n\ + strh r3, [r4, 0x38]\n\ + strh r2, [r4, 0x3A]\n\ + mov r1, r8\n\ + movs r2, 0\n\ + ldrsh r0, [r1, r2]\n\ + strh r0, [r4, 0x3C]\n\ + movs r5, 0x1\n\ + mov r7, r8\n\ + mov r6, sp\n\ +_08155736:\n\ + adds r0, r5, 0\n\ + mov r1, sp\n\ + adds r2, r7, 0\n\ + bl MoveCoords\n\ + movs r1, 0\n\ + ldrsh r0, [r6, r1]\n\ + movs r2, 0\n\ + ldrsh r1, [r7, r2]\n\ + bl MapGridGetZCoordAt\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0x3\n\ + bne _0815575C\n\ + ldrh r0, [r4, 0x38]\n\ + adds r0, 0x1\n\ + strh r0, [r4, 0x38]\n\ + b _08155770\n\ +_0815575C:\n\ + adds r0, r5, 0x1\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + ldrh r0, [r4, 0x3A]\n\ + strh r0, [r6]\n\ + ldrh r0, [r4, 0x3C]\n\ + mov r1, r8\n\ + strh r0, [r1]\n\ + cmp r5, 0x4\n\ + bls _08155736\n\ +_08155770:\n\ + add sp, 0x4\n\ + pop {r3}\n\ + mov r8, r3\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0"); +} +#endif + +void sub_815577C(struct EventObject *eventObject, struct Sprite *linkedSprite, struct Sprite *sprite) +{ + u16 unk_085CDC6A[] = {3, 7}; + u8 v0 = sub_8155638(sprite); + if (v0 != 0) + { + if (((u16)(++ sprite->data[4]) & unk_085CDC6A[sprite->data[5]]) == 0) + { + sprite->pos2.y += sprite->data[3]; + } + if ((sprite->data[4] & 0x0F) == 0) + { + sprite->data[3] = -sprite->data[3]; + } + if (v0 != 2) + { + if (sub_815564C(sprite) == 0) + linkedSprite->pos2.y = sprite->pos2.y; + else + linkedSprite->pos2.y = sprite->data[1] + sprite->pos2.y; + sprite->pos1.x = linkedSprite->pos1.x; + sprite->pos1.y = linkedSprite->pos1.y + 8; + } + } +} + +u8 sub_8155800(u8 oldSpriteId) +{ + u8 spriteId; + struct Sprite *sprite; + + spriteId = CreateSpriteAtEnd(&gDummySpriteTemplate, 0, 0, -1); + sprite = &gSprites[spriteId]; + sprite->callback = sub_8155850; + sprite->invisible = TRUE; + sprite->data[0] = oldSpriteId; + sprite->data[1] = 1; + return spriteId; +} + +void sub_8155850(struct Sprite *sprite) +{ + struct Sprite *oldSprite; + + oldSprite = &gSprites[sprite->data[0]]; + if (((sprite->data[2]++) & 0x03) == 0) + { + oldSprite->pos2.y += sprite->data[1]; + } + if ((sprite->data[2] & 0x0F) == 0) + { + sprite->data[1] = -sprite->data[1]; + } +} + +u32 FldEff_Dust(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 12); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[9], gFieldEffectArguments[0], gFieldEffectArguments[1], 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->data[0] = gFieldEffectArguments[2]; + sprite->data[1] = 10; + } + return 0; +} + +u32 FldEff_SandPile(void) +{ + u8 eventObjectId; + struct EventObject *eventObject; + u8 spriteId; + struct Sprite *sprite; + const struct EventObjectGraphicsInfo *graphicsInfo; + + eventObjectId = GetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + eventObject = &gEventObjects[eventObjectId]; + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[29], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gSprites[eventObject->spriteId].oam.priority; + sprite->data[0] = gFieldEffectArguments[0]; + sprite->data[1] = gFieldEffectArguments[1]; + sprite->data[2] = gFieldEffectArguments[2]; + sprite->data[3] = gSprites[eventObject->spriteId].pos1.x; + sprite->data[4] = gSprites[eventObject->spriteId].pos1.y; + sprite->pos2.y = (graphicsInfo->height >> 1) - 2; + SeekSpriteAnim(sprite, 2); + } + return 0; +} + +void UpdateSandPileFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + s16 x; + s16 y; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[0], sprite->data[1], sprite->data[2], &eventObjectId) || !gEventObjects[eventObjectId].inSandPile) + { + FieldEffectStop(sprite, FLDEFF_SAND_PILE); + } + else + { + y = gSprites[gEventObjects[eventObjectId].spriteId].pos1.y; + x = gSprites[gEventObjects[eventObjectId].spriteId].pos1.x; + if (x != sprite->data[3] || y != sprite->data[4]) + { + sprite->data[3] = x; + sprite->data[4] = y; + if (sprite->animEnded) + { + StartSpriteAnim(sprite, 0); + } + } + sprite->pos1.x = x; + sprite->pos1.y = y; + sprite->subpriority = gSprites[gEventObjects[eventObjectId].spriteId].subpriority; + UpdateEventObjectSpriteVisibility(sprite, FALSE); + } +} + +u32 FldEff_Bubbles(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 0); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[34], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x52); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = 1; + } + return 0; +} + +void UpdateBubblesFieldEffect(struct Sprite *sprite) +{ + sprite->data[0] += 0x80; + sprite->data[0] &= 0x100; + sprite->pos1.y -= sprite->data[0] >> 8; + UpdateEventObjectSpriteVisibility(sprite, FALSE); + if (sprite->invisible || sprite->animEnded) + { + FieldEffectStop(sprite, FLDEFF_BUBBLES); + } +} + +u32 FldEff_BerryTreeGrowthSparkle(void) +{ + u8 spriteId; + struct Sprite *sprite; + + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 4); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[22], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->oam.priority = gFieldEffectArguments[3]; + sprite->oam.paletteNum = 5; + sprite->data[0] = FLDEFF_BERRY_TREE_GROWTH_SPARKLE; + } + return 0; +} + +u32 ShowTreeDisguiseFieldEffect(void) +{ + return ShowDisguiseFieldEffect(FLDEFF_TREE_DISGUISE, 24, 4); +} + + +u32 ShowMountainDisguiseFieldEffect(void) +{ + return ShowDisguiseFieldEffect(FLDEFF_MOUNTAIN_DISGUISE, 25, 3); +} + + +u32 ShowSandDisguiseFieldEffect(void) +{ + return ShowDisguiseFieldEffect(FLDEFF_SAND_DISGUISE, 28, 2); +} + +u32 ShowDisguiseFieldEffect(u8 fldEff, u8 templateIdx, u8 paletteNum) +{ + u8 spriteId; + struct Sprite *sprite; + + if (TryGetEventObjectIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &spriteId)) + { + FieldEffectActiveListRemove(fldEff); + return MAX_SPRITES; + } + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[templateIdx], 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->coordOffsetEnabled ++; + sprite->oam.paletteNum = paletteNum; + sprite->data[1] = fldEff; + sprite->data[2] = gFieldEffectArguments[0]; + sprite->data[3] = gFieldEffectArguments[1]; + sprite->data[4] = gFieldEffectArguments[2]; + } + return spriteId; +} + +void UpdateDisguiseFieldEffect(struct Sprite *sprite) +{ + u8 eventObjectId; + const struct EventObjectGraphicsInfo *graphicsInfo; + struct Sprite *linkedSprite; + + if (TryGetEventObjectIdByLocalIdAndMap(sprite->data[2], sprite->data[3], sprite->data[4], &eventObjectId)) + { + FieldEffectStop(sprite, sprite->data[1]); + } + + graphicsInfo = GetEventObjectGraphicsInfo(gEventObjects[eventObjectId].graphicsId); + linkedSprite = &gSprites[gEventObjects[eventObjectId].spriteId]; + sprite->invisible = linkedSprite->invisible; + sprite->pos1.x = linkedSprite->pos1.x; + sprite->pos1.y = (graphicsInfo->height >> 1) + linkedSprite->pos1.y - 16; + sprite->subpriority = linkedSprite->subpriority - 1; + if (sprite->data[0] == 1) + { + sprite->data[0] ++; + StartSpriteAnim(sprite, 1); + } + if (sprite->data[0] == 2 && sprite->animEnded) + { + sprite->data[7] = 1; + } + if (sprite->data[0] == 3) + { + FieldEffectStop(sprite, sprite->data[1]); + } +} + +void sub_8155D78(struct EventObject *eventObject) +{ + if (eventObject->directionSequenceIndex == 1) + { + gSprites[eventObject->fieldEffectSpriteId].data[0]++; + } +} + +bool8 sub_8155DA0(struct EventObject *eventObject) +{ + struct Sprite *sprite; + + if (eventObject->directionSequenceIndex == 2) + { + return TRUE; + } + if (eventObject->directionSequenceIndex == 0) + { + return TRUE; + } + sprite = &gSprites[eventObject->fieldEffectSpriteId]; + if (sprite->data[7]) + { + eventObject->directionSequenceIndex = 2; + sprite->data[0]++; + return TRUE; + } + return FALSE; +} + +u32 FldEff_Sparkle(void) +{ + u8 spriteId; + + gFieldEffectArguments[0] += 7; + gFieldEffectArguments[1] += 7; + sub_80930E0((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[35], gFieldEffectArguments[0], gFieldEffectArguments[1], 0x52); + if (spriteId != MAX_SPRITES) + { + gSprites[spriteId].oam.priority = gFieldEffectArguments[2]; + gSprites[spriteId].coordOffsetEnabled = TRUE; + } + return 0; +} + +void UpdateSparkleFieldEffect(struct Sprite *sprite) +{ + if (sprite->data[0] == 0) + { + if (sprite->animEnded) + { + sprite->invisible = TRUE; + sprite->data[0]++; + } + + if (sprite->data[0] == 0) + return; + } + + if (++sprite->data[1] > 34) + FieldEffectStop(sprite, FLDEFF_SPARKLE); +} + +void sub_8155EA0(struct Sprite *sprite) +{ + sprite->data[6] = 0; + sprite->data[7] = 0; +} + +bool8 sub_8155EA8(struct Sprite *sprite) +{ + bool8 returnBool = FALSE; + + switch (sprite->data[7]) + { + case 0: + sprite->pos2.x += sub_809773C(sprite->data[6]); + sprite->pos2.y += sub_8097728(sprite->data[6]); + break; + case 1: + sprite->pos2.x -= sub_809773C(0x47 - sprite->data[6]); + sprite->pos2.y += sub_8097728(0x47 - sprite->data[6]); + break; + case 2: + sprite->pos2.x -= sub_809773C(sprite->data[6]); + sprite->pos2.y += sub_8097728(sprite->data[6]); + break; + case 3: + sprite->pos2.x += sub_809773C(0x47 - sprite->data[6]); + sprite->pos2.y += sub_8097728(0x47 - sprite->data[6]); + break; + } + + SetGpuReg(REG_OFFSET_BG0HOFS, -sprite->pos2.x); + if (++sprite->data[6] == 72) + { + sprite->data[6] = 0; + sprite->data[7]++; + } + if (sprite->data[7] == 4) + { + sprite->pos2.y = 0; + sprite->pos2.x = 0; + returnBool = TRUE; + } + + return returnBool; +} + +void sub_8155F80(struct Sprite *sprite) +{ + u8 i, j; + + switch (sprite->data[2]) + { + case 0: + SetGpuReg(REG_OFFSET_BG0VOFS, 0x78 - (sprite->data[0] / 3)); + if (sprite->data[0] == 0x60) + { + for (i = 0; i < 3; i++) + { + for (j = 12; j < 18; j++) + { + ((u16*)(VRAM + 0xF800))[i * 32 + j] = 0xBFF4 + i * 6 + j + 1; + } + } + } + if (sprite->data[0] > 0x137) + { + sprite->data[2] = 1; + sprite->data[0] = 0; + } + break; + case 1: + sprite->pos1.y = (gSineTable[sprite->data[0] / 3] >> 2) + sprite->data[4]; + if (sprite->data[0] == 0xBD) + { + sprite->data[2] = 2; + sprite->data[5] = 0; + sprite->data[0] = 0; + } + break; + case 2: + if (sprite->data[0] == 0x3C) + { + sprite->data[5]++; + sprite->data[0] = 0; + } + if (sprite->data[5] == 7) + { + sprite->data[5] = 0; + sprite->data[2] = 3; + } + break; + case 3: + if (sprite->pos2.y == 0) + { + sprite->data[0] = 0; + sprite->data[2]++; + } + if (sprite->data[0] == 5) + { + sprite->data[0] = 0; + if (sprite->pos2.y > 0) + sprite->pos2.y--; + else + sprite->pos2.y++; + } + break; + case 4: + if (sprite->data[0] == 0x3C) + { + sprite->data[2] = 5; + sprite->data[0] = 0; + sprite->data[5] = 0; + } + break; + case 5: + sub_8155EA0(sprite); + sprite->data[2] = 6; + sprite->data[0] = 0; + break; + case 6: + if (sub_8155EA8(sprite)) + { + sprite->data[0] = 0; + if (++sprite->data[5] <= 2) + { + sub_8155EA0(sprite); + } + else + { + sprite->data[5] = 0; + sprite->data[2] = 7; + } + } + break; + case 7: + if (sprite->data[0] == 0x1E) + { + sprite->data[2] = 8; + sprite->data[0] = 0; + } + break; + case 8: + for (i = 0; i < 15; i++) + { + for (j = 12; j < 18; j++) + { + ((u16*)(VRAM + 0xF800))[i * 32 + j] = 0; + } + } + SetGpuReg(REG_OFFSET_BG0VOFS, 0); + FieldEffectStop(sprite, FLDEFF_64); + break; + } + + if (sprite->data[2] == 1) + { + if ((sprite->data[1] & 7) == 0) + sprite->pos2.y += sprite->data[3]; + if ((sprite->data[1] & 15) == 0) + sprite->data[3] = -sprite->data[3]; + sprite->data[1]++; + } + + sprite->data[0]++; +} + +void sub_8156194(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + FieldEffectStop(sprite, sprite->data[1]); + } + else + { + UpdateEventObjectSpriteVisibility(sprite, FALSE); + SetObjectSubpriorityByZCoord(sprite->data[0], sprite, 0); + } +} + +void sub_81561D0(struct Sprite *sprite) +{ + if (sprite->animEnded) + FieldEffectStop(sprite, sprite->data[0]); + else + UpdateEventObjectSpriteVisibility(sprite, FALSE); +} + +#ifdef NONMATCHING +void sub_81561FC(struct Sprite *sprite /*r6*/, u8 z, u8 offset) +{ + u8 i; + s16 xlo; + s16 xhi; + s16 lx; + s16 lyhi; + s16 ly; + s16 ylo; + s16 yhi; + struct EventObject *eventObject; // r4 + const struct EventObjectGraphicsInfo *graphicsInfo; // destroyed + struct Sprite *linkedSprite; // r5 + + SetObjectSubpriorityByZCoord(z, sprite, offset); + for (i = 0; i < 16; i ++) + { + eventObject = &gEventObjects[i]; + if (eventObject->active) + { + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + linkedSprite = &gSprites[eventObject->spriteId]; + xhi = sprite->pos1.x + sprite->centerToCornerVecX; + xlo = sprite->pos1.x - sprite->centerToCornerVecX; + lx = linkedSprite->pos1.x; + if (xhi < lx && xlo > lx) + { + lyhi = linkedSprite->pos1.y + linkedSprite->centerToCornerVecY; + ly = linkedSprite->pos1.y; + ylo = sprite->pos1.y - sprite->centerToCornerVecY; + yhi = ylo + linkedSprite->centerToCornerVecY; + if ((lyhi < yhi || lyhi < ylo) && ly > yhi) + { + if (sprite->subpriority <= linkedSprite->subpriority) + { + sprite->subpriority = linkedSprite->subpriority + 2; + break; + } + } + } + } + } +} +#else +NAKED void sub_81561FC(struct Sprite *sprite /*r6*/, u8 z, u8 offset) +{ + asm_unified("push {r4-r7,lr}\n\ + adds r6, r0, 0\n\ + adds r0, r1, 0\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + adds r1, r6, 0\n\ + bl SetObjectSubpriorityByZCoord\n\ + movs r7, 0\n\ +_08156212:\n\ + lsls r0, r7, 3\n\ + adds r0, r7\n\ + lsls r0, 2\n\ + ldr r1, =gEventObjects\n\ + adds r4, r0, r1\n\ + ldrb r0, [r4]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _081562B4\n\ + ldrb r0, [r4, 0x5]\n\ + bl GetEventObjectGraphicsInfo\n\ + ldrb r1, [r4, 0x4]\n\ + lsls r0, r1, 4\n\ + adds r0, r1\n\ + lsls r0, 2\n\ + ldr r1, =gSprites\n\ + adds r5, r0, r1\n\ + adds r0, r6, 0\n\ + adds r0, 0x28\n\ + movs r2, 0\n\ + ldrsb r2, [r0, r2]\n\ + ldrh r0, [r6, 0x20]\n\ + adds r1, r0, r2\n\ + subs r0, r2\n\ + lsls r0, 16\n\ + lsrs r4, r0, 16\n\ + lsls r1, 16\n\ + asrs r1, 16\n\ + movs r0, 0x20\n\ + ldrsh r2, [r5, r0]\n\ + cmp r1, r2\n\ + bge _081562B4\n\ + lsls r0, r4, 16\n\ + asrs r0, 16\n\ + cmp r0, r2\n\ + ble _081562B4\n\ + adds r0, r5, 0\n\ + adds r0, 0x29\n\ + movs r3, 0\n\ + ldrsb r3, [r0, r3]\n\ + ldrh r2, [r5, 0x22]\n\ + adds r2, r3\n\ + ldrh r4, [r5, 0x22]\n\ + adds r0, r6, 0\n\ + adds r0, 0x29\n\ + movs r1, 0\n\ + ldrsb r1, [r0, r1]\n\ + ldrh r0, [r6, 0x22]\n\ + subs r0, r1\n\ + lsls r0, 16\n\ + asrs r0, 16\n\ + adds r3, r0, r3\n\ + lsls r2, 16\n\ + asrs r2, 16\n\ + lsls r3, 16\n\ + asrs r3, 16\n\ + cmp r2, r3\n\ + blt _0815628C\n\ + cmp r2, r0\n\ + bge _081562B4\n\ +_0815628C:\n\ + lsls r0, r4, 16\n\ + asrs r0, 16\n\ + cmp r0, r3\n\ + ble _081562B4\n\ + adds r2, r6, 0\n\ + adds r2, 0x43\n\ + adds r0, r5, 0\n\ + adds r0, 0x43\n\ + ldrb r1, [r0]\n\ + ldrb r0, [r2]\n\ + cmp r0, r1\n\ + bhi _081562B4\n\ + adds r0, r1, 0x2\n\ + strb r0, [r2]\n\ + b _081562BE\n\ + .pool\n\ +_081562B4:\n\ + adds r0, r7, 0x1\n\ + lsls r0, 24\n\ + lsrs r7, r0, 24\n\ + cmp r7, 0xF\n\ + bls _08156212\n\ +_081562BE:\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0"); +} +#endif diff --git a/src/field_message_box.c b/src/field_message_box.c index 19859ec0f..f45b6607d 100755 --- a/src/field_message_box.c +++ b/src/field_message_box.c @@ -131,7 +131,7 @@ void HideFieldMessageBox(void) gUnknown_020375BC = 0; } -u8 textbox_any_visible(void) +u8 GetFieldMessageBoxMode(void) { return gUnknown_020375BC; } diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c index 38845beb8..b9cf7d102 100644 --- a/src/field_player_avatar.c +++ b/src/field_player_avatar.c @@ -6,7 +6,6 @@ #include "fieldmap.h" #include "global.fieldmap.h" #include "metatile_behavior.h" -#include "metatile_behaviors.h" #include "overworld.h" #include "rotating_gate.h" #include "sprite.h" @@ -286,7 +285,7 @@ void MovementType_Player(struct Sprite *sprite) UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, EventObjectCB2_NoMovement2); } -static u8 EventObjectCB2_NoMovement2() +static u8 EventObjectCB2_NoMovement2(void) { return 0; } @@ -376,7 +375,7 @@ static void PlayerAllowForcedMovementIfMovingSameDirection(void) gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_5; } -static bool8 TryDoMetatileBehaviorForcedMovement() +static bool8 TryDoMetatileBehaviorForcedMovement(void) { return gUnknown_08497444[GetForcedMovementByMetatileBehavior()](); } diff --git a/src/field_tasks.c b/src/field_tasks.c index fc57585e5..5fb23f536 100644 --- a/src/field_tasks.c +++ b/src/field_tasks.c @@ -627,11 +627,11 @@ static void PerStepCallback_8069F64(u8 taskId) { if (MapGridGetMetatileIdAt(x, y) == 0x20a) { - ash(x, y, 0x212, 4); + StartAshFieldEffect(x, y, 0x212, 4); } else { - ash(x, y, 0x206, 4); + StartAshFieldEffect(x, y, 0x206, 4); } if (CheckBagHasItem(ITEM_SOOT_SACK, 1)) { diff --git a/src/fldeff_cut.c b/src/fldeff_cut.c index 9de954e80..5a9181789 100644 --- a/src/fldeff_cut.c +++ b/src/fldeff_cut.c @@ -1,26 +1,25 @@ #include "global.h" -#include "fldeff_cut.h" +#include "event_obj_lock.h" +#include "event_object_movement.h" #include "field_camera.h" #include "field_effect.h" -#include "event_object_movement.h" #include "field_player_avatar.h" #include "fieldmap.h" -#include "event_obj_lock.h" +#include "fldeff_cut.h" +#include "malloc.h" #include "metatile_behavior.h" -#include "party_menu.h" #include "overworld.h" +#include "party_menu.h" +#include "rom6.h" #include "script.h" #include "sound.h" #include "sprite.h" #include "task.h" #include "trig.h" -#include "malloc.h" +#include "constants/abilities.h" #include "constants/event_objects.h" #include "constants/songs.h" -#include "constants/abilities.h" -extern bool8 CheckObjectGraphicsInFrontOfPlayer(u8); -extern u8 oei_task_add(void); extern void ScriptUnfreezeEventObjects(void); extern bool8 IsMewPlayingHideAndSeek(void); diff --git a/src/fldeff_sweetscent.c b/src/fldeff_sweetscent.c index 14da87eb3..f592ed532 100644 --- a/src/fldeff_sweetscent.c +++ b/src/fldeff_sweetscent.c @@ -35,7 +35,7 @@ void hm2_sweet_scent(void) gFieldEffectArguments[0] = GetCursorSelectionMonId(); } -bool8 FldEff_SweetScent() +bool8 FldEff_SweetScent(void) { u8 taskId; diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c index 2b0904672..f2975e739 100644 --- a/src/hall_of_fame.c +++ b/src/hall_of_fame.c @@ -17,7 +17,7 @@ #include "bg.h" #include "constants/species.h" #include "constants/game_stat.h" -#include "blend_palette.h" +#include "util.h" #include "string_util.h" #include "m4a.h" #include "international_string_util.h" diff --git a/src/intro.c b/src/intro.c index f21ad348d..fe5c012b0 100644 --- a/src/intro.c +++ b/src/intro.c @@ -22,9 +22,10 @@ #include "graphics.h" #include "sound.h" #include "constants/species.h" -#include "blend_palette.h" +#include "util.h" #include "title_screen.h" #include "constants/rgb.h" +#include "constants/battle_anim.h" extern const struct CompressedSpriteSheet gBattleAnimPicTable[]; extern const struct CompressedSpritePalette gBattleAnimPaletteTable[]; @@ -118,7 +119,7 @@ static const struct SpriteTemplate gUnknown_085E4AB8 = }; static const u8 gUnknown_085E4AD0[][2] = { - {0x7C, 0x28}, + {0x7C, 0x28}, {0x66, 0x1E}, {0x4D, 0x1E}, {0x36, 0x0F}, @@ -664,25 +665,25 @@ static const s16 gUnknown_085E4E94[][2] = {5, 20}, {3, 28}, }; -static const union AffineAnimCmd gUnknown_085E4ED8[] = +static const union AffineAnimCmd gUnknown_085E4ED8[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_085E4EE8[] = +static const union AffineAnimCmd gUnknown_085E4EE8[] = { AFFINEANIMCMD_FRAME(128, 128, 0, 0), AFFINEANIMCMD_FRAME(16, 16, 0, 16), AFFINEANIMCMD_FRAME(-16, -16, 0, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_085E4F08[] = +static const union AffineAnimCmd gUnknown_085E4F08[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(8, 8, 0, 48), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd gUnknown_085E4F20[] = +static const union AffineAnimCmd gUnknown_085E4F20[] = { AFFINEANIMCMD_FRAME(256, 256, 0, 0), AFFINEANIMCMD_FRAME(2, 2, 0, 48), @@ -695,7 +696,7 @@ static const union AffineAnimCmd *const gUnknown_085E4F38[] = gUnknown_085E4F08, gUnknown_085E4F20, }; -static const u16 gUnknown_085E4F48[] = +static const u16 gUnknown_085E4F48[] = { 0x100, 0xC0, 0x80, 0x40, 0x00, 0x40, 0x80, 0xC0, 0x100 }; @@ -1086,10 +1087,10 @@ static void Task_IntroWaterDrops(u8 taskId) if (gIntroFrameCounter == 256) CreateTask(Task_IntroWaterDrops_2, 0); - + if (gIntroFrameCounter == 368) CreateWaterDrop(48, 0, 0x400, 5, 0x70, TRUE); - + if (gIntroFrameCounter == 384) CreateWaterDrop(200, 60, 0x400, 9, 0x80, TRUE); @@ -1113,7 +1114,7 @@ static void Task_IntroWaterDrops_3(u8 taskId) s16 *data = gTasks[taskId].data; if (++data[2] & 1) data[3]++; - + switch (data[0]) { case 0: @@ -1127,7 +1128,7 @@ static void Task_IntroWaterDrops_3(u8 taskId) data[0] = 0; break; } - + if (data[3] > 0x3C) DestroyTask(taskId); } @@ -1206,25 +1207,25 @@ static void Task_IntroStartBikeRide(u8 taskId) LoadCompressedObjectPic(gIntro2BrendanSpriteSheet); else LoadCompressedObjectPic(gIntro2MaySpriteSheet); - + LoadCompressedObjectPic(gIntro2BicycleSpriteSheet); LoadCompressedObjectPic(gIntro2FlygonSpriteSheet); - + for (spriteId = 0; spriteId < 3; spriteId++) { LoadCompressedObjectPic(&gUnknown_085E4AE8[spriteId]); } - + LoadSpritePalettes(gUnknown_085F530C); LoadSpritePalettes(gUnknown_085E4B08); CreateSprite(&gUnknown_085E4BDC, 0x110, 0x80, 0); CreateSprite(&gUnknown_085E4BA4, 0x120, 0x6E, 1); - + if (gUnknown_0203BCC8 == 0) spriteId = intro_create_brendan_sprite(0x110, 100); else spriteId = intro_create_may_sprite(0x110, 100); - + gSprites[spriteId].callback = sub_816F9D4; gSprites[spriteId].anims = gUnknown_085E4DC4; gTasks[taskId].data[1] = spriteId; @@ -1243,7 +1244,7 @@ static void Task_IntroHandleBikeAndFlygonMovement(u8 taskId) { s16 a; u16 sine; - + if (gIntroFrameCounter == 1856) { gUnknown_0203BD28 = 2; @@ -1427,7 +1428,7 @@ static void sub_816D9C0(struct Sprite *sprite) case 4: if (sprite->animEnded) sprite->pos1.x += 4; - + if (sprite->pos1.x > 336) { StartSpriteAnim(sprite, 1); @@ -1506,7 +1507,7 @@ static void Task_IntroLoadPart3Graphics(u8 taskId) static void Task_IntroSpinAndZoomPokeball(u8 taskId) { gTasks[taskId].data[0] += 0x400; - + if (gTasks[taskId].data[1] <= 0x6BF) { gTasks[taskId].data[1] += gTasks[taskId].data[2]; @@ -1516,9 +1517,9 @@ static void Task_IntroSpinAndZoomPokeball(u8 taskId) { gTasks[taskId].func = Task_IntroWaitToSetupPart3LegendsFight; } - + sub_816F2A8(0x78, 0x50, 0x10000 / gTasks[taskId].data[1], gTasks[taskId].data[0]); - + if (gIntroFrameCounter == 28) BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, RGB_WHITEALPHA); } @@ -1531,8 +1532,6 @@ static void Task_IntroWaitToSetupPart3LegendsFight(u8 taskId) static void Task_IntroLoadPart1Graphics3(u8 taskId) { - u16 i; - if (!gPaletteFade.active) { intro_reset_and_hide_bgs(); @@ -1543,8 +1542,8 @@ static void Task_IntroLoadPart1Graphics3(u8 taskId) LZDecompressVram(gIntro3GroudonTilemap, (void *)(VRAM + 0xC000)); LZDecompressVram(gIntro3LegendBgGfx, (void *)(VRAM + 0x4000)); LZDecompressVram(gIntro3GroudonBgTilemap, (void *)(VRAM + 0xE000)); - LoadCompressedObjectPicUsingHeap(&gBattleAnimPicTable[0x3A]); - LoadCompressedObjectPaletteUsingHeap(&gBattleAnimPaletteTable[0x3A]); + LoadCompressedObjectPicUsingHeap(&gBattleAnimPicTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_058)]); + LoadCompressedObjectPaletteUsingHeap(&gBattleAnimPaletteTable[GET_TRUE_SPRITE_INDEX(ANIM_TAG_058)]); CpuCopy16(gIntro3BgPal, gPlttBufferUnfaded, sizeof(gIntro3BgPal)); gTasks[taskId].func = Task_IntroLoadPart1Graphics4; } @@ -1584,12 +1583,10 @@ static void Task_IntroLoadPart1Graphics4(u8 taskId) static void Task_IntroLoadPart1Graphics5(u8 taskId) { - u16 foo = gTasks[taskId].data[0]; - if (gTasks[taskId].data[0] != 32) { gTasks[taskId].data[0] += 4; - SetGpuReg(REG_OFFSET_WIN0V, (gTasks[taskId].data[0] * 256) - (foo -= 0x9C)); + SetGpuReg(REG_OFFSET_WIN0V, (gTasks[taskId].data[0] * 256) - (gTasks[taskId].data[0] - 160)); } else { @@ -1613,7 +1610,7 @@ static void Task_IntroLoadPart1Graphics7(u8 taskId) static void Task_IntroLoadPart1Graphics8(u8 taskId) { s16 *data = gTasks[taskId].data; - + data[5]++; if ((u16)(data[0] - 1) < 7 && data[5] % 2 == 0) data[4] ^= 3; @@ -1720,7 +1717,7 @@ static void sub_816E190(u8 a0) { int i; u8 spriteId; - + for (i = 0; i < 6; i++) { spriteId = CreateSprite(gUnknown_08596C10, gUnknown_085E4C64[i][0], 0xA0, i); @@ -1737,7 +1734,7 @@ static void sub_816E1F8(struct Sprite *sprite) sprite->data[3]++; if (sprite->data[3] % 2 == 0) sprite->pos2.y ^= 3; - + switch(sprite->data[0]) { case 0: @@ -1752,7 +1749,7 @@ static void sub_816E1F8(struct Sprite *sprite) sprite->pos1.x -= 2; else sprite->pos1.x += 2; - + if (sprite->pos1.y < 0x50) sprite->pos1.y -= 2; else @@ -1783,9 +1780,9 @@ static void Task_IntroLoadPart1Graphics9(u8 taskId) static void Task_IntroFadeIn0(u8 taskId) { s16 *data = gTasks[taskId].data; - + sub_816F2A8(data[1], data[2], data[3], 0); - + switch (data[0]) { case 0: @@ -1928,7 +1925,7 @@ static void sub_816E6D4(u8 a0) { int i; u8 spriteId; - + for (i = 0; i < 6; i++) { spriteId = CreateSprite(&gUnknown_085E4D14, gUnknown_085E4CA8[i][0], gUnknown_085E4CA8[i][1], i); @@ -1943,7 +1940,7 @@ static void sub_816E74C(void) { int i; u8 spriteId; - + for (i = 0; i < 6; i++) { spriteId = CreateSprite(&gUnknown_085E4D14, gUnknown_085E4CA8[i + 6][0], gUnknown_085E4CA8[i + 6][1], i); @@ -1980,7 +1977,7 @@ static void sub_816E7B4(struct Sprite *sprite) sprite->pos1.x -= 3; else sprite->pos1.x += 3; - + if (sprite->pos1.y < 80) sprite->pos1.y -= 3; else @@ -2053,10 +2050,10 @@ static void Task_IntroFadeIn3(u8 taskId) static void Task_IntroFadeIn4(u8 taskId) { s16 *data = gTasks[taskId].data; - + SetGpuReg(REG_OFFSET_BG0HOFS, (data[6] >> 8)); SetGpuReg(REG_OFFSET_BG1HOFS, -(data[6] >> 8)); - + switch (data[0]) { case 0: @@ -2070,7 +2067,7 @@ static void Task_IntroFadeIn4(u8 taskId) case 1: if (data[6] == 0x2800) BeginNormalPaletteFade(0x0000FFFE, 3, 0, 16, RGB(9, 10, 10)); - + if (data[6] != 0) data[6] -= 0x80; else if (!gPaletteFade.active) @@ -2103,7 +2100,7 @@ static void Task_IntroFadeIn6(u8 taskId) { s16 *data = gTasks[taskId].data; u8 spriteId; - + switch (data[0]) { case 0: @@ -2141,7 +2138,7 @@ static void sub_816EC6C(struct Sprite *sprite) { if (sprite->animEnded) sprite->invisible = TRUE; - + switch(sprite->data[0]) { case 0: @@ -2171,7 +2168,7 @@ static void sub_816EC6C(struct Sprite *sprite) static void Task_IntroFadeIn7(u8 taskId) { u8 newTaskId; - + LoadCompressedObjectPic(gUnknown_085E5048); LoadSpritePalettes(gUnknown_085E5058); SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 @@ -2194,12 +2191,12 @@ static void Task_IntroFadeIn7(u8 taskId) static void Task_IntroFadeIn8(u8 taskId) { s16 *data = gTasks[taskId].data; - + if (data[7] % 2 == 0) data[6] ^= 2; - + data[7]++; - + switch(data[0]) { case 0: @@ -2248,9 +2245,9 @@ static void sub_816EEA8(u8 taskId) { u8 spriteId; s16 *data = gTasks[taskId].data; - + data[2]++; - + switch(data[0]) { case 0: @@ -2377,7 +2374,7 @@ static void Task_IntroWaterDrops_1(u8 taskId) if (gTasks[taskId].data[1] != 0) { u8 tmp; - + gTasks[taskId].data[1]--; tmp = gTasks[taskId].data[1] / 2; SetGpuReg(REG_OFFSET_BLDALPHA, gUnknown_0853FF70[tmp]); @@ -2420,7 +2417,7 @@ static void Task_IntroWaterDrops_2(u8 taskId) if (gTasks[taskId].data[1] < 62) { u8 tmp; - + gTasks[taskId].data[1]++; tmp = gTasks[taskId].data[1] / 2; SetGpuReg(REG_OFFSET_BLDALPHA, gUnknown_0853FF70[tmp]); @@ -2903,7 +2900,7 @@ static u8 sub_816FDB8(s16 a0, s16 a1, s16 a2) { u16 i; u8 spriteId; - + for (i = 0; i < 9; i++) { spriteId = CreateSprite(&gUnknown_085E4F5C, gUnknown_085E4E94[i][1] + a0, a1 - 4, 0); @@ -2926,7 +2923,7 @@ static u8 sub_816FDB8(s16 a0, s16 a1, s16 a2) static void sub_816FEDC(struct Sprite *sprite) { sprite->data[7]++; - + if (sprite->data[0] != 0) { s16 sin1; @@ -2944,7 +2941,7 @@ static void sub_816FEDC(struct Sprite *sprite) SetOamMatrix(1, a, b, c, d); } - + switch (sprite->data[0]) { case 0: diff --git a/src/item_menu.c b/src/item_menu.c index 0cdedec97..bb619cac8 100755 --- a/src/item_menu.c +++ b/src/item_menu.c @@ -46,6 +46,7 @@ #include "text_window.h" #include "menu_helpers.h" #include "window.h" +#include "apprentice.h" void GoToBagMenu(u8 bagMenuType, u8 pocketId, void ( *postExitMenuMainCallback2)()); void CB2_Bag(void); @@ -2203,7 +2204,7 @@ void unknown_ItemMenu_Show(u8 taskId) void bag_menu_leave_maybe_3(void) { - gFieldCallback = sub_819FA50; + gFieldCallback = Apprentice_EnableBothScriptContexts; SetMainCallback2(CB2_ReturnToField); } diff --git a/src/item_menu_icons.c b/src/item_menu_icons.c index f12bb454e..5dd5fd31d 100644 --- a/src/item_menu_icons.c +++ b/src/item_menu_icons.c @@ -19,10 +19,10 @@ struct CompressedTilesPal const u8 *pal; }; -extern void sub_80D5860(struct Sprite *sprite); -extern void sub_80D58F8(struct Sprite *sprite); -extern void sub_80D5968(struct Sprite *sprite); -extern void sub_80D5A94(struct Sprite *sprite); +extern void DoHorizontalLunge(struct Sprite *sprite); +extern void DoVerticalDip(struct Sprite *sprite); +extern void SlideMonToOriginalPos(struct Sprite *sprite); +extern void SlideMonToOffset(struct Sprite *sprite); extern void sub_80D5B48(struct Sprite *sprite); // this file's functions @@ -414,7 +414,7 @@ static const struct SpriteTemplate gUnknown_0857FE10 = .callback = SpriteCallbackDummy, }; -const struct SpriteTemplate gUnknown_0857FE28 = +const struct SpriteTemplate gHorizontalLungeSpriteTemplate = { .tileTag = 0, .paletteTag = 0, @@ -422,10 +422,10 @@ const struct SpriteTemplate gUnknown_0857FE28 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80D5860, + .callback = DoHorizontalLunge, }; -const struct SpriteTemplate gUnknown_0857FE40 = +const struct SpriteTemplate gVerticalDipSpriteTemplate = { .tileTag = 0, .paletteTag = 0, @@ -433,10 +433,10 @@ const struct SpriteTemplate gUnknown_0857FE40 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80D58F8, + .callback = DoVerticalDip, }; -const struct SpriteTemplate gUnknown_0857FE58 = +const struct SpriteTemplate gSlideMonToOriginalPosSpriteTemplate = { .tileTag = 0, .paletteTag = 0, @@ -444,10 +444,10 @@ const struct SpriteTemplate gUnknown_0857FE58 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80D5968, + .callback = SlideMonToOriginalPos, }; -const struct SpriteTemplate gUnknown_0857FE70 = +const struct SpriteTemplate gSlideMonToOffsetSpriteTemplate = { .tileTag = 0, .paletteTag = 0, @@ -455,7 +455,7 @@ const struct SpriteTemplate gUnknown_0857FE70 = .anims = gDummySpriteAnimTable, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, - .callback = sub_80D5A94, + .callback = SlideMonToOffset, }; const struct SpriteTemplate gUnknown_0857FE88 = diff --git a/src/item_use.c b/src/item_use.c index 67bdabd87..633d975a8 100755 --- a/src/item_use.c +++ b/src/item_use.c @@ -203,7 +203,7 @@ u8 CheckIfItemIsTMHMOrEvolutionStone(u16 itemId) return 0; } -void sub_80FD254() +void sub_80FD254(void) { struct MailStruct mail; mail.itemId = gSpecialVar_ItemId; @@ -249,7 +249,7 @@ void ItemUseOnFieldCB_Bike(u8 taskId) DestroyTask(taskId); } -bool32 CanFish() +bool32 CanFish(void) { s16 x, y; u16 tileBehavior; diff --git a/src/main.c b/src/main.c index f04f9b61b..4c71ed1f9 100644 --- a/src/main.c +++ b/src/main.c @@ -33,7 +33,7 @@ static void VCountIntr(void); static void SerialIntr(void); static void IntrDummy(void); -const u8 gGameVersion = VERSION_EMERALD; +const u8 gGameVersion = GAME_VERSION; const u8 gGameLanguage = GAME_LANGUAGE; // English diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c index a5e328e4a..5a7d4ae83 100644 --- a/src/metatile_behavior.c +++ b/src/metatile_behavior.c @@ -1,896 +1,922 @@ #include "global.h" #include "metatile_behavior.h" -#include "metatile_behaviors.h" +#include "constants/metatile_behaviors.h" #define TILE_FLAG_ENCOUNTER_TILE 1 #define TILE_FLAG_SURFABLE 2 -#define TILE_ATTRIBUTES(three, two, one) (((one) ? 1 : 0) | ((two) ? 2 : 0) | ((three) ? 4 : 0)) +#define TILE_ATTRIBUTES(unused, surfable, wildEncounter) (((wildEncounter) ? 1 : 0) | ((surfable) ? 2 : 0) | ((unused) ? 4 : 0)) // wonder what the third flag is supposed to do static const u8 sTileBitAttributes[] = { - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NORMAL 0x00 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x01 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_TALL_GRASS 0x02 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_LONG_GRASS 0x03 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_04 0x04 - TILE_ATTRIBUTES(FALSE, FALSE, TRUE), // MB_05 0x05 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_DEEP_SAND 0x06 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHORT_GRASS 0x07 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_CAVE 0x08 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LONG_GRASS_SOUTH_EDGE 0x09 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NO_RUNNING 0x0A - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_0B 0x0B - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MOUNTAIN_TOP 0x0C - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BATTLE_PYRAMID_WARP 0x0D - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MOSSDEEP_GYM_WARP 0x0E - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MT_PYRE_HOLE 0x0F - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_POND_WATER 0x10 - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEMI_DEEP_WATER 0x11 - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_DEEP_WATER 0x12 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATERFALL 0x13 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_SOOTOPOLIS_DEEP_WATER 0x14 - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_OCEAN_WATER 0x15 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PUDDLE 0x16 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHALLOW_WATER 0x17 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_18 0x18 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_NO_SURFACING 0x19 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_1A 0x1A - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_STAIRS_OUTSIDE_ABANDONED_SHIP 0x1B - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHOAL_CAVE_ENTRANCE 0x1C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x1D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x1E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x1F - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ICE 0x20 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SAND 0x21 - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEAWEED 0x22 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // ? 0x23 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_ASHGRASS 0x24 - TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_25 0x25 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_THIN_ICE 0x26 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_ICE 0x27 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_HOT_SPRINGS 0x28 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LAVARIDGE_GYM_B1F_WARP 0x29 - TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEAWEED_NO_SURFACING 0x2A - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_REFLECTION_UNDER_BRIDGE 0x2B - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x2C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x2D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x2E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x2F - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_EAST 0x30 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_WEST 0x31 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTH 0x32 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTH 0x33 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTHEAST 0x34 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTHWEST 0x35 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTHEAST 0x36 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTHWEST 0x37 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_EAST 0x38 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_WEST 0x39 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_NORTH 0x3A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_SOUTH 0x3B - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // ? 0x3C - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // ? 0x3D - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_SOUTHEAST 0x3E - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_SOUTHWEST 0x3F - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_EAST 0x40 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_WEST 0x41 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_NORTH 0x42 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_SOUTH 0x43 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_EAST 0x44 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_WEST 0x45 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_NORTH 0x46 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_SOUTH 0x47 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_TRICK_HOUSE_PUZZLE_8_FLOOR 0x48 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // ? 0x49 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // ? 0x4A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x4B - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x4C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x4D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x4E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x4F - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_EASTWARD_CURRENT 0x50 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WESTWARD_CURRENT 0x51 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_NORTHWARD_CURRENT 0x52 - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_SOUTHWARD_CURRENT 0x53 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x54 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x55 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x56 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x57 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x58 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x59 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5B - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x5F - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NON_ANIMATED_DOOR 0x60 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LADDER 0x61 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_EAST_ARROW_WARP 0x62 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WEST_ARROW_WARP 0x63 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NORTH_ARROW_WARP 0x64 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SOUTH_ARROW_WARP 0x65 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_FLOOR_HOLE 0x66 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_AQUA_HIDEOUT_WARP 0x67 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LAVARIDGE_GYM_1F_WARP 0x68 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ANIMATED_DOOR 0x69 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UP_ESCALATOR 0x6A - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_DOWN_ESCALATOR 0x6B - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATER_DOOR 0x6C - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATER_SOUTH_ARROW_WARP 0x6D - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_DEEP_SOUTH_WARP 0x6E - TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // ? 0x6F - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_WARP_OR_BRIDGE 0x70 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_71 0x71 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_1 0x72 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_2 0x73 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_VERTICAL_LOG_1 0x74 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_VERTICAL_LOG_2 0x75 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_HORIZONTAL_LOG_1 0x76 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_HORIZONTAL_LOG_2 0x77 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_FORTREE_BRIDGE 0x78 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x79 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_SOUTH_BRIDGE_1 0x7A - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_SOUTH_BRIDGE_2 0x7B - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_3 0x7C - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_4 0x7D - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_7E 0x7E - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE110_BRIDGE 0x7F - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_COUNTER 0x80 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x81 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x82 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_PC 0x83 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CABLE_BOX_RESULTS_1 0x84 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_REGION_MAP 0x85 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TELEVISION 0x86 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_POKEBLOCK_FEEDER 0x87 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x88 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SLOT_MACHINE 0x89 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_ROULETTE 0x8A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CLOSED_SOOTOPOLIS_GYM_DOOR 0x8B - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRICK_HOUSE_PUZZLE_DOOR 0x8C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_8D 0x8D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_RUNNING_SHOES_INSTRUCTION 0x8E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_QUESTIONNAIRE 0x8F - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_RED_CAVE 0x90 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_RED_CAVE_OPEN 0x91 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BROWN_CAVE 0x92 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BROWN_CAVE_OPEN 0x93 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_YELLOW_CAVE 0x94 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_YELLOW_CAVE_OPEN 0x95 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_LEFT 0x96 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_LEFT_OPEN 0x97 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_SHRUB 0x98 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_SHRUB_OPEN 0x99 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BLUE_CAVE 0x9A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BLUE_CAVE_OPEN 0x9B - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_RIGHT 0x9C - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_RIGHT_OPEN 0x9D - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x9E - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0x9F - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BERRY_TREE_SOIL 0xA0 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA1 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA2 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA3 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA4 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA5 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA6 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA7 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA8 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xA9 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAA - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAB - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAC - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAD - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAE - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xAF A - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_PC 0xB0 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_REGISTER_PC 0xB1 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_B2 0xB2 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_B3 0xB3 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_B4 0xB4 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_B5 0xB5 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_B6 0xB6 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_B7 0xB7 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_BALLOON 0xB8 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_B9 0xB9 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_GLITTER_MAT 0xBA - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_JUMP_MAT 0xBB - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_SPIN_MAT 0xBC - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_SOUND_MAT 0xBD - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BE 0xBE - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BF 0xBF - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BED 0xC0 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_C1 0xC1 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_C2 0xC2 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_C3 0xC3 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_TV_SHIELD 0xC4 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_C5 0xC5 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_C6 0xC6 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_POSTER 0xC7 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_C8 0xC8 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_C9 0xC9 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CA 0xCA - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CB 0xCB - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CC 0xCC - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CD 0xCD - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CE 0xCE - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CF 0xCF - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MUDDY_SLOPE 0xD0 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BUMPY_SLOPE 0xD1 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_FLOOR 0xD2 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ISOLATED_VERTICAL_RAIL 0xD3 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ISOLATED_HORIZONTAL_RAIL 0xD4 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_VERTICAL_RAIL 0xD5 - TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_HORIZONTAL_RAIL 0xD6 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xD7 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xD8 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xD9 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDA - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDB - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDC - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDD - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDE - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xDF - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_PICTURE_BOOK_SHELF 0xE0 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BOOKSHELF 0xE1 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_POKEMON_CENTER_BOOKSHELF 0xE2 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_VASE 0xE3 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRASH_CAN 0xE4 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SHOP_SHELF 0xE5 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BLUEPRINT 0xE6 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CABLE_BOX_RESULTS_2 0xE7 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_WIRELESS_BOX_RESULTS 0xE8 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRAINER_HILL_TIMER 0xE9 - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNKNOWN_CLOSED_DOOR 0xEA - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xEB - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xEC - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xED - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xEE - TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // ? 0xEF + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NORMAL + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_WALL + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_TALL_GRASS + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_LONG_GRASS + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_04 + TILE_ATTRIBUTES(FALSE, FALSE, TRUE), // MB_UNUSED_05 + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_DEEP_SAND + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHORT_GRASS + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_UNUSED_CAVE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LONG_GRASS_SOUTH_EDGE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NO_RUNNING + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_INDOOR_ENCOUNTER + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MOUNTAIN_TOP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BATTLE_PYRAMID_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MOSSDEEP_GYM_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MT_PYRE_HOLE + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_POND_WATER + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEMI_DEEP_WATER + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_DEEP_WATER + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATERFALL + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_SOOTOPOLIS_DEEP_WATER + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_OCEAN_WATER + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PUDDLE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHALLOW_WATER + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_SOOTOPOLIS_DEEP_WATER + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_NO_SURFACING + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_SOOTOPOLIS_DEEP_WATER_2 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_STAIRS_OUTSIDE_ABANDONED_SHIP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SHOAL_CAVE_ENTRANCE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_1D + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_1E + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_1F + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ICE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SAND + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEAWEED + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UNUSED_23 + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_ASHGRASS + TILE_ATTRIBUTES(TRUE, FALSE, TRUE), // MB_FOOTPRINTS + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_THIN_ICE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_ICE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_HOT_SPRINGS + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LAVARIDGE_GYM_B1F_WARP + TILE_ATTRIBUTES(TRUE, TRUE, TRUE), // MB_SEAWEED_NO_SURFACING + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_REFLECTION_UNDER_BRIDGE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_2C + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_2D + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_2E + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_2F + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_EAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_WEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTHEAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_NORTHWEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTHEAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTHWEST + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_EAST + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_WEST + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_NORTH + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_JUMP_SOUTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_NORTHEAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_NORTHWEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_SOUTHEAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_JUMP_SOUTHWEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_EAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_WEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_NORTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WALK_SOUTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_EAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_WEST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_NORTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SLIDE_SOUTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_TRICK_HOUSE_PUZZLE_8_FLOOR + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UNUSED_49 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UNUSED_4A + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_4B + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_4C + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_4D + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_4E + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_4F + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_EASTWARD_CURRENT + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WESTWARD_CURRENT + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_NORTHWARD_CURRENT + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_SOUTHWARD_CURRENT + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_54 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_55 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_56 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_57 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_58 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_59 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5A + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5B + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5C + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5D + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5E + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_5F + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NON_ANIMATED_DOOR + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LADDER + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_EAST_ARROW_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_WEST_ARROW_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_NORTH_ARROW_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SOUTH_ARROW_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_FLOOR_HOLE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_AQUA_HIDEOUT_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LAVARIDGE_GYM_1F_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ANIMATED_DOOR + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UP_ESCALATOR + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_DOWN_ESCALATOR + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATER_DOOR + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_WATER_SOUTH_ARROW_WARP + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_DEEP_SOUTH_WARP + TILE_ATTRIBUTES(TRUE, TRUE, FALSE), // MB_UNUSED_6F + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_WARP_OR_BRIDGE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UNUSED_71 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_1 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_2 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_VERTICAL_LOG_1 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_VERTICAL_LOG_2 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_HORIZONTAL_LOG_1 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PACIFIDLOG_HORIZONTAL_LOG_2 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_FORTREE_BRIDGE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_79 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_SOUTH_BRIDGE_1 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_SOUTH_BRIDGE_2 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_3 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE120_NORTH_BRIDGE_4 + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_UNUSED_7E + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ROUTE110_BRIDGE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_COUNTER + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_81 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_82 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_PC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CABLE_BOX_RESULTS_1 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_REGION_MAP + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TELEVISION + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_POKEBLOCK_FEEDER + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_88 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SLOT_MACHINE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_ROULETTE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CLOSED_SOOTOPOLIS_DOOR + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRICK_HOUSE_PUZZLE_DOOR + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_PETALBURG_GYM_DOOR + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_RUNNING_SHOES_INSTRUCTION + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_QUESTIONNAIRE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_RED_CAVE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_RED_CAVE_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BROWN_CAVE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BROWN_CAVE_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_YELLOW_CAVE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_YELLOW_CAVE_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_LEFT + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_LEFT_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_SHRUB + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_SHRUB_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BLUE_CAVE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_BLUE_CAVE_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_RIGHT + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SPOT_TREE_RIGHT_OPEN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_9E + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_9F + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BERRY_TREE_SOIL + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A1 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A2 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A3 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A4 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A5 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A6 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A7 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A8 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_A9 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AA + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AB + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AD + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_AF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_PC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_REGISTER_PC + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_UNUSED + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BLOCK_DECORATION + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_DECORATION + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_LARGE_MAT_EDGE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_B6 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_NORTH_WALL + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_BALLOON + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_IMPASSABLE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_GLITTER_MAT + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_JUMP_MAT + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_SPIN_MAT + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_SOUND_MAT + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_BREAKABLE_DOOR + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_SAND_ORNAMENT + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_SOUTH_AND_NORTH + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_IMPASSABLE_WEST_AND_EAST + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_HOLE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_LARGE_MAT_CENTER + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_SECRET_BASE_TV_SHIELD + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_PLAYER_ROOM_PC_ON + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_C6 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SECRET_BASE_POSTER + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_C8 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_C9 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CA + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CB + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CD + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_CF + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_MUDDY_SLOPE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_BUMPY_SLOPE + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_CRACKED_FLOOR + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ISOLATED_VERTICAL_RAIL + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_ISOLATED_HORIZONTAL_RAIL + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_VERTICAL_RAIL + TILE_ATTRIBUTES(TRUE, FALSE, FALSE), // MB_HORIZONTAL_RAIL + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_D7 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_D8 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_D9 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DA + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DB + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DD + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_DF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_PICTURE_BOOK_SHELF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BOOKSHELF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_POKEMON_CENTER_BOOKSHELF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_VASE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRASH_CAN + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_SHOP_SHELF + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_BLUEPRINT + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_CABLE_BOX_RESULTS_2 + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_WIRELESS_BOX_RESULTS + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_TRAINER_HILL_TIMER + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNKNOWN_CLOSED_DOOR + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_EB + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_EC + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_ED + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_EE + TILE_ATTRIBUTES(FALSE, FALSE, FALSE), // MB_UNUSED_EF }; -bool8 MetatileBehavior_IsATile(u8 var) +bool8 MetatileBehavior_IsATile(u8 metatileBehavior) { return TRUE; } -bool8 MetatileBehavior_IsEncounterTile(u8 var) +bool8 MetatileBehavior_IsEncounterTile(u8 metatileBehavior) { - if ((sTileBitAttributes[var] & TILE_FLAG_ENCOUNTER_TILE) != 0) + if ((sTileBitAttributes[metatileBehavior] & TILE_FLAG_ENCOUNTER_TILE)) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsJumpEast(u8 var) +bool8 MetatileBehavior_IsJumpEast(u8 metatileBehavior) { - if (var == MB_JUMP_EAST) + if (metatileBehavior == MB_JUMP_EAST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsJumpWest(u8 var) +bool8 MetatileBehavior_IsJumpWest(u8 metatileBehavior) { - if (var == MB_JUMP_WEST) + if (metatileBehavior == MB_JUMP_WEST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsJumpNorth(u8 var) +bool8 MetatileBehavior_IsJumpNorth(u8 metatileBehavior) { - if (var == MB_JUMP_NORTH) + if (metatileBehavior == MB_JUMP_NORTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsJumpSouth(u8 var) +bool8 MetatileBehavior_IsJumpSouth(u8 metatileBehavior) { - if (var == MB_JUMP_SOUTH) + if (metatileBehavior == MB_JUMP_SOUTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPokeGrass(u8 var) +bool8 MetatileBehavior_IsPokeGrass(u8 metatileBehavior) { - if (var == MB_TALL_GRASS || var == MB_LONG_GRASS) + if (metatileBehavior == MB_TALL_GRASS || metatileBehavior == MB_LONG_GRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSandOrDeepSand(u8 var) +bool8 MetatileBehavior_IsSandOrDeepSand(u8 metatileBehavior) { - if (var == MB_SAND || var == MB_DEEP_SAND) + if (metatileBehavior == MB_SAND || metatileBehavior == MB_DEEP_SAND) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsDeepSand(u8 var) +bool8 MetatileBehavior_IsDeepSand(u8 metatileBehavior) { - if (var == MB_DEEP_SAND) + if (metatileBehavior == MB_DEEP_SAND) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsReflective(u8 var) +bool8 MetatileBehavior_IsReflective(u8 metatileBehavior) { - if (var == MB_POND_WATER || var == MB_PUDDLE || var == MB_1A || var == MB_ICE || var == MB_SOOTOPOLIS_DEEP_WATER || var == MB_REFLECTION_UNDER_BRIDGE) + if (metatileBehavior == MB_POND_WATER + || metatileBehavior == MB_PUDDLE + || metatileBehavior == MB_UNUSED_SOOTOPOLIS_DEEP_WATER_2 + || metatileBehavior == MB_ICE + || metatileBehavior == MB_SOOTOPOLIS_DEEP_WATER + || metatileBehavior == MB_REFLECTION_UNDER_BRIDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsIce(u8 var) +bool8 MetatileBehavior_IsIce(u8 metatileBehavior) { - if (var == MB_ICE) + if (metatileBehavior == MB_ICE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWarpDoor(u8 var) +bool8 MetatileBehavior_IsWarpDoor(u8 metatileBehavior) { - if (var == MB_ANIMATED_DOOR) + if (metatileBehavior == MB_ANIMATED_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsDoor(u8 var) +bool8 MetatileBehavior_IsDoor(u8 metatileBehavior) { - if (var == MB_8D || var == MB_ANIMATED_DOOR) + if (metatileBehavior == MB_PETALBURG_GYM_DOOR + || metatileBehavior == MB_ANIMATED_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsEscalator(u8 var) +bool8 MetatileBehavior_IsEscalator(u8 metatileBehavior) { - if (var == MB_UP_ESCALATOR || var == MB_DOWN_ESCALATOR) + if (metatileBehavior == MB_UP_ESCALATOR + || metatileBehavior == MB_DOWN_ESCALATOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_04(u8 var) // unused +bool8 Unref_MetatileBehavior_IsUnused04(u8 metatileBehavior) { - if (var == MB_04) + if (metatileBehavior == MB_UNUSED_04) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLadder(u8 var) +bool8 MetatileBehavior_IsLadder(u8 metatileBehavior) { - if (var == MB_LADDER) + if (metatileBehavior == MB_LADDER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsNonAnimDoor(u8 var) +bool8 MetatileBehavior_IsNonAnimDoor(u8 metatileBehavior) { - if (var == MB_NON_ANIMATED_DOOR || var == MB_WATER_DOOR || var == MB_DEEP_SOUTH_WARP) + if (metatileBehavior == MB_NON_ANIMATED_DOOR + || metatileBehavior == MB_WATER_DOOR + || metatileBehavior == MB_DEEP_SOUTH_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsDeepSouthWarp(u8 var) +bool8 MetatileBehavior_IsDeepSouthWarp(u8 metatileBehavior) { - if (var == MB_DEEP_SOUTH_WARP) + if (metatileBehavior == MB_DEEP_SOUTH_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSurfableWaterOrUnderwater(u8 var) +bool8 MetatileBehavior_IsSurfableWaterOrUnderwater(u8 metatileBehavior) { - if ((sTileBitAttributes[var] & TILE_FLAG_SURFABLE) != 0) + if ((sTileBitAttributes[metatileBehavior] & TILE_FLAG_SURFABLE)) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsEastArrowWarp(u8 var) +bool8 MetatileBehavior_IsEastArrowWarp(u8 metatileBehavior) { - if (var == MB_EAST_ARROW_WARP) + if (metatileBehavior == MB_EAST_ARROW_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWestArrowWarp(u8 var) +bool8 MetatileBehavior_IsWestArrowWarp(u8 metatileBehavior) { - if (var == MB_WEST_ARROW_WARP) + if (metatileBehavior == MB_WEST_ARROW_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsNorthArrowWarp(u8 var) +bool8 MetatileBehavior_IsNorthArrowWarp(u8 metatileBehavior) { - if (var == MB_NORTH_ARROW_WARP || var == MB_STAIRS_OUTSIDE_ABANDONED_SHIP) + if (metatileBehavior == MB_NORTH_ARROW_WARP + || metatileBehavior == MB_STAIRS_OUTSIDE_ABANDONED_SHIP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSouthArrowWarp(u8 var) +bool8 MetatileBehavior_IsSouthArrowWarp(u8 metatileBehavior) { - if (var == MB_SOUTH_ARROW_WARP || var == MB_WATER_SOUTH_ARROW_WARP || var == MB_SHOAL_CAVE_ENTRANCE) + if (metatileBehavior == MB_SOUTH_ARROW_WARP + || metatileBehavior == MB_WATER_SOUTH_ARROW_WARP + || metatileBehavior == MB_SHOAL_CAVE_ENTRANCE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsArrowWarp(u8 var) // unused +bool8 Unref_MetatileBehavior_IsArrowWarp(u8 metatileBehavior) { - u8 ret = FALSE; + u8 isArrowWarp = FALSE; - if (MetatileBehavior_IsEastArrowWarp(var) - || MetatileBehavior_IsWestArrowWarp(var) - || MetatileBehavior_IsNorthArrowWarp(var) - || MetatileBehavior_IsSouthArrowWarp(var)) + if (MetatileBehavior_IsEastArrowWarp(metatileBehavior) + || MetatileBehavior_IsWestArrowWarp(metatileBehavior) + || MetatileBehavior_IsNorthArrowWarp(metatileBehavior) + || MetatileBehavior_IsSouthArrowWarp(metatileBehavior)) { - ret = TRUE; + isArrowWarp = TRUE; } - return ret; + return isArrowWarp; } -bool8 MetatileBehavior_IsMoveTile(u8 var) +bool8 MetatileBehavior_IsForcedMovementTile(u8 metatileBehavior) { - if ((var >= MB_WALK_EAST && var <= MB_TRICK_HOUSE_PUZZLE_8_FLOOR) || (var >= MB_EASTWARD_CURRENT && var <= MB_SOUTHWARD_CURRENT) - || var == MB_MUDDY_SLOPE || var == MB_CRACKED_FLOOR || var == MB_WATERFALL || var == MB_ICE || var == MB_SECRET_BASE_JUMP_MAT || var == MB_SECRET_BASE_SPIN_MAT) + if ((metatileBehavior >= MB_WALK_EAST && metatileBehavior <= MB_TRICK_HOUSE_PUZZLE_8_FLOOR) + || (metatileBehavior >= MB_EASTWARD_CURRENT && metatileBehavior <= MB_SOUTHWARD_CURRENT) + || metatileBehavior == MB_MUDDY_SLOPE + || metatileBehavior == MB_CRACKED_FLOOR + || metatileBehavior == MB_WATERFALL + || metatileBehavior == MB_ICE + || metatileBehavior == MB_SECRET_BASE_JUMP_MAT + || metatileBehavior == MB_SECRET_BASE_SPIN_MAT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsIce_2(u8 var) +bool8 MetatileBehavior_IsIce_2(u8 metatileBehavior) { - if (var == MB_ICE) + if (metatileBehavior == MB_ICE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsTrickHouseSlipperyFloor(u8 var) +bool8 MetatileBehavior_IsTrickHouseSlipperyFloor(u8 metatileBehavior) { - if (var == MB_TRICK_HOUSE_PUZZLE_8_FLOOR) + if (metatileBehavior == MB_TRICK_HOUSE_PUZZLE_8_FLOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_05(u8 var) +bool8 Unref_MetatileBehavior_IsUnused05(u8 metatileBehavior) { - if (var == MB_05) + if (metatileBehavior == MB_UNUSED_05) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWalkNorth(u8 var) +bool8 MetatileBehavior_IsWalkNorth(u8 metatileBehavior) { - if (var == MB_WALK_NORTH) + if (metatileBehavior == MB_WALK_NORTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWalkSouth(u8 var) +bool8 MetatileBehavior_IsWalkSouth(u8 metatileBehavior) { - if (var == MB_WALK_SOUTH) + if (metatileBehavior == MB_WALK_SOUTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWalkWest(u8 var) +bool8 MetatileBehavior_IsWalkWest(u8 metatileBehavior) { - if (var == MB_WALK_WEST) + if (metatileBehavior == MB_WALK_WEST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWalkEast(u8 var) +bool8 MetatileBehavior_IsWalkEast(u8 metatileBehavior) { - if (var == MB_WALK_EAST) + if (metatileBehavior == MB_WALK_EAST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsNorthwardCurrent(u8 var) +bool8 MetatileBehavior_IsNorthwardCurrent(u8 metatileBehavior) { - if (var == MB_NORTHWARD_CURRENT) + if (metatileBehavior == MB_NORTHWARD_CURRENT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSouthwardCurrent(u8 var) +bool8 MetatileBehavior_IsSouthwardCurrent(u8 metatileBehavior) { - if (var == MB_SOUTHWARD_CURRENT) + if (metatileBehavior == MB_SOUTHWARD_CURRENT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWestwardCurrent(u8 var) +bool8 MetatileBehavior_IsWestwardCurrent(u8 metatileBehavior) { - if (var == MB_WESTWARD_CURRENT) + if (metatileBehavior == MB_WESTWARD_CURRENT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsEastwardCurrent(u8 var) +bool8 MetatileBehavior_IsEastwardCurrent(u8 metatileBehavior) { - if (var == MB_EASTWARD_CURRENT) + if (metatileBehavior == MB_EASTWARD_CURRENT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSlideNorth(u8 var) +bool8 MetatileBehavior_IsSlideNorth(u8 metatileBehavior) { - if (var == MB_SLIDE_NORTH) + if (metatileBehavior == MB_SLIDE_NORTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSlideSouth(u8 var) +bool8 MetatileBehavior_IsSlideSouth(u8 metatileBehavior) { - if (var == MB_SLIDE_SOUTH) + if (metatileBehavior == MB_SLIDE_SOUTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSlideWest(u8 var) +bool8 MetatileBehavior_IsSlideWest(u8 metatileBehavior) { - if (var == MB_SLIDE_WEST) + if (metatileBehavior == MB_SLIDE_WEST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSlideEast(u8 var) +bool8 MetatileBehavior_IsSlideEast(u8 metatileBehavior) { - if (var == MB_SLIDE_EAST) + if (metatileBehavior == MB_SLIDE_EAST) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCounter(u8 var) +bool8 MetatileBehavior_IsCounter(u8 metatileBehavior) { - if (var == MB_COUNTER) + if (metatileBehavior == MB_COUNTER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPlayerFacingTVScreen(u8 tile, u8 playerDir) +bool8 MetatileBehavior_IsPlayerFacingTVScreen(u8 metatileBehavior, u8 playerDir) { - if (playerDir != CONNECTION_NORTH) // if the player isn't facing north, forget about it. + if (playerDir != DIR_NORTH) return FALSE; - else if (tile == MB_TELEVISION) // is the player's north tile a TV? + else if (metatileBehavior == MB_TELEVISION) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPC(u8 var) +bool8 MetatileBehavior_IsPC(u8 metatileBehavior) { - if (var == MB_PC) + if (metatileBehavior == MB_PC) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCableBoxResults1(u8 var) +bool8 MetatileBehavior_IsCableBoxResults1(u8 metatileBehavior) { - if (var == MB_CABLE_BOX_RESULTS_1) + if (metatileBehavior == MB_CABLE_BOX_RESULTS_1) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseOpen(u8 var) +bool8 MetatileBehavior_IsOpenSecretBaseDoor(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SPOT_RED_CAVE_OPEN || var == MB_SECRET_BASE_SPOT_BROWN_CAVE_OPEN - || var == MB_SECRET_BASE_SPOT_YELLOW_CAVE_OPEN || var == MB_SECRET_BASE_SPOT_TREE_LEFT_OPEN - || var == MB_SECRET_BASE_SPOT_SHRUB_OPEN || var == MB_SECRET_BASE_SPOT_BLUE_CAVE_OPEN - || var == MB_SECRET_BASE_SPOT_TREE_RIGHT_OPEN) + if (metatileBehavior == MB_SECRET_BASE_SPOT_RED_CAVE_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_BROWN_CAVE_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_YELLOW_CAVE_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_TREE_LEFT_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_SHRUB_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_BLUE_CAVE_OPEN + || metatileBehavior == MB_SECRET_BASE_SPOT_TREE_RIGHT_OPEN) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseCave(u8 var) +bool8 MetatileBehavior_IsSecretBaseCave(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SPOT_RED_CAVE || var == MB_SECRET_BASE_SPOT_BROWN_CAVE || var == MB_SECRET_BASE_SPOT_YELLOW_CAVE || var == MB_SECRET_BASE_SPOT_BLUE_CAVE) + if (metatileBehavior == MB_SECRET_BASE_SPOT_RED_CAVE + || metatileBehavior == MB_SECRET_BASE_SPOT_BROWN_CAVE + || metatileBehavior == MB_SECRET_BASE_SPOT_YELLOW_CAVE + || metatileBehavior == MB_SECRET_BASE_SPOT_BLUE_CAVE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseTree(u8 var) +bool8 MetatileBehavior_IsSecretBaseTree(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SPOT_TREE_LEFT || var == MB_SECRET_BASE_SPOT_TREE_RIGHT) + if (metatileBehavior == MB_SECRET_BASE_SPOT_TREE_LEFT + || metatileBehavior == MB_SECRET_BASE_SPOT_TREE_RIGHT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseShrub(u8 var) +bool8 MetatileBehavior_IsSecretBaseShrub(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SPOT_SHRUB) + if (metatileBehavior == MB_SECRET_BASE_SPOT_SHRUB) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBasePC(u8 var) +bool8 MetatileBehavior_IsSecretBasePC(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_PC) + if (metatileBehavior == MB_SECRET_BASE_PC) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseRegisterPC(u8 var) +bool8 MetatileBehavior_IsSecretBaseRegisterPC(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_REGISTER_PC) + if (metatileBehavior == MB_SECRET_BASE_REGISTER_PC) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B2(u8 var) // unused +bool8 Unref_MetatileBehavior_IsSecretBaseUnused_B2(u8 metatileBehavior) { - if (var == MB_B2) + if (metatileBehavior == MB_SECRET_BASE_UNUSED) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B3(u8 var) +bool8 MetatileBehavior_IsBlockDecoration(u8 metatileBehavior) { - if (var == MB_B3) + if (metatileBehavior == MB_BLOCK_DECORATION) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B9(u8 var) +bool8 MetatileBehavior_IsSecretBaseImpassable(u8 metatileBehavior) { - if (var == MB_B9) + if (metatileBehavior == MB_SECRET_BASE_IMPASSABLE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_C6(u8 var) +bool8 MetatileBehavior_IsMB_C6(u8 metatileBehavior) { - if (var == MB_C6) + if (metatileBehavior == MB_C6) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBasePoster(u8 var) +bool8 MetatileBehavior_IsSecretBasePoster(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_POSTER) + if (metatileBehavior == MB_SECRET_BASE_POSTER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsNormal(u8 var) +bool8 MetatileBehavior_IsNormal(u8 metatileBehavior) { - if (var == MB_NORMAL) + if (metatileBehavior == MB_NORMAL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B7(u8 var) +bool8 MetatileBehavior_IsSecretBaseNorthWall(u8 metatileBehavior) { - if (var == MB_B7) + if (metatileBehavior == MB_SECRET_BASE_NORTH_WALL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B2_Duplicate(u8 var) // unused +bool8 Unref_MetatileBehavior_IsSecretBaseUnused_B2_2(u8 metatileBehavior) { - if (var == MB_B2) + if (metatileBehavior == MB_SECRET_BASE_UNUSED) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_B5(u8 var) +bool8 MetatileBehavior_IsSecretBaseLargeMatEdge(u8 metatileBehavior) { - if (var == MB_B5) + if (metatileBehavior == MB_SECRET_BASE_LARGE_MAT_EDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_C3(u8 var) +bool8 MetatileBehavior_IsLargeMatCenter(u8 metatileBehavior) { - if (var == MB_C3) + if (metatileBehavior == MB_LARGE_MAT_CENTER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_C2(u8 var) +bool8 MetatileBehavior_IsSecretBaseHole(u8 metatileBehavior) { - if (var == MB_C2) + if (metatileBehavior == MB_SECRET_BASE_HOLE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseBalloon(u8 var) +bool8 MetatileBehavior_IsSecretBaseBalloon(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_BALLOON) + if (metatileBehavior == MB_SECRET_BASE_BALLOON) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_BE(u8 var) +bool8 MetatileBehavior_IsSecretBaseBreakableDoor(u8 metatileBehavior) { - if (var == MB_BE) + if (metatileBehavior == MB_SECRET_BASE_BREAKABLE_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseSoundMat(u8 var) +bool8 MetatileBehavior_IsSecretBaseSoundMat(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SOUND_MAT) + if (metatileBehavior == MB_SECRET_BASE_SOUND_MAT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseGlitterMat(u8 var) +bool8 MetatileBehavior_IsSecretBaseGlitterMat(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_GLITTER_MAT) + if (metatileBehavior == MB_SECRET_BASE_GLITTER_MAT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_BF(u8 var) +bool8 MetatileBehavior_IsSecretBaseSandOrnament(u8 metatileBehavior) { - if (var == MB_BF) + if (metatileBehavior == MB_SECRET_BASE_SAND_ORNAMENT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseTvOrShield(u8 var) +bool8 MetatileBehavior_IsSecretBaseTvOrShield(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_TV_SHIELD) + if (metatileBehavior == MB_SECRET_BASE_TV_SHIELD) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_C5(u8 var) +bool8 MetatileBehavior_IsPlayerRoomPCOn(u8 metatileBehavior) { - if (var == MB_C5) + if (metatileBehavior == MB_PLAYER_ROOM_PC_ON) return TRUE; else return FALSE; } -bool8 MetatileBehavior_HasRipples(u8 var) +bool8 MetatileBehavior_HasRipples(u8 metatileBehavior) { - if (var == MB_POND_WATER || var == MB_PUDDLE || var == MB_SOOTOPOLIS_DEEP_WATER) + if (metatileBehavior == MB_POND_WATER || metatileBehavior == MB_PUDDLE || metatileBehavior == MB_SOOTOPOLIS_DEEP_WATER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPuddle(u8 var) +bool8 MetatileBehavior_IsPuddle(u8 metatileBehavior) { - if (var == MB_PUDDLE) + if (metatileBehavior == MB_PUDDLE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsTallGrass(u8 var) +bool8 MetatileBehavior_IsTallGrass(u8 metatileBehavior) { - if (var == MB_TALL_GRASS) + if (metatileBehavior == MB_TALL_GRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLongGrass(u8 var) +bool8 MetatileBehavior_IsLongGrass(u8 metatileBehavior) { - if (var == MB_LONG_GRASS) + if (metatileBehavior == MB_LONG_GRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBerryTreeSoil(u8 var) +bool8 MetatileBehavior_IsBerryTreeSoil(u8 metatileBehavior) { - if (var == MB_BERRY_TREE_SOIL) + if (metatileBehavior == MB_BERRY_TREE_SOIL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsAshGrass(u8 var) +bool8 MetatileBehavior_IsAshGrass(u8 metatileBehavior) { - if (var == MB_ASHGRASS) + if (metatileBehavior == MB_ASHGRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsUnusedFootprintMetatile(u8 var) +bool8 MetatileBehavior_IsFootprints(u8 metatileBehavior) { - if (var == MB_25) + // MB_FOOTPRINTS is not used by any metatiles. + if (metatileBehavior == MB_FOOTPRINTS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBridge(u8 var) +bool8 MetatileBehavior_IsBridge(u8 metatileBehavior) { - if ((var == MB_WARP_OR_BRIDGE || var == MB_71 || var == MB_ROUTE120_NORTH_BRIDGE_1 || var == MB_ROUTE120_NORTH_BRIDGE_2) - || (var == MB_ROUTE120_NORTH_BRIDGE_3 || var == MB_ROUTE120_NORTH_BRIDGE_4 || var == MB_7E || var == MB_ROUTE110_BRIDGE)) + if ((metatileBehavior == MB_WARP_OR_BRIDGE || metatileBehavior == MB_UNUSED_71 || metatileBehavior == MB_ROUTE120_NORTH_BRIDGE_1 || metatileBehavior == MB_ROUTE120_NORTH_BRIDGE_2) + || (metatileBehavior == MB_ROUTE120_NORTH_BRIDGE_3 || metatileBehavior == MB_ROUTE120_NORTH_BRIDGE_4 || metatileBehavior == MB_UNUSED_7E || metatileBehavior == MB_ROUTE110_BRIDGE)) return TRUE; else return FALSE; } -u8 MetatileBehavior_GetBridgeSth(u8 var) +u8 MetatileBehavior_GetBridgeSth(u8 metatileBehavior) { - u8 result = var - MB_WARP_OR_BRIDGE; + u8 result = metatileBehavior - MB_WARP_OR_BRIDGE; if (result < 4) return result; - result = var - MB_ROUTE120_SOUTH_BRIDGE_1; + result = metatileBehavior - MB_ROUTE120_SOUTH_BRIDGE_1; if (result < 2) return 2; - result = var - MB_ROUTE120_NORTH_BRIDGE_3; + result = metatileBehavior - MB_ROUTE120_NORTH_BRIDGE_3; if (result < 2) return 3; return 0; } -u8 MetatileBehavior_8089510(u8 var) +u8 MetatileBehavior_8089510(u8 metatileBehavior) { - u8 result = var - MB_WARP_OR_BRIDGE; + u8 result = metatileBehavior - MB_WARP_OR_BRIDGE; if (result < 4) return 1; @@ -898,485 +924,514 @@ u8 MetatileBehavior_8089510(u8 var) return 0; } -bool8 MetatileBehavior_IsLandWildEncounter(u8 var) +bool8 MetatileBehavior_IsLandWildEncounter(u8 metatileBehavior) { - if (MetatileBehavior_IsSurfableWaterOrUnderwater(var) == FALSE && MetatileBehavior_IsEncounterTile(var) == TRUE) + if (MetatileBehavior_IsSurfableWaterOrUnderwater(metatileBehavior) == FALSE && MetatileBehavior_IsEncounterTile(metatileBehavior) == TRUE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWaterWildEncounter(u8 var) +bool8 MetatileBehavior_IsWaterWildEncounter(u8 metatileBehavior) { - if (MetatileBehavior_IsSurfableWaterOrUnderwater(var) == TRUE && MetatileBehavior_IsEncounterTile(var) == TRUE) + if (MetatileBehavior_IsSurfableWaterOrUnderwater(metatileBehavior) == TRUE && MetatileBehavior_IsEncounterTile(metatileBehavior) == TRUE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_0B(u8 var) +bool8 MetatileBehavior_IsIndoorEncounter(u8 metatileBehavior) { - if (var == MB_0B) + if (metatileBehavior == MB_INDOOR_ENCOUNTER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMountain(u8 var) +bool8 MetatileBehavior_IsMountain(u8 metatileBehavior) { - if (var == MB_MOUNTAIN_TOP) + if (metatileBehavior == MB_MOUNTAIN_TOP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsDiveable(u8 var) +bool8 MetatileBehavior_IsDiveable(u8 metatileBehavior) { - if (var == MB_SEMI_DEEP_WATER || var == MB_DEEP_WATER || var == MB_SOOTOPOLIS_DEEP_WATER) + if (metatileBehavior == MB_SEMI_DEEP_WATER + || metatileBehavior == MB_DEEP_WATER + || metatileBehavior == MB_SOOTOPOLIS_DEEP_WATER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsUnableToEmerge(u8 var) +bool8 MetatileBehavior_IsUnableToEmerge(u8 metatileBehavior) { - if (var == MB_NO_SURFACING || var == MB_SEAWEED_NO_SURFACING) + if (metatileBehavior == MB_NO_SURFACING + || metatileBehavior == MB_SEAWEED_NO_SURFACING) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsShallowFlowingWater(u8 var) +bool8 MetatileBehavior_IsShallowFlowingWater(u8 metatileBehavior) { - if (var == MB_SHALLOW_WATER || var == MB_STAIRS_OUTSIDE_ABANDONED_SHIP || var == MB_SHOAL_CAVE_ENTRANCE) + if (metatileBehavior == MB_SHALLOW_WATER + || metatileBehavior == MB_STAIRS_OUTSIDE_ABANDONED_SHIP + || metatileBehavior == MB_SHOAL_CAVE_ENTRANCE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsThinIce(u8 var) +bool8 MetatileBehavior_IsThinIce(u8 metatileBehavior) { - if (var == MB_THIN_ICE) + if (metatileBehavior == MB_THIN_ICE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCrackedIce(u8 var) +bool8 MetatileBehavior_IsCrackedIce(u8 metatileBehavior) { - if (var == MB_CRACKED_ICE) + if (metatileBehavior == MB_CRACKED_ICE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsDeepOrOceanWater(u8 var) +bool8 MetatileBehavior_IsDeepOrOceanWater(u8 metatileBehavior) { - if (var == MB_OCEAN_WATER || var == MB_SEMI_DEEP_WATER || var == MB_DEEP_WATER) + if (metatileBehavior == MB_OCEAN_WATER + || metatileBehavior == MB_SEMI_DEEP_WATER + || metatileBehavior == MB_DEEP_WATER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMB_18_OrMB_1A(u8 var) // unused +bool8 Unref_MetatileBehavior_IsUnusedSootopolisWater(u8 metatileBehavior) { - if (var == MB_18 || var == MB_1A) + if (metatileBehavior == MB_UNUSED_SOOTOPOLIS_DEEP_WATER + || metatileBehavior == MB_UNUSED_SOOTOPOLIS_DEEP_WATER_2) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSurfableAndNotWaterfall(u8 var) +bool8 MetatileBehavior_IsSurfableAndNotWaterfall(u8 metatileBehavior) { - if (MetatileBehavior_IsSurfableWaterOrUnderwater(var) && MetatileBehavior_IsWaterfall(var) == FALSE) + if (MetatileBehavior_IsSurfableWaterOrUnderwater(metatileBehavior) + && MetatileBehavior_IsWaterfall(metatileBehavior) == FALSE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsEastBlocked(u8 var) +bool8 MetatileBehavior_IsEastBlocked(u8 metatileBehavior) { - if (var == MB_IMPASSABLE_EAST || var == MB_IMPASSABLE_NORTHEAST || var == MB_IMPASSABLE_SOUTHEAST || var == MB_C1 || var == MB_BE) + if (metatileBehavior == MB_IMPASSABLE_EAST + || metatileBehavior == MB_IMPASSABLE_NORTHEAST + || metatileBehavior == MB_IMPASSABLE_SOUTHEAST + || metatileBehavior == MB_IMPASSABLE_WEST_AND_EAST + || metatileBehavior == MB_SECRET_BASE_BREAKABLE_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWestBlocked(u8 var) +bool8 MetatileBehavior_IsWestBlocked(u8 metatileBehavior) { - if (var == MB_IMPASSABLE_WEST || var == MB_IMPASSABLE_NORTHWEST || var == MB_IMPASSABLE_SOUTHWEST || var == MB_C1 || var == MB_BE) + if (metatileBehavior == MB_IMPASSABLE_WEST + || metatileBehavior == MB_IMPASSABLE_NORTHWEST + || metatileBehavior == MB_IMPASSABLE_SOUTHWEST + || metatileBehavior == MB_IMPASSABLE_WEST_AND_EAST + || metatileBehavior == MB_SECRET_BASE_BREAKABLE_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsNorthBlocked(u8 var) +bool8 MetatileBehavior_IsNorthBlocked(u8 metatileBehavior) { - if (var == MB_IMPASSABLE_NORTH || var == MB_IMPASSABLE_NORTHEAST || var == MB_IMPASSABLE_NORTHWEST || var == MB_BED) + if (metatileBehavior == MB_IMPASSABLE_NORTH + || metatileBehavior == MB_IMPASSABLE_NORTHEAST + || metatileBehavior == MB_IMPASSABLE_NORTHWEST + || metatileBehavior == MB_IMPASSABLE_SOUTH_AND_NORTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSouthBlocked(u8 var) +bool8 MetatileBehavior_IsSouthBlocked(u8 metatileBehavior) { - if (var == MB_IMPASSABLE_SOUTH || var == MB_IMPASSABLE_SOUTHEAST || var == MB_IMPASSABLE_SOUTHWEST || var == MB_BED) + if (metatileBehavior == MB_IMPASSABLE_SOUTH + || metatileBehavior == MB_IMPASSABLE_SOUTHEAST + || metatileBehavior == MB_IMPASSABLE_SOUTHWEST + || metatileBehavior == MB_IMPASSABLE_SOUTH_AND_NORTH) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsShortGrass(u8 var) +bool8 MetatileBehavior_IsShortGrass(u8 metatileBehavior) { - if (var == MB_SHORT_GRASS) + if (metatileBehavior == MB_SHORT_GRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsHotSprings(u8 var) +bool8 MetatileBehavior_IsHotSprings(u8 metatileBehavior) { - if (var == MB_HOT_SPRINGS) + if (metatileBehavior == MB_HOT_SPRINGS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWaterfall(u8 var) +bool8 MetatileBehavior_IsWaterfall(u8 metatileBehavior) { - if (var == MB_WATERFALL) + if (metatileBehavior == MB_WATERFALL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsFortreeBridge(u8 var) +bool8 MetatileBehavior_IsFortreeBridge(u8 metatileBehavior) { - if (var == MB_FORTREE_BRIDGE) + if (metatileBehavior == MB_FORTREE_BRIDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPacifilogVerticalLog1(u8 var) +bool8 MetatileBehavior_IsPacifilogVerticalLog1(u8 metatileBehavior) { - if (var == MB_PACIFIDLOG_VERTICAL_LOG_1) + if (metatileBehavior == MB_PACIFIDLOG_VERTICAL_LOG_1) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPacifilogVerticalLog2(u8 var) +bool8 MetatileBehavior_IsPacifilogVerticalLog2(u8 metatileBehavior) { - if (var == MB_PACIFIDLOG_VERTICAL_LOG_2) + if (metatileBehavior == MB_PACIFIDLOG_VERTICAL_LOG_2) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPacifilogHorizontalLog1(u8 var) +bool8 MetatileBehavior_IsPacifilogHorizontalLog1(u8 metatileBehavior) { - if (var == MB_PACIFIDLOG_HORIZONTAL_LOG_1) + if (metatileBehavior == MB_PACIFIDLOG_HORIZONTAL_LOG_1) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPacifilogHorizontalLog2(u8 var) +bool8 MetatileBehavior_IsPacifilogHorizontalLog2(u8 metatileBehavior) { - if (var == MB_PACIFIDLOG_HORIZONTAL_LOG_2) + if (metatileBehavior == MB_PACIFIDLOG_HORIZONTAL_LOG_2) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPacifidlogLog(u8 var) +bool8 MetatileBehavior_IsPacifidlogLog(u8 metatileBehavior) { - if (var == MB_PACIFIDLOG_VERTICAL_LOG_1 || var == MB_PACIFIDLOG_VERTICAL_LOG_2 - || var == MB_PACIFIDLOG_HORIZONTAL_LOG_1 || var == MB_PACIFIDLOG_HORIZONTAL_LOG_2) + if (metatileBehavior == MB_PACIFIDLOG_VERTICAL_LOG_1 || metatileBehavior == MB_PACIFIDLOG_VERTICAL_LOG_2 + || metatileBehavior == MB_PACIFIDLOG_HORIZONTAL_LOG_1 || metatileBehavior == MB_PACIFIDLOG_HORIZONTAL_LOG_2) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsTrickHousePuzzleDoor(u8 var) +bool8 MetatileBehavior_IsTrickHousePuzzleDoor(u8 metatileBehavior) { - if (var == MB_TRICK_HOUSE_PUZZLE_DOOR) + if (metatileBehavior == MB_TRICK_HOUSE_PUZZLE_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsRegionMap(u8 var) +bool8 MetatileBehavior_IsRegionMap(u8 metatileBehavior) { - if (var == MB_REGION_MAP) + if (metatileBehavior == MB_REGION_MAP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsClosedSootopolisGymDoor(u8 var) +bool8 MetatileBehavior_IsClosedSootopolisGymDoor(u8 metatileBehavior) { - if (var == MB_CLOSED_SOOTOPOLIS_GYM_DOOR) + if (metatileBehavior == MB_CLOSED_SOOTOPOLIS_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsUnknownClosedDoor(u8 var) +bool8 MetatileBehavior_IsUnknownClosedDoor(u8 metatileBehavior) { - if (var == MB_UNKNOWN_CLOSED_DOOR) + if (metatileBehavior == MB_UNKNOWN_CLOSED_DOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsRoulette(u8 var) // unused +bool8 MetatileBehavior_IsRoulette(u8 metatileBehavior) // unused { - if (var == MB_ROULETTE) + if (metatileBehavior == MB_ROULETTE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPokeblockFeeder(u8 var) +bool8 MetatileBehavior_IsPokeblockFeeder(u8 metatileBehavior) { - if (var == MB_POKEBLOCK_FEEDER) + if (metatileBehavior == MB_POKEBLOCK_FEEDER) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseJumpMat(u8 var) +bool8 MetatileBehavior_IsSecretBaseJumpMat(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_JUMP_MAT) + if (metatileBehavior == MB_SECRET_BASE_JUMP_MAT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSecretBaseSpinMat(u8 var) +bool8 MetatileBehavior_IsSecretBaseSpinMat(u8 metatileBehavior) { - if (var == MB_SECRET_BASE_SPIN_MAT) + if (metatileBehavior == MB_SECRET_BASE_SPIN_MAT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLavaridgeB1FWarp(u8 var) +bool8 MetatileBehavior_IsLavaridgeB1FWarp(u8 metatileBehavior) { - if (var == MB_LAVARIDGE_GYM_B1F_WARP) + if (metatileBehavior == MB_LAVARIDGE_GYM_B1F_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLavaridge1FWarp(u8 var) +bool8 MetatileBehavior_IsLavaridge1FWarp(u8 metatileBehavior) { - if (var == MB_LAVARIDGE_GYM_1F_WARP) + if (metatileBehavior == MB_LAVARIDGE_GYM_1F_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsAquaHideoutWarp(u8 var) +bool8 MetatileBehavior_IsAquaHideoutWarp(u8 metatileBehavior) { - if (var == MB_AQUA_HIDEOUT_WARP) + if (metatileBehavior == MB_AQUA_HIDEOUT_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsWarpOrBridge(u8 var) +bool8 MetatileBehavior_IsWarpOrBridge(u8 metatileBehavior) { - if (var == MB_WARP_OR_BRIDGE) + if (metatileBehavior == MB_WARP_OR_BRIDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMossdeepGymWarp(u8 var) +bool8 MetatileBehavior_IsMossdeepGymWarp(u8 metatileBehavior) { - if (var == MB_MOSSDEEP_GYM_WARP) + if (metatileBehavior == MB_MOSSDEEP_GYM_WARP) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSurfableFishableWater(u8 var) +bool8 MetatileBehavior_IsSurfableFishableWater(u8 metatileBehavior) { - if (var == MB_POND_WATER || var == MB_OCEAN_WATER || var == MB_SEMI_DEEP_WATER || var == MB_DEEP_WATER - || var == MB_SOOTOPOLIS_DEEP_WATER || (var == MB_EASTWARD_CURRENT || var == MB_WESTWARD_CURRENT - || var == MB_NORTHWARD_CURRENT || var == MB_SOUTHWARD_CURRENT)) + if (metatileBehavior == MB_POND_WATER || metatileBehavior == MB_OCEAN_WATER || metatileBehavior == MB_SEMI_DEEP_WATER || metatileBehavior == MB_DEEP_WATER + || metatileBehavior == MB_SOOTOPOLIS_DEEP_WATER || (metatileBehavior == MB_EASTWARD_CURRENT || metatileBehavior == MB_WESTWARD_CURRENT + || metatileBehavior == MB_NORTHWARD_CURRENT || metatileBehavior == MB_SOUTHWARD_CURRENT)) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMtPyreHole(u8 var) +bool8 MetatileBehavior_IsMtPyreHole(u8 metatileBehavior) { - if (var == MB_MT_PYRE_HOLE) + if (metatileBehavior == MB_MT_PYRE_HOLE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCrackedFloorHole(u8 var) +bool8 MetatileBehavior_IsCrackedFloorHole(u8 metatileBehavior) { - if (var == MB_CRACKED_FLOOR_HOLE) + if (metatileBehavior == MB_CRACKED_FLOOR_HOLE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCrackedFloor(u8 var) +bool8 MetatileBehavior_IsCrackedFloor(u8 metatileBehavior) { - if (var == MB_CRACKED_FLOOR) + if (metatileBehavior == MB_CRACKED_FLOOR) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsMuddySlope(u8 var) +bool8 MetatileBehavior_IsMuddySlope(u8 metatileBehavior) { - if (var == MB_MUDDY_SLOPE) + if (metatileBehavior == MB_MUDDY_SLOPE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBumpySlope(u8 var) +bool8 MetatileBehavior_IsBumpySlope(u8 metatileBehavior) { - if (var == MB_BUMPY_SLOPE) + if (metatileBehavior == MB_BUMPY_SLOPE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsIsolatedVerticalRail(u8 var) +bool8 MetatileBehavior_IsIsolatedVerticalRail(u8 metatileBehavior) { - if (var == MB_ISOLATED_VERTICAL_RAIL) + if (metatileBehavior == MB_ISOLATED_VERTICAL_RAIL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsIsolatedHorizontalRail(u8 var) +bool8 MetatileBehavior_IsIsolatedHorizontalRail(u8 metatileBehavior) { - if (var == MB_ISOLATED_HORIZONTAL_RAIL) + if (metatileBehavior == MB_ISOLATED_HORIZONTAL_RAIL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsVerticalRail(u8 var) +bool8 MetatileBehavior_IsVerticalRail(u8 metatileBehavior) { - if (var == MB_VERTICAL_RAIL) + if (metatileBehavior == MB_VERTICAL_RAIL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsHorizontalRail(u8 var) +bool8 MetatileBehavior_IsHorizontalRail(u8 metatileBehavior) { - if (var == MB_HORIZONTAL_RAIL) + if (metatileBehavior == MB_HORIZONTAL_RAIL) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsSeaweed(u8 var) +bool8 MetatileBehavior_IsSeaweed(u8 metatileBehavior) { - if (var == MB_SEAWEED || var == MB_SEAWEED_NO_SURFACING) + if (metatileBehavior == MB_SEAWEED || metatileBehavior == MB_SEAWEED_NO_SURFACING) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsRunningDisallowed(u8 var) +bool8 MetatileBehavior_IsRunningDisallowed(u8 metatileBehavior) { - if (var == MB_NO_RUNNING || var == MB_LONG_GRASS || var == MB_HOT_SPRINGS || MetatileBehavior_IsPacifidlogLog(var) != FALSE) + if (metatileBehavior == MB_NO_RUNNING + || metatileBehavior == MB_LONG_GRASS + || metatileBehavior == MB_HOT_SPRINGS + || MetatileBehavior_IsPacifidlogLog(metatileBehavior) != FALSE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsCuttableGrass(u8 var) +bool8 MetatileBehavior_IsCuttableGrass(u8 metatileBehavior) { - if (var == MB_TALL_GRASS || var == MB_LONG_GRASS || var == MB_ASHGRASS || var == MB_LONG_GRASS_SOUTH_EDGE) + if (metatileBehavior == MB_TALL_GRASS + || metatileBehavior == MB_LONG_GRASS + || metatileBehavior == MB_ASHGRASS + || metatileBehavior == MB_LONG_GRASS_SOUTH_EDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsRunningShoesInstruction(u8 var) +bool8 MetatileBehavior_IsRunningShoesInstruction(u8 metatileBehavior) { - if (var == MB_RUNNING_SHOES_INSTRUCTION) + if (metatileBehavior == MB_RUNNING_SHOES_INSTRUCTION) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPictureBookShelf(u8 var) +bool8 MetatileBehavior_IsPictureBookShelf(u8 metatileBehavior) { - if (var == MB_PICTURE_BOOK_SHELF) + if (metatileBehavior == MB_PICTURE_BOOK_SHELF) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBookShelf(u8 var) +bool8 MetatileBehavior_IsBookShelf(u8 metatileBehavior) { - if (var == MB_BOOKSHELF) + if (metatileBehavior == MB_BOOKSHELF) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsPokeCenterBookShelf(u8 var) +bool8 MetatileBehavior_IsPokeCenterBookShelf(u8 metatileBehavior) { - if (var == MB_POKEMON_CENTER_BOOKSHELF) + if (metatileBehavior == MB_POKEMON_CENTER_BOOKSHELF) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsVase(u8 var) +bool8 MetatileBehavior_IsVase(u8 metatileBehavior) { - if (var == MB_VASE) + if (metatileBehavior == MB_VASE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsTrashCan(u8 var) +bool8 MetatileBehavior_IsTrashCan(u8 metatileBehavior) { - if (var == MB_TRASH_CAN) + if (metatileBehavior == MB_TRASH_CAN) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsShopShelf(u8 var) +bool8 MetatileBehavior_IsShopShelf(u8 metatileBehavior) { - if (var == MB_SHOP_SHELF) + if (metatileBehavior == MB_SHOP_SHELF) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBlueprint(u8 var) +bool8 MetatileBehavior_IsBlueprint(u8 metatileBehavior) { - if (var == MB_BLUEPRINT) + if (metatileBehavior == MB_BLUEPRINT) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsBattlePyramidWarp(u8 var) +bool8 MetatileBehavior_IsBattlePyramidWarp(u8 metatileBehavior) { - if (var == MB_BATTLE_PYRAMID_WARP) + if (metatileBehavior == MB_BATTLE_PYRAMID_WARP) return TRUE; else return FALSE; @@ -1402,33 +1457,33 @@ bool8 MetatileBehavior_IsCableBoxResults2(u8 tile, u8 playerDir) return FALSE; } -bool8 MetatileBehavior_IsQuestionnaire(u8 var) +bool8 MetatileBehavior_IsQuestionnaire(u8 metatileBehavior) { - if (var == MB_QUESTIONNAIRE) + if (metatileBehavior == MB_QUESTIONNAIRE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLongGrass_Duplicate(u8 var) +bool8 MetatileBehavior_IsLongGrass_Duplicate(u8 metatileBehavior) { - if (var == MB_LONG_GRASS) + if (metatileBehavior == MB_LONG_GRASS) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsLongGrassSouthEdge(u8 var) +bool8 MetatileBehavior_IsLongGrassSouthEdge(u8 metatileBehavior) { - if (var == MB_LONG_GRASS_SOUTH_EDGE) + if (metatileBehavior == MB_LONG_GRASS_SOUTH_EDGE) return TRUE; else return FALSE; } -bool8 MetatileBehavior_IsTrainerHillTimer(u8 var) +bool8 MetatileBehavior_IsTrainerHillTimer(u8 metatileBehavior) { - if (var == MB_TRAINER_HILL_TIMER) + if (metatileBehavior == MB_TRAINER_HILL_TIMER) return TRUE; else return FALSE; diff --git a/src/money.c b/src/money.c index 7b78dda92..dcc6afa2c 100644 --- a/src/money.c +++ b/src/money.c @@ -6,10 +6,9 @@ #include "menu.h" #include "window.h" #include "sprite.h" +#include "strings.h" #include "decompress.h" -extern const u8 gText_PokedollarVar1[]; - extern const u8 gMenuMoneyGfx[]; extern const u8 gMenuMoneyPal[]; diff --git a/src/mystery_event_menu.c b/src/mystery_event_menu.c index 8dcb960b7..7e09a4d70 100644 --- a/src/mystery_event_menu.c +++ b/src/mystery_event_menu.c @@ -151,7 +151,7 @@ static void CB2_MysteryEventMenu(void) if (!IsTextPrinterActive(0)) { gMain.state++; - gLinkType = 21761; + gLinkType = 0x5501; OpenLink(); } break; diff --git a/src/new_game.c b/src/new_game.c index 36c028ce8..127e48c35 100644 --- a/src/new_game.c +++ b/src/new_game.c @@ -25,6 +25,7 @@ #include "battle_records.h" #include "item.h" #include "pokedex.h" +#include "apprentice.h" extern u8 gDifferentSaveFile; extern u16 gSaveFileStatus; @@ -44,7 +45,6 @@ extern void NewGameInitPCItems(void); extern void ClearDecorationInventories(void); extern void ResetFanClub(void); extern void copy_strings_to_sav1(void); -extern void sub_819FAA0(void); extern void sub_81A4B14(void); extern void sub_8195E10(void); extern void sub_801AFD8(void); @@ -203,7 +203,7 @@ void NewGameInitData(void) ResetMiniGamesResults(); copy_strings_to_sav1(); SetLilycoveLady(); - sub_819FAA0(); + ResetAllApprenticeData(); sub_81A4B14(); sub_8195E10(); sub_801AFD8(); diff --git a/src/palette.c b/src/palette.c index fd4ad32ad..1e92f4bba 100644 --- a/src/palette.c +++ b/src/palette.c @@ -1,6 +1,6 @@ #include "global.h" -#include "blend_palette.h" #include "palette.h" +#include "util.h" #include "decompress.h" #include "gpu_regs.h" #include "task.h" diff --git a/src/pokeball.c b/src/pokeball.c index 3dbbb2967..bb02a02ba 100644 --- a/src/pokeball.c +++ b/src/pokeball.c @@ -378,8 +378,8 @@ static void Task_DoPokeballSendOutAnim(u8 taskId) gSprites[ballSpriteId].callback = SpriteCB_PlayerMonSendOut_1; break; case POKEBALL_OPPONENT_SENDOUT: - gSprites[ballSpriteId].pos1.x = GetBattlerSpriteCoord(battlerId, BANK_X_POS); - gSprites[ballSpriteId].pos1.y = GetBattlerSpriteCoord(battlerId, BANK_Y_POS) + 24; + gSprites[ballSpriteId].pos1.x = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_X); + gSprites[ballSpriteId].pos1.y = GetBattlerSpriteCoord(battlerId, BATTLER_COORD_Y) + 24; gBattlerTarget = battlerId; gSprites[ballSpriteId].data[0] = 0; gSprites[ballSpriteId].callback = SpriteCB_OpponentMonSendOut; @@ -399,8 +399,8 @@ static void Task_DoPokeballSendOutAnim(u8 taskId) // this will perform an unused ball throw animation gSprites[ballSpriteId].data[0] = 0x22; - gSprites[ballSpriteId].data[2] = GetBattlerSpriteCoord(gBattlerTarget, BANK_X_POS); - gSprites[ballSpriteId].data[4] = GetBattlerSpriteCoord(gBattlerTarget, BANK_Y_POS) - 16; + gSprites[ballSpriteId].data[2] = GetBattlerSpriteCoord(gBattlerTarget, BATTLER_COORD_X); + gSprites[ballSpriteId].data[4] = GetBattlerSpriteCoord(gBattlerTarget, BATTLER_COORD_Y) - 16; gSprites[ballSpriteId].data[5] = -40; sub_80A68D4(&gSprites[ballSpriteId]); gSprites[ballSpriteId].oam.affineParam = taskId; @@ -411,7 +411,7 @@ static void Task_DoPokeballSendOutAnim(u8 taskId) static void SpriteCB_TestBallThrow(struct Sprite *sprite) { - if (AnimateBallThrow(sprite)) + if (TranslateAnimArc(sprite)) { u16 ballId; u8 taskId = sprite->oam.affineParam; @@ -922,7 +922,7 @@ static void SpriteCB_PlayerMonSendOut_2(struct Sprite *sprite) StartSpriteAffineAnim(sprite, 4); } r4 = sprite->data[0]; - sub_80A6F3C(sprite); + TranslateAnimLinear(sprite); sprite->data[7] += sprite->sBattler / 3; sprite->pos2.y += Sin(HIBYTE(sprite->data[7]), sprite->data[5]); sprite->oam.affineParam += 0x100; @@ -940,7 +940,7 @@ static void SpriteCB_PlayerMonSendOut_2(struct Sprite *sprite) } else { - if (AnimateBallThrow(sprite)) + if (TranslateAnimArc(sprite)) { sprite->pos1.x += sprite->pos2.x; sprite->pos1.y += sprite->pos2.y; diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 1449d4a00..10f7d34d8 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -6,7 +6,7 @@ #include "menu.h" #include "malloc.h" #include "pokemon.h" -#include "blend_palette.h" +#include "util.h" #include "main.h" #include "menu_helpers.h" #include "bg.h" diff --git a/src/pokemon.c b/src/pokemon.c index 8e2e3b764..40f7e94b2 100644 --- a/src/pokemon.c +++ b/src/pokemon.c @@ -35,6 +35,7 @@ #include "pokenav.h" #include "pokemon_storage_system.h" #include "recorded_battle.h" +#include "apprentice.h" struct SpeciesItem { @@ -69,7 +70,6 @@ extern const union AnimCmd *const *const gMonAnimationsSpriteAnimsPtrTable[]; extern const union AnimCmd *const *const gTrainerBackAnimsPtrTable[]; extern const union AnimCmd *const *const gTrainerFrontAnimsPtrTable[]; extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1]; -extern const struct UnknownPokemonStruct3 gUnknown_08610970[]; extern const struct CompressedSpritePalette gMonPaletteTable[]; extern const struct CompressedSpritePalette gMonShinyPaletteTable[]; extern const u8 gTrainerClassNames[][13]; @@ -80,7 +80,6 @@ extern u8 StorageGetCurrentBox(void); extern void set_unknown_box_id(u8); extern void sub_803FA70(u8 battlerId); extern u8 sav1_map_get_name(void); -extern const u8 *sub_81A1650(u8, u8 language); extern u8 GetFrontierEnemyMonLevel(u8); extern bool8 InBattlePyramid(void); extern bool8 InBattlePike(void); @@ -2873,27 +2872,27 @@ void sub_8068338(struct Pokemon *mon, struct UnknownPokemonStruct *src, bool8 lv CalculateMonStats(mon); } -void sub_8068528(struct Pokemon *mon, const struct UnknownPokemonStruct2 *src, u8 monId) +void CreateApprenticeMon(struct Pokemon *mon, const struct Apprentice *src, u8 monId) { s32 i; u16 evAmount; u8 language; - u32 otId = gUnknown_08610970[src->field_0_0].field_30; - u32 personality = ((gUnknown_08610970[src->field_0_0].field_30 >> 8) | ((gUnknown_08610970[src->field_0_0].field_30 & 0xFF) << 8)) - + src->mons[monId].species + src->field_2; + u32 otId = gApprentices[src->id].otId; + u32 personality = ((gApprentices[src->id].otId >> 8) | ((gApprentices[src->id].otId & 0xFF) << 8)) + + src->monData[monId].species + src->number; CreateMon(mon, - src->mons[monId].species, - GetFrontierEnemyMonLevel(src->field_0_1 - 1), + src->monData[monId].species, + GetFrontierEnemyMonLevel(src->lvlMode - 1), 0x1F, TRUE, personality, TRUE, otId); - SetMonData(mon, MON_DATA_HELD_ITEM, &src->mons[monId].item); + SetMonData(mon, MON_DATA_HELD_ITEM, &src->monData[monId].item); for (i = 0; i < 4; i++) - SetMonMoveSlot(mon, src->mons[monId].moves[i], i); + SetMonMoveSlot(mon, src->monData[monId].moves[i], i); evAmount = MAX_TOTAL_EVS / NUM_STATS; for (i = 0; i < NUM_STATS; i++) @@ -2901,7 +2900,7 @@ void sub_8068528(struct Pokemon *mon, const struct UnknownPokemonStruct2 *src, u language = src->language; SetMonData(mon, MON_DATA_LANGUAGE, &language); - SetMonData(mon, MON_DATA_OT_NAME, sub_81A1650(src->field_0_0, language)); + SetMonData(mon, MON_DATA_OT_NAME, GetApprenticeNameInLanguage(src->id, language)); CalculateMonStats(mon); } diff --git a/src/pokemon_animation.c b/src/pokemon_animation.c index e75f2eeba..6734fce06 100644 --- a/src/pokemon_animation.c +++ b/src/pokemon_animation.c @@ -4,7 +4,7 @@ #include "pokemon_animation.h" #include "trig.h" #include "task.h" -#include "blend_palette.h" +#include "util.h" #include "constants/rgb.h" struct UnkAnimStruct diff --git a/src/record_mixing.c b/src/record_mixing.c index 6c6f69fa8..4c3c3d03c 100644 --- a/src/record_mixing.c +++ b/src/record_mixing.c @@ -83,7 +83,7 @@ struct PlayerRecordsEmerald /* 0x1124 */ struct EmeraldBattleTowerRecord battleTowerRecord; /* 0x1210 */ u16 unk_1210; /* 0x1214 */ LilycoveLady lilycoveLady; - /* 0x1254 */ struct UnkRecordMixingStruct unk_1254[2]; + /* 0x1254 */ struct Apprentice apprentice[2]; /* 0x12dc */ struct UnkRecordMixingStruct2 unk_12dc; /* 0x1434 */ u8 field_1434[0x10]; }; // 0x1444 @@ -134,8 +134,8 @@ static void sub_80E7B2C(const u8 *); static void ReceiveDaycareMailData(struct RecordMixingDayCareMail *, size_t, u8, TVShow *); static void sub_80E7F68(u16 *item, u8 which); static void sub_80E7FF8(u8 taskId); -static void sub_80E8110(struct UnkRecordMixingStruct *arg0, struct UnkRecordMixingStruct *arg1); -static void sub_80E8468(struct UnkRecordMixingStruct *arg0, size_t arg1, u32 arg2); +static void sub_80E8110(struct Apprentice *arg0, struct Apprentice *arg1); +static void ReceiveApprenticeData(struct Apprentice *arg0, size_t arg1, u32 arg2); static void sub_80E89AC(struct UnkRecordMixingStruct2 *arg0, size_t arg1, u32 arg2); static void sub_80E89F8(struct RecordMixingDayCareMail *dst); static void SanitizeDayCareMailForRuby(struct RecordMixingDayCareMail *src); @@ -199,7 +199,7 @@ static void SetSrcLookupPointers(void) gUnknown_03001148 = &gUnknown_02039F9C; sBattleTowerSave = &gSaveBlock2Ptr->frontier.battleTower; sLilycoveLadySave = &gSaveBlock1Ptr->lilycoveLady; - gUnknown_03001154 = gSaveBlock2Ptr->field_DC; + gUnknown_03001154 = gSaveBlock2Ptr->apprentices; sBattleTowerSave_Duplicate = &gSaveBlock2Ptr->frontier.battleTower; } @@ -265,7 +265,7 @@ static void PrepareExchangePacket(void) if (GetMultiplayerId() == 0) sSentRecord->emerald.unk_1210 = GetRecordMixingGift(); - sub_80E8110(sSentRecord->emerald.unk_1254, gUnknown_03001154); + sub_80E8110(sSentRecord->emerald.apprentice, gUnknown_03001154); sub_80E8260(&sSentRecord->emerald.unk_12dc); } } @@ -298,7 +298,7 @@ static void ReceiveExchangePacket(u32 which) ReceiveBattleTowerData(&sReceivedRecords->emerald.battleTowerRecord, sizeof(struct PlayerRecordsEmerald), which); sub_80E7F68(&sReceivedRecords->emerald.unk_1210, which); ReceiveLilycoveLadyData(&sReceivedRecords->emerald.lilycoveLady, sizeof(struct PlayerRecordsEmerald), which); - sub_80E8468(sReceivedRecords->emerald.unk_1254, sizeof(struct PlayerRecordsEmerald), (u8) which); + ReceiveApprenticeData(sReceivedRecords->emerald.apprentice, sizeof(struct PlayerRecordsEmerald), (u8) which); sub_80E89AC(&sReceivedRecords->emerald.unk_12dc, sizeof(struct PlayerRecordsEmerald), (u8) which); } } @@ -1551,13 +1551,13 @@ static void sub_80E7FF8(u8 taskId) // New Emerald functions -static void sub_80E8110(struct UnkRecordMixingStruct *dst, struct UnkRecordMixingStruct *src) +static void sub_80E8110(struct Apprentice *dst, struct Apprentice *src) { s32 i, id; s32 var_2C, var_28, var_24, r8; - dst[0].field_38[0] = 0xFF; - dst[1].field_38[0] = 0xFF; + dst[0].playerName[0] = EOS; + dst[1].playerName[0] = EOS; dst[0] = src[0]; @@ -1567,8 +1567,8 @@ static void sub_80E8110(struct UnkRecordMixingStruct *dst, struct UnkRecordMixin r8 = 0; for (i = 0; i < 2; i++) { - id = ((i + gSaveBlock2Ptr->field_B2_1) % 3) + 1; - if (src[id].field_38[0] != 0xFF) + id = ((i + gSaveBlock2Ptr->playerApprentice.field_B2_1) % 3) + 1; + if (src[id].playerName[0] != EOS) { if (ReadUnalignedWord(src[id].playerId) != ReadUnalignedWord(gSaveBlock2Ptr->playerTrainerId)) { @@ -1597,11 +1597,11 @@ static void sub_80E8110(struct UnkRecordMixingStruct *dst, struct UnkRecordMixin case 2: if (Random2() > 0x3333) { - dst[1] = src[gSaveBlock2Ptr->field_B2_1 + 1]; + dst[1] = src[gSaveBlock2Ptr->playerApprentice.field_B2_1 + 1]; } else { - dst[1] = src[((gSaveBlock2Ptr->field_B2_1 + 1) % 3 + 1)]; + dst[1] = src[((gSaveBlock2Ptr->playerApprentice.field_B2_1 + 1) % 3 + 1)]; } break; } @@ -1646,14 +1646,14 @@ void sub_80E8260(struct UnkRecordMixingStruct2 *dst) } } -static bool32 sub_80E841C(struct UnkRecordMixingStruct *arg0, struct UnkRecordMixingStruct *arg1) +static bool32 sub_80E841C(struct Apprentice *arg0, struct Apprentice *arg1) { s32 i; for (i = 0; i < 4; i++) { if (ReadUnalignedWord(arg0->playerId) == ReadUnalignedWord(arg1[i].playerId) - && arg0->field_0[2] == arg1[i].field_0[2]) + && arg0->number == arg1[i].number) { return TRUE; } @@ -1662,10 +1662,10 @@ static bool32 sub_80E841C(struct UnkRecordMixingStruct *arg0, struct UnkRecordMi return FALSE; } -static void sub_80E8468(struct UnkRecordMixingStruct *arg0, size_t arg1, u32 arg2) +static void ReceiveApprenticeData(struct Apprentice *arg0, size_t arg1, u32 arg2) { s32 i, r7, r8; - struct UnkRecordMixingStruct *structPtr; + struct Apprentice *structPtr; u32 mixIndices[4]; u32 structId; @@ -1675,7 +1675,7 @@ static void sub_80E8468(struct UnkRecordMixingStruct *arg0, size_t arg1, u32 arg r8 = 0; for (i = 0; i < 2; i++) { - if (structPtr[i].field_38[0] != 0xFF && !sub_80E841C(&structPtr[i], gSaveBlock2Ptr->field_DC)) + if (structPtr[i].playerName[0] != EOS && !sub_80E841C(&structPtr[i], &gSaveBlock2Ptr->apprentices[0])) { r7++; r8 = i; @@ -1685,17 +1685,17 @@ static void sub_80E8468(struct UnkRecordMixingStruct *arg0, size_t arg1, u32 arg switch (r7) { case 1: - structId = gSaveBlock2Ptr->field_B2_1 + 1; - gSaveBlock2Ptr->field_DC[structId] = structPtr[r8]; - gSaveBlock2Ptr->field_B2_1 = (gSaveBlock2Ptr->field_B2_1 + 1) % 3; + structId = gSaveBlock2Ptr->playerApprentice.field_B2_1 + 1; + gSaveBlock2Ptr->apprentices[structId] = structPtr[r8]; + gSaveBlock2Ptr->playerApprentice.field_B2_1 = (gSaveBlock2Ptr->playerApprentice.field_B2_1 + 1) % 3; break; case 2: for (i = 0; i < 2; i++) { - structId = ((i ^ 1) + gSaveBlock2Ptr->field_B2_1) % 3 + 1; - gSaveBlock2Ptr->field_DC[structId] = structPtr[i]; + structId = ((i ^ 1) + gSaveBlock2Ptr->playerApprentice.field_B2_1) % 3 + 1; + gSaveBlock2Ptr->apprentices[structId] = structPtr[i]; } - gSaveBlock2Ptr->field_B2_1 = (gSaveBlock2Ptr->field_B2_1 + 2) % 3; + gSaveBlock2Ptr->playerApprentice.field_B2_1 = (gSaveBlock2Ptr->playerApprentice.field_B2_1 + 2) % 3; break; } } diff --git a/src/rom_8011DC0.c b/src/rom_8011DC0.c index 56c31f89f..dc94cb9d5 100644 --- a/src/rom_8011DC0.c +++ b/src/rom_8011DC0.c @@ -1609,7 +1609,7 @@ void sub_80141A4(void) break; case 1: if (!FuncIsActiveTask(sub_80140E0)) - sub_80C4E74(GetMultiplayerId() ^ 1, CB2_ReturnToField); + TrainerCard_ShowLinkCard(GetMultiplayerId() ^ 1, CB2_ReturnToField); break; } @@ -1675,7 +1675,7 @@ void sub_80143E4(void *arg0, bool32 arg1) { u16 *argAsU16Ptr = arg0; - sub_80C30A4(argAsU16Ptr); + TrainerCard_GenerateCardForPlayer((struct TrainerCard *)argAsU16Ptr); if (arg1) argAsU16Ptr[48] = sub_801B39C(); else diff --git a/src/secret_base.c b/src/secret_base.c index 7fae50a81..441bdef04 100644 --- a/src/secret_base.c +++ b/src/secret_base.c @@ -548,7 +548,7 @@ void sub_80E933C(void) gSpecialVar_0x8006 = roomDecorPos[decorIdx] >> 4; gSpecialVar_0x8007 = roomDecorPos[decorIdx] & 0xF; metatile = MapGridGetMetatileBehaviorAt(gSpecialVar_0x8006 + 7, gSpecialVar_0x8007 + 7); - if (MetatileBehavior_IsMB_B5(metatile) == TRUE || MetatileBehavior_IsMB_C3(metatile) == TRUE) + if (MetatileBehavior_IsSecretBaseLargeMatEdge(metatile) == TRUE || MetatileBehavior_IsLargeMatCenter(metatile) == TRUE) { gSpecialVar_Result = gMapHeader.events->eventObjects[objIdx].graphicsId + VAR_0x3F20; VarSet(gSpecialVar_Result, gDecorations[roomDecor[decorIdx]].tiles[0]); @@ -1271,7 +1271,7 @@ void sub_80EA3E4(u8 taskId) } } } - else if (MetatileBehavior_IsMB_BE(behavior) == TRUE) + else if (MetatileBehavior_IsSecretBaseBreakableDoor(behavior) == TRUE) { if (gUnknown_0203A01D == TRUE) { diff --git a/src/shop.c b/src/shop.c new file mode 100755 index 000000000..26151171a --- /dev/null +++ b/src/shop.c @@ -0,0 +1,679 @@ +#include "global.h" +#include "bg.h" +#include "decompress.h" +#include "decoration.h" +#include "field_player_avatar.h" +#include "field_screen.h" +#include "field_weather.h" +#include "fieldmap.h" +#include "gpu_regs.h" +#include "international_string_util.h" +#include "item.h" +#include "item_icon.h" +#include "list_menu.h" +#include "main.h" +#include "malloc.h" +#include "menu.h" +#include "menu_helpers.h" +#include "money.h" +#include "overworld.h" +#include "palette.h" +#include "scanline_effect.h" +#include "script.h" +#include "shop.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "strings.h" +#include "text_window.h" +#include "tv.h" +#include "constants/rgb.h" +#include "constants/songs.h" + +extern struct ShopData *gShopDataPtr; +extern struct ListMenuItem *gUnknown_02039F74; +extern u8 (*gUnknown_02039F78)[16]; +extern struct MartInfo gMartInfo; + +extern const struct WindowTemplate gUnknown_08589A38[2]; +extern const struct MenuAction gUnknown_08589A10[3]; +extern const struct MenuAction gUnknown_08589A28[2]; +extern const struct ListMenuTemplate gUnknown_08589A48; +extern const struct BgTemplate gUnknown_08589A60[4]; +extern const u8 gBuyMenuFrame_Gfx[]; +extern const u8 gBuyMenuFrame_Tilemap[]; +extern const u16 gMenuMoneyPal[]; +extern const struct WindowTemplate gUnknown_08589A70[]; +extern u8 gUnknown_08589AB0[][3]; + +static void Task_ShopMenu(u8 taskId); +void HandleShopMenuQuit(u8 taskId); +void CB2_InitBuyMenu(void); +static void Task_GoToBuyOrSellMenu(u8 taskId); +void CB2_GoToSellMenu(void); +void MapPostLoadHook_ExitBuyOrSellMenu(void); +void Task_ExitSellMenu(u8 taskId); +void ReturnToShopMenuAfterExitingSellMenu(u8 taskId); +void BuyMenuDrawGraphics(void); +void BuyMenuAddScrollIndicatorArrows(void); +void Task_BuyMenu(u8 taskId); +void BuyMenuBuildListMenuTemplate(void); +void BuyMenuInitBgs(void); +void BuyMenuInitWindows(void); +void BuyMenuDecompressBgGraphics(void); +void BuyMenuSetListEntry(struct ListMenuItem*, u16, u8*); +void BuyMenuAddItemIcon(u16, u8); +void BuyMenuRemoveItemIcon(u16, u8); +void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet); +void BuyMenuDrawMapGraphics(void); +void BuyMenuCopyMenuBgToBg1TilemapBuffer(void); +void BuyMenuCollectEventObjectData(void); +void BuyMenuDrawEventObjects(void); +void BuyMenuDrawMapBg(void); +bool8 BuyMenuCheckForOverlapWithMenuBg(u16, u16); +void BuyMenuDrawMapMetatile(s16, s16, u16*, u8); + + +/*static*/ u8 CreateShopMenu(u8 martType) +{ + int numMenuItems; + + ScriptContext2_Enable(); + gMartInfo.martType = martType; + + if (martType == MART_TYPE_0) + { + struct WindowTemplate winTemplate; + winTemplate = gUnknown_08589A38[0]; + winTemplate.width = GetMaxWidthInMenuTable(gUnknown_08589A10, ARRAY_COUNT(gUnknown_08589A10)); + gMartInfo.windowId = AddWindow(&winTemplate); + gMartInfo.menuActions = gUnknown_08589A10; + numMenuItems = ARRAY_COUNT(gUnknown_08589A10); + } + else + { + struct WindowTemplate winTemplate; + winTemplate = gUnknown_08589A38[1]; + winTemplate.width = GetMaxWidthInMenuTable(gUnknown_08589A28, ARRAY_COUNT(gUnknown_08589A28)); + gMartInfo.windowId = AddWindow(&winTemplate); + gMartInfo.menuActions = gUnknown_08589A28; + numMenuItems = ARRAY_COUNT(gUnknown_08589A28); + } + + SetStandardWindowBorderStyle(gMartInfo.windowId, 0); + PrintMenuTable(gMartInfo.windowId, numMenuItems, gMartInfo.menuActions); + InitMenuInUpperLeftCornerPlaySoundWhenAPressed(gMartInfo.windowId, numMenuItems, 0); + PutWindowTilemap(gMartInfo.windowId); + CopyWindowToVram(gMartInfo.windowId, 1); + + return CreateTask(Task_ShopMenu, 8); +} + +/*static*/ void SetShopMenuCallback(void (* callback)(void)) +{ + gMartInfo.callback = callback; +} + +/*static*/ void SetShopItemsForSale(const u16 *items) +{ + u16 i = 0; + + gMartInfo.itemList = items; + gMartInfo.itemCount = 0; + + while (gMartInfo.itemList[i]) + { + gMartInfo.itemCount++; + i++; + } +} + +static void Task_ShopMenu(u8 taskId) +{ + s8 inputCode = Menu_ProcessInputNoWrapAround(); + switch (inputCode) + { + case -2: + break; + case -1: + PlaySE(SE_SELECT); + HandleShopMenuQuit(taskId); + break; + default: + gMartInfo.menuActions[inputCode].func.void_u8(taskId); + break; + } +} + +void HandleShopMenuBuy(u8 taskId) +{ + s16 *taskData = gTasks[taskId].data; + taskData[8] = (u32)CB2_InitBuyMenu >> 16; + taskData[9] = (u32)CB2_InitBuyMenu; + gTasks[taskId].func = Task_GoToBuyOrSellMenu; + FadeScreen(1, 0); +} + +void HandleShopMenuSell(u8 taskId) +{ + s16 *taskData = gTasks[taskId].data; + taskData[8] = (u32)CB2_GoToSellMenu >> 16; + taskData[9] = (u32)CB2_GoToSellMenu; + gTasks[taskId].func = Task_GoToBuyOrSellMenu; + FadeScreen(1, 0); +} + +void CB2_ExitSellMenu(void) +{ + gFieldCallback = MapPostLoadHook_ExitBuyOrSellMenu; + SetMainCallback2(CB2_ReturnToField); +} + +/*static*/ void HandleShopMenuQuit(u8 taskId) +{ + sub_8198070(gMartInfo.windowId, 2); + RemoveWindow(gMartInfo.windowId); + SaveRecordedItemPurchasesForTVShow(); + ScriptContext2_Disable(); + DestroyTask(taskId); + + if (gMartInfo.callback) + gMartInfo.callback(); +} + +static void Task_GoToBuyOrSellMenu(u8 taskId) +{ + s16 *taskData = gTasks[taskId].data; + if (!gPaletteFade.active) + { + DestroyTask(taskId); + SetMainCallback2((void *)((u16)taskData[8] << 16 | (u16)taskData[9])); + } +} + +void MapPostLoadHook_ExitBuyOrSellMenu(void) +{ + pal_fill_black(); + CreateTask(Task_ExitSellMenu, 8); +} + +void Task_ExitSellMenu(u8 taskId) +{ + if (IsWeatherNotFadingIn() == TRUE) + { + if (gMartInfo.martType == MART_TYPE_2) + DisplayItemMessageOnField(taskId, gText_CanIHelpWithAnythingElse, ReturnToShopMenuAfterExitingSellMenu); + else + DisplayItemMessageOnField(taskId, gText_AnythingElseICanHelp, ReturnToShopMenuAfterExitingSellMenu); + } +} + +void ReturnToShopMenuAfterExitingSellMenu(u8 taskId) +{ + CreateShopMenu(gMartInfo.martType); + DestroyTask(taskId); +} + +void CB2_BuyMenu(void) +{ + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + do_scheduled_bg_tilemap_copies_to_vram(); + UpdatePaletteFade(); +} + +void VBlankCB_BuyMenu(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void CB2_InitBuyMenu(void) +{ + u8 taskId; + + switch (gMain.state) + { + case 0: + SetVBlankHBlankCallbacksToNull(); + CpuFastFill(0, (void *)OAM, 0x400); + ScanlineEffect_Stop(); + reset_temp_tile_data_buffers(); + FreeAllSpritePalettes(); + ResetPaletteFade(); + ResetSpriteData(); + ResetTasks(); + clear_scheduled_bg_copies_to_vram(); + gShopDataPtr = AllocZeroed(sizeof(struct ShopData)); + gShopDataPtr->scrollIndicatorsTaskId = 0xFF; + gShopDataPtr->unk200D[0] = -1; + gShopDataPtr->unk200D[1] = -1; + BuyMenuBuildListMenuTemplate(); + BuyMenuInitBgs(); + FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20); + FillBgTilemapBufferRect_Palette0(1, 0, 0, 0, 0x20, 0x20); + FillBgTilemapBufferRect_Palette0(2, 0, 0, 0, 0x20, 0x20); + FillBgTilemapBufferRect_Palette0(3, 0, 0, 0, 0x20, 0x20); + BuyMenuInitWindows(); + BuyMenuDecompressBgGraphics(); + gMain.state++; + break; + case 1: + if (!free_temp_tile_data_buffers_if_possible()) + gMain.state++; + break; + default: + BuyMenuDrawGraphics(); + BuyMenuAddScrollIndicatorArrows(); + taskId = CreateTask(Task_BuyMenu, 8); + gTasks[taskId].data[7] = ListMenuInit(&gMultiuseListMenuTemplate, 0, 0); + BlendPalettes(0xFFFFFFFF, 0x10, RGB_BLACK); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, RGB_BLACK); + SetVBlankCallback(VBlankCB_BuyMenu); + SetMainCallback2(CB2_BuyMenu); + break; + } +} + +void BuyMenuFreeMemory(void) +{ + Free(gShopDataPtr); + Free(gUnknown_02039F74); + Free(gUnknown_02039F78); + FreeAllWindowBuffers(); +} + +void BuyMenuBuildListMenuTemplate(void) +{ + u16 i; + u16 itemCount; + + gUnknown_02039F74 = Alloc((gMartInfo.itemCount + 1) * sizeof(*gUnknown_02039F74)); + gUnknown_02039F78 = Alloc((gMartInfo.itemCount + 1) * sizeof(*gUnknown_02039F78)); + for (i = 0; i < gMartInfo.itemCount; i++) + BuyMenuSetListEntry(&gUnknown_02039F74[i], gMartInfo.itemList[i], gUnknown_02039F78[i]); + + StringCopy(gUnknown_02039F78[i], gText_Cancel2); + gUnknown_02039F74[i].name = gUnknown_02039F78[i]; + gUnknown_02039F74[i].id = -2; + + gMultiuseListMenuTemplate = gUnknown_08589A48; + gMultiuseListMenuTemplate.items = gUnknown_02039F74; + gMultiuseListMenuTemplate.totalItems = gMartInfo.itemCount + 1; + if (gMultiuseListMenuTemplate.totalItems > 8) + gMultiuseListMenuTemplate.maxShowed = 8; + else + gMultiuseListMenuTemplate.maxShowed = gMultiuseListMenuTemplate.totalItems; + + gShopDataPtr->unk2004 = gMultiuseListMenuTemplate.maxShowed; +} + +void BuyMenuSetListEntry(struct ListMenuItem *menuItem, u16 item, u8 *name) +{ + if (gMartInfo.martType == MART_TYPE_0) + CopyItemName(item, name); + else + StringCopy(name, gDecorations[item].name); + + menuItem->name = name; + menuItem->id = item; +} + +void BuyMenuPrintItemDescriptionAndShowItemIcon(int item, bool8 onInit, struct ListMenu *list) +{ + const u8 *description; + if (onInit != TRUE) + PlaySE(SE_SELECT); + + if (item != -2) + BuyMenuAddItemIcon(item, gShopDataPtr->unk200C); + else + BuyMenuAddItemIcon(-1, gShopDataPtr->unk200C); + + BuyMenuRemoveItemIcon(item, gShopDataPtr->unk200C ^ 1); + gShopDataPtr->unk200C ^= 1; + if (item != -2) + { + if (gMartInfo.martType == MART_TYPE_0) + description = ItemId_GetDescription(item); + else + description = gDecorations[item].description; + } + else + { + description = gText_QuitShopping; + } + + FillWindowPixelBuffer(2, 0); + BuyMenuPrint(2, description, 3, 1, 0, 0); +} + +void BuyMenuPrintPriceInList(u8 windowId, int item, u8 y) +{ + u8 x; + + if (item != -2) + { + if (gMartInfo.martType == MART_TYPE_0) + { + ConvertIntToDecimalStringN( + gStringVar1, + ItemId_GetPrice(item) >> GetPriceReduction(1), + STR_CONV_MODE_LEFT_ALIGN, + 5); + } + else + { + ConvertIntToDecimalStringN( + gStringVar1, + gDecorations[item].price, + STR_CONV_MODE_LEFT_ALIGN, + 5); + } + + StringExpandPlaceholders(gStringVar4, gText_PokedollarVar1); + x = GetStringRightAlignXOffset(7, gStringVar4, 0x78); + AddTextPrinterParameterized4(windowId, 7, x, y, 0, 0, gUnknown_08589AB0[1], -1, gStringVar4); + } +} + +void BuyMenuAddScrollIndicatorArrows(void) +{ + if (gShopDataPtr->scrollIndicatorsTaskId == 0xFF && gMartInfo.itemCount + 1 > 8) + { + gShopDataPtr->scrollIndicatorsTaskId = AddScrollIndicatorArrowPairParameterized( + SCROLL_ARROW_UP, + 0xAC, + 0xC, + 0x94, + gMartInfo.itemCount - 7, + 0x834, + 0x834, + &gShopDataPtr->unk2008); + } +} + +void BuyMenuRemoveScrollIndicatorArrows(void) +{ + if (gShopDataPtr->scrollIndicatorsTaskId != 0xFF) + { + RemoveScrollIndicatorArrowPair(gShopDataPtr->scrollIndicatorsTaskId); + gShopDataPtr->scrollIndicatorsTaskId = 0xFF; + } +} + +void BuyMenuPrintCursor(u8 scrollIndicatorsTaskId, u8 colorSet) +{ + u8 y = ListMenuGetYCoordForPrintingArrowCursor(scrollIndicatorsTaskId); + BuyMenuPrint(1, gText_SelectorArrow2, 0, y, 0, colorSet); +} + +void BuyMenuAddItemIcon(u16 item, u8 iconSlot) +{ + u8 spriteId; + u8 *spriteIdPtr = &gShopDataPtr->unk200D[iconSlot]; + if (*spriteIdPtr != 0xFF) + return; + + if (gMartInfo.martType == MART_TYPE_0 || item == 0xFFFF) + { + spriteId = AddItemIconSprite(iconSlot + 0x83E, iconSlot + 0x83E, item); + if (spriteId != MAX_SPRITES) + { + *spriteIdPtr = spriteId; + gSprites[spriteId].pos2.x = 24; + gSprites[spriteId].pos2.y = 88; + } + } + else + { + spriteId = AddDecorationIconObject(item, 20, 84, 1, iconSlot + 0x83E, iconSlot + 0x83E); + if (spriteId != MAX_SPRITES) + *spriteIdPtr = spriteId; + } +} + +void BuyMenuRemoveItemIcon(u16 item, u8 iconSlot) +{ + u8 *spriteIdPtr = &gShopDataPtr->unk200D[iconSlot]; + if (*spriteIdPtr == 0xFF) + return; + + FreeSpriteTilesByTag(iconSlot + 0x83E); + FreeSpritePaletteByTag(iconSlot + 0x83E); + DestroySprite(&gSprites[*spriteIdPtr]); + *spriteIdPtr = 0xFF; +} + +void BuyMenuInitBgs(void) +{ + ResetBgsAndClearDma3BusyFlags(0); + InitBgsFromTemplates(0, gUnknown_08589A60, ARRAY_COUNT(gUnknown_08589A60)); + SetBgTilemapBuffer(1, gShopDataPtr->tilemapBuffers[1]); + SetBgTilemapBuffer(2, gShopDataPtr->tilemapBuffers[3]); + SetBgTilemapBuffer(3, gShopDataPtr->tilemapBuffers[2]); + SetGpuReg(REG_OFFSET_BG0HOFS, 0); + SetGpuReg(REG_OFFSET_BG0VOFS, 0); + SetGpuReg(REG_OFFSET_BG1HOFS, 0); + SetGpuReg(REG_OFFSET_BG1VOFS, 0); + SetGpuReg(REG_OFFSET_BG2HOFS, 0); + SetGpuReg(REG_OFFSET_BG2VOFS, 0); + SetGpuReg(REG_OFFSET_BG3HOFS, 0); + SetGpuReg(REG_OFFSET_BG3VOFS, 0); + SetGpuReg(REG_OFFSET_BLDCNT, 0); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP); + ShowBg(0); + ShowBg(1); + ShowBg(2); + ShowBg(3); +} + +void BuyMenuDecompressBgGraphics(void) +{ + decompress_and_copy_tile_data_to_vram(1, gBuyMenuFrame_Gfx, 0x3A0, 0x3E3, 0); + LZDecompressWram(gBuyMenuFrame_Tilemap, gShopDataPtr->tilemapBuffers[0]); + LoadCompressedPalette(gMenuMoneyPal, 0xC0, 0x20); +} + +void BuyMenuInitWindows(void) +{ + InitWindows(gUnknown_08589A70); + DeactivateAllTextPrinters(); + LoadUserWindowBorderGfx(0, 1, 0xD0); + LoadMessageBoxGfx(0, 0xA, 0xE0); + PutWindowTilemap(0); + PutWindowTilemap(1); + PutWindowTilemap(2); +} + +void BuyMenuPrint(u8 windowId, const u8 *text, u8 x, u8 y, s8 speed, u8 colorSet) +{ + AddTextPrinterParameterized4(windowId, 1, x, y, 0, 0, gUnknown_08589AB0[colorSet], speed, text); +} + +void BuyMenuDisplayMessage(u8 taskId, const u8 *text, TaskFunc callback) +{ + DisplayMessageAndContinueTask(taskId, 5, 10, 14, 1, GetPlayerTextSpeed(), text, callback); + schedule_bg_copy_tilemap_to_vram(0); +} + +void BuyMenuDrawGraphics(void) +{ + BuyMenuDrawMapGraphics(); + BuyMenuCopyMenuBgToBg1TilemapBuffer(); + AddMoneyLabelObject(19, 11); + PrintMoneyAmountInMoneyBoxWithBorder(0, 1, 13, GetMoney(&gSaveBlock1Ptr->money)); + schedule_bg_copy_tilemap_to_vram(0); + schedule_bg_copy_tilemap_to_vram(1); + schedule_bg_copy_tilemap_to_vram(2); + schedule_bg_copy_tilemap_to_vram(3); +} + +void BuyMenuDrawMapGraphics(void) +{ + BuyMenuCollectEventObjectData(); + BuyMenuDrawEventObjects(); + BuyMenuDrawMapBg(); +} + +#ifdef NONMATCHING +// functionally equivalent, but couldn't get the loop variables using the +// stack correctly. Might be related to the tileset metatiles type. +void BuyMenuDrawMapBg(void) +{ + s16 i; + s16 j; + s16 x; + s16 y; + const struct MapLayout *mapLayout; + u16 metatile, metatileLayerType; + + mapLayout = gMapHeader.mapLayout; + GetXYCoordsOneStepInFrontOfPlayer(&x, &y); + x -= 4; + y -= 4; + + for (j = 0; j < 10; j++) + { + for (i = 0; i < 15; i++) + { + metatile = MapGridGetMetatileIdAt(x + i, y + j); + if (BuyMenuCheckForOverlapWithMenuBg(i, j) == TRUE) + metatileLayerType = MapGridGetMetatileLayerTypeAt(x + i, y + j); + else + metatileLayerType = 1; + + if (metatile < 0x200) + { + BuyMenuDrawMapMetatile(i, j, (u16*)mapLayout->primaryTileset->metatiles + metatile * 8, metatileLayerType); + } + else + { + BuyMenuDrawMapMetatile(i, j, (u16*)mapLayout->secondaryTileset->metatiles + ((metatile - 0x200) * 8), metatileLayerType); + } + } + } +} +#else +NAKED +void BuyMenuDrawMapBg(void) +{ + asm_unified("\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x4\n\ + ldr r0, =gMapHeader\n\ + ldr r0, [r0]\n\ + mov r9, r0\n\ + mov r4, sp\n\ + adds r4, 0x2\n\ + mov r0, sp\n\ + adds r1, r4, 0\n\ + bl GetXYCoordsOneStepInFrontOfPlayer\n\ + mov r1, sp\n\ + mov r0, sp\n\ + ldrh r0, [r0]\n\ + subs r0, 0x4\n\ + strh r0, [r1]\n\ + ldrh r0, [r4]\n\ + subs r0, 0x4\n\ + strh r0, [r4]\n\ + movs r1, 0\n\ + mov r10, r4\n\ +_080E05B6:\n\ + movs r4, 0\n\ + lsls r7, r1, 16\n\ + asrs r0, r7, 16\n\ + mov r8, r0\n\ +_080E05BE:\n\ + mov r0, sp\n\ + movs r1, 0\n\ + ldrsh r0, [r0, r1]\n\ + lsls r4, 16\n\ + asrs r5, r4, 16\n\ + adds r0, r5\n\ + mov r2, r10\n\ + movs r3, 0\n\ + ldrsh r1, [r2, r3]\n\ + add r1, r8\n\ + bl MapGridGetMetatileIdAt\n\ + lsls r0, 16\n\ + lsrs r6, r0, 16\n\ + adds r0, r5, 0\n\ + mov r1, r8\n\ + bl BuyMenuCheckForOverlapWithMenuBg\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0x1\n\ + bne _080E0608\n\ + mov r0, sp\n\ + movs r1, 0\n\ + ldrsh r0, [r0, r1]\n\ + adds r0, r5\n\ + mov r2, r10\n\ + movs r3, 0\n\ + ldrsh r1, [r2, r3]\n\ + add r1, r8\n\ + bl MapGridGetMetatileLayerTypeAt\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + b _080E060A\n\ + .pool\n\ +_080E0608:\n\ + movs r5, 0x1\n\ +_080E060A:\n\ + ldr r0, =0x000001ff\n\ + cmp r6, r0\n\ + bhi _080E062C\n\ + asrs r0, r4, 16\n\ + mov r2, r9\n\ + ldr r1, [r2, 0x10]\n\ + lsls r3, r6, 4\n\ + ldr r2, [r1, 0xC]\n\ + adds r2, r3\n\ + asrs r1, r7, 16\n\ + adds r3, r5, 0\n\ + bl BuyMenuDrawMapMetatile\n\ + b _080E0644\n\ + .pool\n\ +_080E062C:\n\ + asrs r0, r4, 16\n\ + mov r3, r9\n\ + ldr r2, [r3, 0x14]\n\ + ldr r3, =0xfffffe00\n\ + adds r1, r6, r3\n\ + lsls r1, 4\n\ + ldr r2, [r2, 0xC]\n\ + adds r2, r1\n\ + asrs r1, r7, 16\n\ + adds r3, r5, 0\n\ + bl BuyMenuDrawMapMetatile\n\ +_080E0644:\n\ + movs r1, 0x80\n\ + lsls r1, 9\n\ + adds r0, r4, r1\n\ + lsrs r4, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0xE\n\ + ble _080E05BE\n\ + adds r0, r7, r1\n\ + lsrs r1, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x9\n\ + ble _080E05B6\n\ + add sp, 0x4\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .pool"); +} +#endif // NONMATCHING diff --git a/src/start_menu.c b/src/start_menu.c index 9d10aeaa4..dcb2c4154 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -88,7 +88,7 @@ extern void CB2_PartyMenuFromStartMenu(void); extern void CB2_PokeNav(void); extern void sub_80C4DDC(void (*)(void)); extern void sub_80C51C4(void (*)(void)); -extern void sub_80C4E74(u8, void (*)(void)); +extern void TrainerCard_ShowLinkCard(u8, void (*)(void)); extern void ScriptUnfreezeEventObjects(void); extern void sub_81A9EC8(void); extern void save_serialize_map(void); @@ -750,7 +750,7 @@ static bool8 StartMenuLinkModePlayerNameCallback(void) { play_some_sound(); overworld_free_bg_tilemaps(); - sub_80C4E74(gUnknown_03005DB4, CB2_ReturnToFieldWithOpenMenu); + TrainerCard_ShowLinkCard(gUnknown_03005DB4, CB2_ReturnToFieldWithOpenMenu); return TRUE; } diff --git a/src/string_util.c b/src/string_util.c index ea50ba5a5..3fbf79d87 100644 --- a/src/string_util.c +++ b/src/string_util.c @@ -20,20 +20,20 @@ static const s32 sPowersOfTen[] = 1000000000, }; -extern u8 gExpandedPlaceholder_Empty[]; -extern u8 gExpandedPlaceholder_Kun[]; -extern u8 gExpandedPlaceholder_Chan[]; -extern u8 gExpandedPlaceholder_Sapphire[]; -extern u8 gExpandedPlaceholder_Ruby[]; -extern u8 gExpandedPlaceholder_Emerald[]; -extern u8 gExpandedPlaceholder_Aqua[]; -extern u8 gExpandedPlaceholder_Magma[]; -extern u8 gExpandedPlaceholder_Archie[]; -extern u8 gExpandedPlaceholder_Maxie[]; -extern u8 gExpandedPlaceholder_Kyogre[]; -extern u8 gExpandedPlaceholder_Groudon[]; -extern u8 gExpandedPlaceholder_Brendan[]; -extern u8 gExpandedPlaceholder_May[]; +extern const u8 gExpandedPlaceholder_Empty[]; +extern const u8 gExpandedPlaceholder_Kun[]; +extern const u8 gExpandedPlaceholder_Chan[]; +extern const u8 gExpandedPlaceholder_Sapphire[]; +extern const u8 gExpandedPlaceholder_Ruby[]; +extern const u8 gExpandedPlaceholder_Emerald[]; +extern const u8 gExpandedPlaceholder_Aqua[]; +extern const u8 gExpandedPlaceholder_Magma[]; +extern const u8 gExpandedPlaceholder_Archie[]; +extern const u8 gExpandedPlaceholder_Maxie[]; +extern const u8 gExpandedPlaceholder_Kyogre[]; +extern const u8 gExpandedPlaceholder_Groudon[]; +extern const u8 gExpandedPlaceholder_Brendan[]; +extern const u8 gExpandedPlaceholder_May[]; u8 *StringCopy10(u8 *dest, const u8 *src) { @@ -348,7 +348,7 @@ u8 *StringExpandPlaceholders(u8 *dest, const u8 *src) { u8 c = *src++; u8 placeholderId; - u8 *expandedString; + const u8 *expandedString; switch (c) { @@ -383,9 +383,9 @@ u8 *StringExpandPlaceholders(u8 *dest, const u8 *src) case EOS: *dest = EOS; return dest; - case 0xFA: - case 0xFB: - case 0xFE: + case CHAR_PROMPT_SCROLL: + case CHAR_PROMPT_CLEAR: + case CHAR_NEWLINE: default: *dest++ = c; } @@ -394,8 +394,8 @@ u8 *StringExpandPlaceholders(u8 *dest, const u8 *src) u8 *StringBraille(u8 *dest, const u8 *src) { - u8 setBrailleFont[] = { 0xFC, 0x06, 0x06, 0xFF }; - u8 gotoLine2[] = { 0xFE, 0xFC, 0x0E, 0x02, 0xFF }; + u8 setBrailleFont[] = { EXT_CTRL_CODE_BEGIN, 0x06, 0x06, EOS }; + u8 gotoLine2[] = { CHAR_NEWLINE, EXT_CTRL_CODE_BEGIN, 0x0E, 0x02, EOS }; dest = StringCopy(dest, setBrailleFont); @@ -408,7 +408,7 @@ u8 *StringBraille(u8 *dest, const u8 *src) case EOS: *dest = c; return dest; - case 0xFE: + case CHAR_NEWLINE: dest = StringCopy(dest, gotoLine2); break; default: @@ -419,32 +419,32 @@ u8 *StringBraille(u8 *dest, const u8 *src) } } -static u8 *ExpandPlaceholder_UnknownStringVar(void) +static const u8 *ExpandPlaceholder_UnknownStringVar(void) { return gUnknownStringVar; } -static u8 *ExpandPlaceholder_PlayerName(void) +static const u8 *ExpandPlaceholder_PlayerName(void) { return gSaveBlock2Ptr->playerName; } -static u8 *ExpandPlaceholder_StringVar1(void) +static const u8 *ExpandPlaceholder_StringVar1(void) { return gStringVar1; } -static u8 *ExpandPlaceholder_StringVar2(void) +static const u8 *ExpandPlaceholder_StringVar2(void) { return gStringVar2; } -static u8 *ExpandPlaceholder_StringVar3(void) +static const u8 *ExpandPlaceholder_StringVar3(void) { return gStringVar3; } -static u8 *ExpandPlaceholder_KunChan(void) +static const u8 *ExpandPlaceholder_KunChan(void) { if (gSaveBlock2Ptr->playerGender == MALE) return gExpandedPlaceholder_Kun; @@ -452,7 +452,7 @@ static u8 *ExpandPlaceholder_KunChan(void) return gExpandedPlaceholder_Chan; } -static u8 *ExpandPlaceholder_RivalName(void) +static const u8 *ExpandPlaceholder_RivalName(void) { if (gSaveBlock2Ptr->playerGender == MALE) return gExpandedPlaceholder_May; @@ -460,44 +460,44 @@ static u8 *ExpandPlaceholder_RivalName(void) return gExpandedPlaceholder_Brendan; } -static u8 *ExpandPlaceholder_Version(void) +static const u8 *ExpandPlaceholder_Version(void) { return gExpandedPlaceholder_Emerald; } -static u8 *ExpandPlaceholder_Aqua(void) +static const u8 *ExpandPlaceholder_Aqua(void) { return gExpandedPlaceholder_Aqua; } -static u8 *ExpandPlaceholder_Magma(void) +static const u8 *ExpandPlaceholder_Magma(void) { return gExpandedPlaceholder_Magma; } -static u8 *ExpandPlaceholder_Archie(void) +static const u8 *ExpandPlaceholder_Archie(void) { return gExpandedPlaceholder_Archie; } -static u8 *ExpandPlaceholder_Maxie(void) +static const u8 *ExpandPlaceholder_Maxie(void) { return gExpandedPlaceholder_Maxie; } -static u8 *ExpandPlaceholder_Kyogre(void) +static const u8 *ExpandPlaceholder_Kyogre(void) { return gExpandedPlaceholder_Kyogre; } -static u8 *ExpandPlaceholder_Groudon(void) +static const u8 *ExpandPlaceholder_Groudon(void) { return gExpandedPlaceholder_Groudon; } -u8 *GetExpandedPlaceholder(u32 id) +const u8 *GetExpandedPlaceholder(u32 id) { - typedef u8 *(*ExpandPlaceholderFunc)(void); + typedef const u8 *(*ExpandPlaceholderFunc)(void); static const ExpandPlaceholderFunc funcs[] = { @@ -574,7 +574,7 @@ u8 *StringCopyN_Multibyte(u8 *dest, u8 *src, u32 n) else { *dest++ = *src++; - if (*(src - 1) == 0xF9) + if (*(src - 1) == CHAR_SPECIAL_F9) *dest++ = *src++; } } @@ -589,7 +589,7 @@ u32 StringLength_Multibyte(u8 *str) while (*str != EOS) { - if (*str == 0xF9) + if (*str == CHAR_SPECIAL_F9) str++; str++; length++; @@ -600,7 +600,7 @@ u32 StringLength_Multibyte(u8 *str) u8 *WriteColorChangeControlCode(u8 *dest, u32 colorType, u8 color) { - *dest = 0xFC; + *dest = EXT_CTRL_CODE_BEGIN; dest++; switch (colorType) @@ -630,7 +630,7 @@ bool32 IsStringJapanese(u8 *str) while (*str != EOS) { if (*str <= 0xA0) - if (*str != 0) + if (*str != CHAR_SPACE) return TRUE; str++; } @@ -645,7 +645,7 @@ bool32 sub_800924C(u8 *str, s32 n) for (i = 0; *str != EOS && i < n; i++) { if (*str <= 0xA0) - if (*str != 0) + if (*str != CHAR_SPACE) return TRUE; str++; } @@ -692,7 +692,7 @@ u8 GetExtCtrlCodeLength(u8 code) static const u8 *SkipExtCtrlCode(const u8 *s) { - while (*s == 0xFC) + while (*s == EXT_CTRL_CODE_BEGIN) { s++; s += GetExtCtrlCodeLength(*s); @@ -716,11 +716,11 @@ s32 StringCompareWithoutExtCtrlCodes(const u8 *str1, const u8 *str2) if (*str1 < *str2) { retVal = -1; - if (*str2 == 0xFF) + if (*str2 == EOS) retVal = 1; } - if (*str1 == 0xFF) + if (*str1 == EOS) return retVal; str1++; @@ -729,7 +729,7 @@ s32 StringCompareWithoutExtCtrlCodes(const u8 *str1, const u8 *str2) retVal = 1; - if (*str1 == 0xFF) + if (*str1 == EOS) retVal = -1; return retVal; @@ -743,9 +743,9 @@ void ConvertInternationalString(u8 *s, u8 language) StripExtCtrlCodes(s); i = StringLength(s); - s[i++] = 0xFC; + s[i++] = EXT_CTRL_CODE_BEGIN; s[i++] = 22; - s[i++] = 0xFF; + s[i++] = EOS; i--; @@ -755,7 +755,7 @@ void ConvertInternationalString(u8 *s, u8 language) i--; } - s[0] = 0xFC; + s[0] = EXT_CTRL_CODE_BEGIN; s[1] = 21; } } @@ -764,9 +764,9 @@ void StripExtCtrlCodes(u8 *str) { u16 srcIndex = 0; u16 destIndex = 0; - while (str[srcIndex] != 0xFF) + while (str[srcIndex] != EOS) { - if (str[srcIndex] == 0xFC) + if (str[srcIndex] == EXT_CTRL_CODE_BEGIN) { srcIndex++; srcIndex += GetExtCtrlCodeLength(str[srcIndex]); @@ -776,5 +776,5 @@ void StripExtCtrlCodes(u8 *str) str[destIndex++] = str[srcIndex++]; } } - str[destIndex] = 0xFF; + str[destIndex] = EOS; } diff --git a/src/task.c b/src/task.c index fafa7c70d..f067e21b4 100644 --- a/src/task.c +++ b/src/task.c @@ -7,7 +7,7 @@ struct Task gTasks[NUM_TASKS]; static void InsertTask(u8 newTaskId); -static u8 FindFirstActiveTask(); +static u8 FindFirstActiveTask(void); void ResetTasks(void) { @@ -124,7 +124,7 @@ void RunTasks(void) } } -static u8 FindFirstActiveTask() +static u8 FindFirstActiveTask(void) { u8 taskId; diff --git a/src/text.c b/src/text.c index e5a9feed8..ec0d26ab1 100644 --- a/src/text.c +++ b/src/text.c @@ -3095,13 +3095,13 @@ u32 GetStringWidthFixedWidthFont(const u8 *str, u8 fontId, u8 letterSpacing) temp = strLocal[strPos++]; switch (temp) { - case 0xFE: - case 0xFF: + case CHAR_NEWLINE: + case EOS: lineWidths[line] = width; width = 0; line++; break; - case 0xFC: + case EXT_CTRL_CODE_BEGIN: temp2 = strLocal[strPos++]; switch (temp2) { @@ -3135,21 +3135,21 @@ u32 GetStringWidthFixedWidthFont(const u8 *str, u8 fontId, u8 letterSpacing) break; } break; - case 0xF7: - case 0xFD: + case CHAR_SPECIAL_F7: + case PLACEHOLDER_BEGIN: ++strPos; break; - case 0xFA: - case 0xFB: + case CHAR_PROMPT_SCROLL: + case CHAR_PROMPT_CLEAR: break; - case 0xF8: - case 0xF9: + case CHAR_SPECIAL_F8: + case CHAR_SPECIAL_F9: ++strPos; default: ++width; break; } - } while (temp != 0xFF); + } while (temp != EOS); for (width = 0, strPos = 0; strPos < 8; ++strPos) { @@ -3201,16 +3201,16 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) lineWidth = 0; bufferPointer = 0; - while (*str != 0xFF) + while (*str != EOS) { switch (*str) { - case 0xFE: + case CHAR_NEWLINE: if (lineWidth > width) width = lineWidth; lineWidth = 0; break; - case 0xFD: + case PLACEHOLDER_BEGIN: switch (*++str) { case 0x2: @@ -3225,10 +3225,10 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) default: return 0; } - case 0xF7: + case CHAR_SPECIAL_F7: if (bufferPointer == NULL) bufferPointer = DynamicPlaceholderTextUtil_GetPlaceholderPtr(*++str); - while (*bufferPointer != 0xFF) + while (*bufferPointer != EOS) { glyphWidth = func(*bufferPointer++, isJapanese); if (minGlyphWidth > 0) @@ -3240,13 +3240,13 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) else { lineWidth += glyphWidth; - if (isJapanese && str[1] != 0xFF) + if (isJapanese && str[1] != EOS) lineWidth += localLetterSpacing; } } bufferPointer = 0; break; - case 0xFC: + case EXT_CTRL_CODE_BEGIN: switch (*++str) { case 0x4: @@ -3299,9 +3299,9 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) break; } break; - case 0xF8: - case 0xF9: - if (*str == 0xF9) + case CHAR_SPECIAL_F8: + case CHAR_SPECIAL_F9: + if (*str == CHAR_SPECIAL_F9) glyphWidth = func(*++str | 0x100, isJapanese); else glyphWidth = GetKeypadIconWidth(*++str); @@ -3315,12 +3315,12 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) else { lineWidth += glyphWidth; - if (isJapanese && str[1] != 0xFF) + if (isJapanese && str[1] != EOS) lineWidth += localLetterSpacing; } break; - case 0xFA: - case 0xFB: + case CHAR_PROMPT_SCROLL: + case CHAR_PROMPT_CLEAR: break; default: glyphWidth = func(*str, isJapanese); @@ -3333,7 +3333,7 @@ u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) else { lineWidth += glyphWidth; - if (isJapanese && str[1] != 0xFF) + if (isJapanese && str[1] != EOS) lineWidth += localLetterSpacing; } break; @@ -3372,7 +3372,7 @@ u8 RenderTextFont9(u8 *pixels, u8 fontId, u8 *str) temp = strLocal[strPos++]; switch (temp) { - case 0xFC: + case EXT_CTRL_CODE_BEGIN: temp2 = strLocal[strPos++]; switch (temp2) { @@ -3421,16 +3421,16 @@ u8 RenderTextFont9(u8 *pixels, u8 fontId, u8 *str) continue; } break; - case 0xF7: - case 0xF8: - case 0xF9: - case 0xFD: + case CHAR_SPECIAL_F7: + case CHAR_SPECIAL_F8: + case CHAR_SPECIAL_F9: + case PLACEHOLDER_BEGIN: ++strPos; break; - case 0xFA: - case 0xFB: - case 0xFE: - case 0xFF: + case CHAR_PROMPT_SCROLL: + case CHAR_PROMPT_CLEAR: + case CHAR_NEWLINE: + case EOS: break; default: switch (fontId) @@ -3450,7 +3450,7 @@ u8 RenderTextFont9(u8 *pixels, u8 fontId, u8 *str) break; } } - while (temp != 0xFF); + while (temp != EOS); RestoreTextColors(&colorBackup[0], &colorBackup[1], &colorBackup[2]); return 1; diff --git a/src/tileset_anims.c b/src/tileset_anims.c index 454a2e435..f7c3cd482 100644 --- a/src/tileset_anims.c +++ b/src/tileset_anims.c @@ -1,7 +1,7 @@ // Includes #include "global.h" #include "palette.h" -#include "blend_palette.h" +#include "util.h" #include "battle_transition.h" #include "task.h" #include "battle_transition.h" @@ -936,7 +936,7 @@ void GabbyAndTyBeforeInterview(void) { gSaveBlock1Ptr->gabbyAndTyData.battleNum ++; } - gSaveBlock1Ptr->gabbyAndTyData.battleTookMoreThanOneTurn = gBattleResults.unk5_0; + gSaveBlock1Ptr->gabbyAndTyData.battleTookMoreThanOneTurn = gBattleResults.playerMonWasDamaged; if (gBattleResults.playerFaintCounter != 0) { gSaveBlock1Ptr->gabbyAndTyData.playerLostAMon = TRUE; diff --git a/src/util.c b/src/util.c index 9c8766a97..47112774a 100644 --- a/src/util.c +++ b/src/util.c @@ -1,6 +1,7 @@ #include "global.h" #include "util.h" #include "sprite.h" +#include "palette.h" const u32 gBitTable[] = { @@ -258,3 +259,20 @@ u32 CalcByteArraySum(const u8* data, u32 length) sum += data[i]; return sum; } + +void BlendPalette(u16 palOffset, u16 numEntries, u8 coeff, u16 blendColor) +{ + u16 i; + for (i = 0; i < numEntries; i++) + { + u16 index = i + palOffset; + struct PlttData *data1 = (struct PlttData *)&gPlttBufferUnfaded[index]; + s8 r = data1->r; + s8 g = data1->g; + s8 b = data1->b; + struct PlttData *data2 = (struct PlttData *)&blendColor; + gPlttBufferFaded[index] = ((r + (((data2->r - r) * coeff) >> 4)) << 0) + | ((g + (((data2->g - g) * coeff) >> 4)) << 5) + | ((b + (((data2->b - b) * coeff) >> 4)) << 10); + } +} |