diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/battle_dome_cards.c | 430 | ||||
| -rw-r--r-- | src/berry.c | 6 | ||||
| -rw-r--r-- | src/berry_fix_program.c | 531 | ||||
| -rw-r--r-- | src/egg_hatch.c | 8 | ||||
| -rwxr-xr-x | src/field_map_obj.c | 5118 | ||||
| -rw-r--r-- | src/item.c | 12 | ||||
| -rw-r--r-- | src/lilycove_lady.c | 1101 | ||||
| -rw-r--r-- | src/load_save.c | 4 | ||||
| -rw-r--r-- | src/malloc.c | 5 | ||||
| -rw-r--r-- | src/multiboot.c | 2 | ||||
| -rw-r--r-- | src/pokemon_2.c | 6 | ||||
| -rw-r--r-- | src/pokemon_3.c | 24 | ||||
| -rw-r--r-- | src/pokemon_size_record.c | 8 | ||||
| -rw-r--r-- | src/reset_save_heap.c | 32 | ||||
| -rw-r--r-- | src/start_menu.c | 8 | ||||
| -rw-r--r-- | src/text.c | 6 | ||||
| -rw-r--r-- | src/trig.c | 3 |
17 files changed, 7255 insertions, 49 deletions
diff --git a/src/battle_dome_cards.c b/src/battle_dome_cards.c new file mode 100644 index 000000000..c0557ac70 --- /dev/null +++ b/src/battle_dome_cards.c @@ -0,0 +1,430 @@ + +// Includes +#include "global.h" +#include "sprite.h" +#include "window.h" +#include "malloc.h" +#include "species.h" +#include "palette.h" +#include "decompress.h" +#include "battle_dome_cards.h" + +extern const struct CompressedSpriteSheet gMonFrontPicTable[NUM_SPECIES]; +extern const struct CompressedSpriteSheet gMonBackPicTable[NUM_SPECIES]; +extern const struct CompressedSpriteSheet gTrainerFrontPicTable[]; +extern const struct CompressedSpriteSheet gTrainerBackPicTable[]; +extern const struct CompressedSpritePalette gTrainerFrontPicPaletteTable[]; +extern const union AffineAnimCmd *const gUnknown_082FF618[]; +extern const union AffineAnimCmd *const gUnknown_082FF694[]; +extern const union AnimCmd *const gUnknown_082FF70C[]; +extern const union AnimCmd *const *const gUnknown_08309AAC[NUM_SPECIES]; +extern const union AnimCmd *const *const gUnknown_0830536C[]; +extern const u8 gUnknown_0831F578[]; + +// Static type declarations + +struct BattleDomeCard { + u8 *frames; + struct SpriteFrameImage *images; + u16 paletteTag; + u8 spriteId; + u8 active; +}; + +// Static RAM declarations + +static EWRAM_DATA struct SpriteTemplate gUnknown_0203CCEC = {}; +static EWRAM_DATA struct BattleDomeCard gUnknown_0203CD04[8] = {}; + +// Static ROM declarations + +// .rodata + +static const struct BattleDomeCard gUnknown_0860B058 = {}; +static const struct OamData gUnknown_0860B064 = { + .size = 3 +}; +static const struct OamData gUnknown_0860B06C = { + .affineMode = 1, .size = 3 +}; + +// .text + +static void nullsub_122(struct Sprite *sprite) +{ + +} + +bool16 dp13_810BB8C(void) +{ + int i; + + for (i = 0; i < 8; i ++) + { + gUnknown_0203CD04[i] = gUnknown_0860B058; + } + return FALSE; +} + +static bool16 load_pokemon_image_TODO(u16 species, u32 personality, bool8 isFrontPic, u8 *dest, bool8 isTrainer, bool8 ignoreDeoxys) +{ + if (!isTrainer) + { + if (isFrontPic) + { + if (!ignoreDeoxys) + { + LoadSpecialPokePic(&gMonFrontPicTable[species], dest, species, personality, isFrontPic); + } + else + { + LoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species], dest, species, personality, isFrontPic); + } + } + else + { + if (!ignoreDeoxys) + { + LoadSpecialPokePic(&gMonBackPicTable[species], dest, species, personality, isFrontPic); + } + else + { + LoadSpecialPokePic_DontHandleDeoxys(&gMonBackPicTable[species], dest, species, personality, isFrontPic); + } + } + } + else + { + if (isFrontPic) + { + DecompressPicFromTable(&gTrainerFrontPicTable[species], dest, species); + } + else + { + DecompressPicFromTable(&gTrainerBackPicTable[species], dest, species); + } + } + return FALSE; +} + +static bool16 sub_818D09C(u16 species, u32 personality, bool8 isFrontPic, u8 *dest, bool8 isTrainer) +{ + return load_pokemon_image_TODO(species, personality, isFrontPic, dest, isTrainer, FALSE); +} + +static void sub_818D0C4(u16 species, u32 otId, u32 personality, u8 paletteSlot, u16 paletteTag, bool8 isTrainer) +{ + if (!isTrainer) + { + if (paletteTag == 0xFFFF) + { + gUnknown_0203CCEC.paletteTag |= 0xFFFF; + LoadCompressedPalette(species_and_otid_get_pal(species, otId, personality), 0x100 + paletteSlot * 0x10, 0x20); + } + else + { + gUnknown_0203CCEC.paletteTag = paletteTag; + LoadCompressedObjectPalette(sub_806E7CC(species, otId, personality)); + } + } + else + { + if (paletteTag == 0xFFFF) + { + gUnknown_0203CCEC.paletteTag |= 0xFFFF; + LoadCompressedPalette(gTrainerFrontPicPaletteTable[species].data, 0x100 + paletteSlot * 0x10, 0x20); + } + else + { + gUnknown_0203CCEC.paletteTag = paletteTag; + LoadCompressedObjectPalette(&gTrainerFrontPicPaletteTable[species]); + } + } +} + +static void sub_818D180(u16 species, u32 otId, u32 personality, u8 paletteSlot, bool8 isTrainer) +{ + if (!isTrainer) + { + LoadCompressedPalette(species_and_otid_get_pal(species, otId, personality), paletteSlot * 0x10, 0x20); + } + else + { + LoadCompressedPalette(gTrainerFrontPicPaletteTable[species].data, paletteSlot * 0x10, 0x20); + } +} + +static void uns_builder_assign_animtable1(bool8 isTrainer) +{ + if (!isTrainer) + { + gUnknown_0203CCEC.anims = gUnknown_082FF70C; + } + else + { + gUnknown_0203CCEC.anims = gUnknown_0830536C[0]; + } +} + +static u16 oamt_spawn_poke_or_trainer_picture(u16 species, u32 otId, u32 personality, bool8 isFrontPic, s16 x, s16 y, u8 paletteSlot, u16 paletteTag, bool8 isTrainer, bool8 ignoreDeoxys) +{ + u8 i; + u8 *framePics; + struct SpriteFrameImage *images; + int j; + u8 spriteId; + + for (i = 0; i < 8; i ++) + { + if (!gUnknown_0203CD04[i].active) + { + break; + } + } + if (i == 8) + { + return 0xFFFF; + } + framePics = Alloc(4 * 0x800); + if (!framePics) + { + return 0xFFFF; + } + images = Alloc(4 * sizeof(struct SpriteFrameImage)); + if (!images) + { + Free(framePics); + return 0xFFFF; + } + if (load_pokemon_image_TODO(species, personality, isFrontPic, framePics, isTrainer, ignoreDeoxys)) + { + // debug trap? + return 0xFFFF; + } + for (j = 0; j < 4; j ++) + { + images[j].data = framePics + 0x800 * j; + images[j].size = 0x800; + } + gUnknown_0203CCEC.tileTag = 0xFFFF; + gUnknown_0203CCEC.oam = &gUnknown_0860B064; + uns_builder_assign_animtable1(isTrainer); + gUnknown_0203CCEC.images = images; + gUnknown_0203CCEC.affineAnims = gDummySpriteAffineAnimTable; + gUnknown_0203CCEC.callback = nullsub_122; + sub_818D0C4(species, otId, personality, paletteSlot, paletteTag, isTrainer); + spriteId = CreateSprite(&gUnknown_0203CCEC, x, y, 0); + if (paletteTag == 0xFFFF) + { + gSprites[spriteId].oam.paletteNum = paletteSlot; + } + gUnknown_0203CD04[i].frames = framePics; + gUnknown_0203CD04[i].images = images; + gUnknown_0203CD04[i].paletteTag = paletteTag; + gUnknown_0203CD04[i].spriteId = spriteId; + gUnknown_0203CD04[i].active = TRUE; + return spriteId; +} + +static u16 sub_818D384(u16 species, u32 otId, u32 personality, bool8 isFrontPic, s16 x, s16 y, u8 paletteSlot, u16 paletteTag, bool8 isTrainer) +{ + return oamt_spawn_poke_or_trainer_picture(species, otId, personality, isFrontPic, x, y, paletteSlot, paletteTag, isTrainer, FALSE); +} + +u16 sub_818D3E4(u16 species, u32 otId, u32 personality, u8 flags, s16 x, s16 y, u8 paletteSlot, u16 paletteTag) +{ + u8 *framePics; + struct SpriteFrameImage *images; + int j; + u8 i; + u8 spriteId; + u8 flags2; + + for (i = 0; i < 8; i ++) + { + if (!gUnknown_0203CD04[i].active) + { + break; + } + } + if (i == 8) + { + return 0xFFFF; + } + framePics = Alloc(4 * 0x800); + if (!framePics) + { + return 0xFFFF; + } + if (flags & 0x80) + { + flags &= 0x7F; + flags2 = 3; + } + else + { + flags2 = flags; + } + images = Alloc(4 * sizeof(struct SpriteFrameImage)); + if (!images) + { + Free(framePics); + return 0xFFFF; + } + if (load_pokemon_image_TODO(species, personality, flags, framePics, FALSE, FALSE)) + { + // debug trap? + return 0xFFFF; + } + for (j = 0; j < 4; j ++) + { + images[j].data = framePics + 0x800 * j; + images[j].size = 0x800; + } + gUnknown_0203CCEC.tileTag = 0xFFFF; + gUnknown_0203CCEC.anims = gUnknown_08309AAC[species]; + gUnknown_0203CCEC.images = images; + if (flags2 == 0x01) + { + gUnknown_0203CCEC.affineAnims = gUnknown_082FF694; + gUnknown_0203CCEC.oam = &gUnknown_0860B06C; + } + else if (flags2 == 0x00) + { + gUnknown_0203CCEC.affineAnims = gUnknown_082FF618; + gUnknown_0203CCEC.oam = &gUnknown_0860B06C; + } + else + { + gUnknown_0203CCEC.oam = &gUnknown_0860B064; + gUnknown_0203CCEC.affineAnims = gDummySpriteAffineAnimTable; + } + gUnknown_0203CCEC.callback = nullsub_122; + sub_818D0C4(species, otId, personality, paletteSlot, paletteTag, FALSE); + spriteId = CreateSprite(&gUnknown_0203CCEC, x, y, 0); + if (paletteTag == 0xFFFF) + { + gSprites[spriteId].oam.paletteNum = paletteSlot; + } + gUnknown_0203CD04[i].frames = framePics; + gUnknown_0203CD04[i].images = images; + gUnknown_0203CD04[i].paletteTag = paletteTag; + gUnknown_0203CD04[i].spriteId = spriteId; + gUnknown_0203CD04[i].active = TRUE; + return spriteId; +} + +static u16 sub_818D5B0(u16 spriteId) +{ + u8 i; + u8 *framePics; + struct SpriteFrameImage *images; + + for (i = 0; i < 8; i ++) + { + if (gUnknown_0203CD04[i].spriteId == spriteId) + { + break; + } + } + if (i == 8) + { + return 0xFFFF; + } + framePics = gUnknown_0203CD04[i].frames; + images = gUnknown_0203CD04[i].images; + if (gUnknown_0203CD04[i].paletteTag != 0xFFFF) + { + FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(gSprites[spriteId].oam.paletteNum)); + } + DestroySprite(&gSprites[spriteId]); + Free(framePics); + Free(images); + gUnknown_0203CD04[i] = gUnknown_0860B058; + return 0; +} + +static u16 sub_818D65C(u16 species, u32 otId, u32 personality, bool8 isFrontPic, u8 paletteSlot, u8 windowId, bool8 isTrainer) +{ + if (sub_818D09C(species, personality, isFrontPic, (u8 *)GetWindowAttribute(windowId, WINDOW_TILE_DATA), FALSE)) + { + return 0xFFFF; + } + sub_818D180(species, otId, personality, paletteSlot, isTrainer); + return 0; +} + +static u16 sub_818D6CC(u16 species, u32 otId, u32 personality, bool8 isFrontPic, u16 destX, u16 destY, u8 paletteSlot, u8 windowId, bool8 isTrainer) +{ + u8 *framePics; + + framePics = Alloc(4 * 0x800); + if (framePics && !sub_818D09C(species, personality, isFrontPic, framePics, isTrainer)) + { + BlitBitmapRectToWindow(windowId, framePics, 0, 0, 0x40, 0x40, destX, destY, 0x40, 0x40); + sub_818D180(species, otId, personality, paletteSlot, isTrainer); + Free(framePics); + return 0; + } + return 0xFFFF; +} + +static u16 sub_818D778(u16 species, u32 otId, u32 personality, bool8 isFrontPic, s16 x, s16 y, u8 paletteSlot, u16 paletteTag, bool8 ignoreDeoxys) +{ + return oamt_spawn_poke_or_trainer_picture(species, otId, personality, isFrontPic, x, y, paletteSlot, paletteTag, FALSE, ignoreDeoxys); +} + +u16 sub_818D7D8(u16 species, u32 otId, u32 personality, bool8 isFrontPic, s16 x, s16 y, u8 paletteSlot, u16 paletteTag) +{ + return sub_818D778(species, otId, personality, isFrontPic, x, y, paletteSlot, paletteTag, FALSE); +} + +u16 sub_818D820(u16 spriteId) +{ + return sub_818D5B0(spriteId); +} + +u16 sub_818D834(u16 species, u32 otId, u32 personality, bool8 isFrontPic, u8 paletteSlot, u8 windowId) +{ + return sub_818D65C(species, otId, personality, isFrontPic, paletteSlot, windowId, FALSE); +} + +u16 sub_818D864(u16 species, u32 otId, u32 personality, bool8 isFrontPic, u16 destX, u16 destY, u8 paletteSlot, u8 windowId) +{ + return sub_818D6CC(species, otId, personality, isFrontPic, destX, destY, paletteSlot, windowId, FALSE); +} + +u16 sub_818D8AC(u16 species, bool8 isFrontPic, s16 x, s16 y, u8 paletteSlot, u16 paletteTag) +{ + return sub_818D384(species, 0, 0, isFrontPic, x, y, paletteSlot, paletteTag, TRUE); +} + +u16 sub_818D8F0(u16 spriteId) +{ + return sub_818D5B0(spriteId); +} + +u16 sub_818D904(u16 species, bool8 isFrontPic, u8 paletteSlot, u8 windowId) +{ + return sub_818D65C(species, 0, 0, isFrontPic, paletteSlot, windowId, TRUE); +} + +u16 sub_818D938(u16 species, bool8 isFrontPic, u16 destX, u16 destY, u8 paletteSlot, u8 windowId) +{ + return sub_818D6CC(species, 0, 0, isFrontPic, destX, destY, paletteSlot, windowId, TRUE); +} + +u8 sub_818D97C(u8 a0, u8 a1) +{ + if (a1 == 1) + { + switch (a0) + { + default: + return gUnknown_0831F578[0x3F]; + case 0: + return gUnknown_0831F578[0x3C]; + } + } + return a0; +} diff --git a/src/berry.c b/src/berry.c index b6eaa14a0..e9d6994f8 100644 --- a/src/berry.c +++ b/src/berry.c @@ -807,7 +807,7 @@ const struct Berry gBerries[] = // unused void ClearEnigmaBerries(void) { - CpuFill16(0, &gSaveBlock1Ptr->enigmaBerry, sizeof(gSaveBlock1Ptr->enigmaBerry)); + CpuFill16(0, &gSaveBlock1Ptr->enigmaBerry, 52); } void SetEnigmaBerry(u8 *src) @@ -815,7 +815,7 @@ void SetEnigmaBerry(u8 *src) u32 i; u8 *dest = (u8*)&gSaveBlock1Ptr->enigmaBerry; - for (i = 0; i < sizeof(gSaveBlock1Ptr->enigmaBerry); i++) + for (i = 0; i < 52; i++) dest[i] = src[i]; } @@ -827,7 +827,7 @@ u32 GetEnigmaBerryChecksum(struct EnigmaBerry *enigmaBerry) dest = (u8*)enigmaBerry; checksum = 0; - for (i = 0; i < sizeof(gSaveBlock1Ptr->enigmaBerry) - sizeof(gSaveBlock1Ptr->enigmaBerry.checksum); i++) + for (i = 0; i < 52 - sizeof(gSaveBlock1Ptr->enigmaBerry.checksum); i++) { checksum += dest[i]; } diff --git a/src/berry_fix_program.c b/src/berry_fix_program.c new file mode 100644 index 000000000..f04308ae8 --- /dev/null +++ b/src/berry_fix_program.c @@ -0,0 +1,531 @@ + +// Includes +#include "global.h" +#include "gpu_regs.h" +#include "multiboot.h" +#include "malloc.h" +#include "bg.h" +#include "main.h" +#include "sprite.h" +#include "task.h" +#include "unknown_task.h" +#include "window.h" +#include "menu.h" +#include "m4a.h" + +// Static type declarations + +typedef struct { + u8 state; + u8 unk1; + u16 unk2; + struct MultiBootParam mb; +} berryfix_t; + +// Static RAM declarations + +static berryfix_t *berry_fix_mb_manager; + +// Static ROM declarations + +static void berry_fix_main(void); +static void berry_fix_gpu_set(void); +static int berry_fix_text_update(int); +static void berry_fix_text_print(int); +static void berry_fix_bg_hide(void); + +// .rodata + +static const u8 gUnknown_08617E78[] = _("Berry Program Update"); +static const u8 gUnknown_08617E8D[] = _("Ruby/Sapphire"); +static const u8 gUnknown_08617E9B[] = _("Emerald"); + +static const u8 Unknown_08617EA3[] = _("The Berry Program on your POKéMON\nRuby/Sapphire Game Pak will be updated.\n{COLOR RED}{SHADOW LIGHT_RED}Press the A Button."); +static const u8 Unknown_08617F07[] = _("Please ensure the connection of your\nGame Boy Advance system matches this.\n{COLOR RED}{SHADOW LIGHT_RED}YES: Press the A Button.\nNO: Turn off the power and try again."); +static const u8 Unknown_08617F97[] = _("Please turn on the power of POKéMON\nRuby/Sapphire while holding START and\nSELECT simultaneously. Then, ensure\nthe picture above appears."); +static const u8 Unknown_08618020[] = _("Transmitting. Please wait.\n{COLOR RED}{SHADOW LIGHT_RED}Please do not turn off the power or\nunplug the Game Boy Advance Game\nLink Cable."); +static const u8 Unknown_08618092[] = _("Please follow the instructions on your\nPOKéMON Ruby/Sapphire screen."); +static const u8 Unknown_086180D7[] = _("Transmission failure.\n{COLOR RED}{SHADOW LIGHT_RED}Please try again."); + +static const struct BgTemplate gUnknown_08618108[] = { + { + 0, 0, 30, 0, 0, 0 + }, { + 1, 1, 31, 0, 0, 1 + } +}; + +static const struct WindowTemplate gUnknown_08618110[] = { + {0, 2, 4, 26, 2, 15, 0x001}, + {0, 1, 11, 28, 8, 15, 0x035}, + {0, 0, 8, 30, 2, 15, 0x115}, + {0, 8, 0, 14, 2, 15, 0x151}, + {-1} +}; + +static const u16 gUnknown_08618138[] = { + 0x7fff, 0x7fff, 0x318c, 0x675a, + 0x043c, 0x3aff, 0x0664, 0x4bd2, + 0x6546, 0x7b14, 0x7fff, 0x318c, + 0x675a, 0x0000, 0x0000, 0x0000 +}; + +static const u8 gUnknown_08618158[] = {10, 11, 12}; +static const u8 gUnknown_0861815B[] = { 0, 10, 13}; + +static const u8 *const gUnknown_08618160[] = { + Unknown_08617F07, + Unknown_08617F97, + Unknown_08618020, + Unknown_08618092, + Unknown_086180D7, + Unknown_08617EA3 +}; + +extern const u8 gUnknown_08DD87C0[]; +extern const u8 gUnknown_08DD8EE0[]; +extern const u8 gUnknown_08DD8780[]; +extern const u8 gUnknown_08DD90E0[]; +extern const u8 gUnknown_08DD9718[]; +extern const u8 gUnknown_08DD9080[]; +extern const u8 gUnknown_08DD98B4[]; +extern const u8 gUnknown_08DD9E58[]; +extern const u8 gUnknown_08DD9874[]; +extern const u8 gUnknown_08DDA02C[]; +extern const u8 gUnknown_08DDA63C[]; +extern const u8 gUnknown_08DD9FEC[]; +extern const u8 gUnknown_08DDA840[]; +extern const u8 gUnknown_08DDAE40[]; +extern const u8 gUnknown_08DDA800[]; +extern const u8 gUnknown_08DDB020[]; +extern const u8 gUnknown_08DDB2C4[]; +extern const u8 gUnknown_08DDAFE0[]; + +static const u8 *const gUnknown_08618178[][3] = { + { + gUnknown_08DD87C0, + gUnknown_08DD8EE0, + gUnknown_08DD8780 + }, { + gUnknown_08DD90E0, + gUnknown_08DD9718, + gUnknown_08DD9080 + }, { + gUnknown_08DD98B4, + gUnknown_08DD9E58, + gUnknown_08DD9874 + }, { + gUnknown_08DDA02C, + gUnknown_08DDA63C, + gUnknown_08DD9FEC + }, { + gUnknown_08DDA840, + gUnknown_08DDAE40, + gUnknown_08DDA800 + }, { + gUnknown_08DDB020, + gUnknown_08DDB2C4, + gUnknown_08DDAFE0 + }, +}; + +extern const u8 gUnknown_089A6550[0xC0]; +extern const u8 gMultiBootProgram_BerryGlitchFix_Start[0x3b34]; +extern const u8 gMultiBootProgram_BerryGlitchFix_End[]; + +// .text + +void InitBerryFixProgram(void) +{ + DisableInterrupts(0xFFFF); + EnableInterrupts(0x0001); + m4aSoundVSyncOff(); + SetVBlankCallback(NULL); + ResetSpriteData(); + ResetTasks(); + remove_some_task(); + SetGpuReg(REG_OFFSET_DISPCNT, 0x0000); + berry_fix_mb_manager = AllocZeroed(0x50); + berry_fix_mb_manager->state = 0; + berry_fix_mb_manager->unk1 = 6; + SetMainCallback2(berry_fix_main); +} + +static void berry_fix_main(void) +{ + switch (berry_fix_mb_manager->state) + { + case 0: + berry_fix_gpu_set(); + berry_fix_mb_manager->state = 1; + break; + case 1: + if (berry_fix_text_update(5) == 5 && (gMain.newKeys & A_BUTTON)) + { + berry_fix_mb_manager->state = 2; + } + break; + case 2: + if (berry_fix_text_update(0) == 0 && (gMain.newKeys & A_BUTTON)) + { + berry_fix_mb_manager->state = 3; + } + break; + case 3: + if (berry_fix_text_update(1) == 1) + { + berry_fix_mb_manager->mb.masterp = gUnknown_089A6550; + berry_fix_mb_manager->mb.server_type = 0; + MultiBootInit(&berry_fix_mb_manager->mb); + berry_fix_mb_manager->unk2 = 0; + berry_fix_mb_manager->state = 4; + } + break; + case 4: + MultiBootMain(&berry_fix_mb_manager->mb); + if (berry_fix_mb_manager->mb.probe_count != 0 || (!(berry_fix_mb_manager->mb.response_bit & 2) || !(berry_fix_mb_manager->mb.client_bit & 2))) + { + berry_fix_mb_manager->unk2 = 0; + } + else if (++ berry_fix_mb_manager->unk2 > 180) + { + MultiBootStartMaster(&berry_fix_mb_manager->mb, gMultiBootProgram_BerryGlitchFix_Start, (u32)(gMultiBootProgram_BerryGlitchFix_End - gMultiBootProgram_BerryGlitchFix_Start), 4, 1); + berry_fix_mb_manager->state = 5; + } + break; + case 5: + if (berry_fix_text_update(2) == 2) { + MultiBootMain(&berry_fix_mb_manager->mb); + if (MultiBootCheckComplete(&berry_fix_mb_manager->mb)) { + berry_fix_mb_manager->state = 6; + } + else if (!(berry_fix_mb_manager->mb.client_bit & 2)) { + berry_fix_mb_manager->state = 7; + } + } + break; + case 6: + if (berry_fix_text_update(3) == 3 && gMain.newKeys & A_BUTTON) + { + DoSoftReset(); + } + break; + case 7: + if (berry_fix_text_update(4) == 4 && gMain.newKeys & A_BUTTON) + { + berry_fix_mb_manager->state = 1; + } + break; + } +} + +#ifdef NONMATCHING +static void berry_fix_gpu_set(void) +{ + s32 width; + + SetGpuReg(REG_OFFSET_BG0CNT, 0x0000); + SetGpuReg(REG_OFFSET_BG1CNT, 0x0000); + SetGpuReg(REG_OFFSET_BG0HOFS, 0x0000); + SetGpuReg(REG_OFFSET_BG0VOFS, 0x0000); + SetGpuReg(REG_OFFSET_BG1HOFS, 0x0000); + SetGpuReg(REG_OFFSET_BG1VOFS, 0x0000); + SetGpuReg(REG_OFFSET_BLDCNT, 0x0000); + + DmaFill32(3, 0, VRAM, VRAM_SIZE); + DmaFill32(3, 0, OAM, OAM_SIZE); + DmaFill32(3, 0, PLTT, PLTT_SIZE); + ResetBgsAndClearDma3BusyFlags(0); + + InitBgsFromTemplates(0, gUnknown_08618108, ARRAY_COUNT(gUnknown_08618108)); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + InitWindows(gUnknown_08618110); + DeactivateAllTextPrinters(); + + DmaCopy32(3, gUnknown_08618138, BG_PLTT + 0x1E0, 0x20); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP); + FillWindowPixelBuffer(2, 0); + FillWindowPixelBuffer(3, 0); + FillWindowPixelBuffer(0, 0xAA); + +// This block is a meme among memes + width = (0x78 - GetStringWidth(0, gUnknown_08617E9B, 0)) / 2; + box_print(2, 0, width, 3, gUnknown_0861815B, -1, gUnknown_08617E9B); + width = (s32)(0x78 - GetStringWidth(0, gUnknown_08617E9B, 0)) / 2 + 0x78; + box_print(2, 0, width, 3, gUnknown_0861815B, -1, gUnknown_08617E8D); + width = (0x70 - GetStringWidth(0, gUnknown_08617E8D, 0)) / 2; + box_print(3, 0, width, 0, gUnknown_0861815B, -1, gUnknown_08617E8D); + width = (0xd0 - GetStringWidth(1, gUnknown_08617E78, 0)) / 2; + box_print(0, 1, width, 2, gUnknown_08618158, -1, gUnknown_08617E78); + + CopyWindowToVram(2, 2); + CopyWindowToVram(3, 2); + CopyWindowToVram(0, 2); +} + +#else +__attribute__((naked)) static void berry_fix_gpu_set(void) +{ + asm(".syntax unified\n" + "\tpush {r4-r6,lr}\n" + "\tmov r6, r8\n" + "\tpush {r6}\n" + "\tsub sp, 0x10\n" + "\tmovs r0, 0x8\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0xA\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x10\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x12\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x14\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x16\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x50\n" + "\tmovs r1, 0\n" + "\tbl SetGpuReg\n" + "\tmovs r1, 0\n" + "\tstr r1, [sp, 0xC]\n" + "\tldr r4, =0x040000d4\n" + "\tadd r0, sp, 0xC\n" + "\tstr r0, [r4]\n" + "\tmovs r0, 0xC0\n" + "\tlsls r0, 19\n" + "\tstr r0, [r4, 0x4]\n" + "\tldr r0, =0x85006000\n" + "\tstr r0, [r4, 0x8]\n" + "\tldr r0, [r4, 0x8]\n" + "\tstr r1, [sp, 0xC]\n" + "\tadd r0, sp, 0xC\n" + "\tstr r0, [r4]\n" + "\tmovs r0, 0xE0\n" + "\tlsls r0, 19\n" + "\tstr r0, [r4, 0x4]\n" + "\tldr r2, =0x85000100\n" + "\tstr r2, [r4, 0x8]\n" + "\tldr r0, [r4, 0x8]\n" + "\tstr r1, [sp, 0xC]\n" + "\tadd r0, sp, 0xC\n" + "\tstr r0, [r4]\n" + "\tmovs r0, 0xA0\n" + "\tlsls r0, 19\n" + "\tstr r0, [r4, 0x4]\n" + "\tstr r2, [r4, 0x8]\n" + "\tldr r0, [r4, 0x8]\n" + "\tmovs r0, 0\n" + "\tbl ResetBgsAndClearDma3BusyFlags\n" + "\tldr r1, =gUnknown_08618108\n" + "\tmovs r0, 0\n" + "\tmovs r2, 0x2\n" + "\tbl InitBgsFromTemplates\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0\n" + "\tbl ChangeBgX\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0\n" + "\tbl ChangeBgY\n" + "\tmovs r0, 0x1\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0\n" + "\tbl ChangeBgX\n" + "\tmovs r0, 0x1\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0\n" + "\tbl ChangeBgY\n" + "\tldr r0, =gUnknown_08618110\n" + "\tbl InitWindows\n" + "\tbl DeactivateAllTextPrinters\n" + "\tldr r0, =gUnknown_08618138\n" + "\tstr r0, [r4]\n" + "\tldr r0, =0x050001e0\n" + "\tstr r0, [r4, 0x4]\n" + "\tldr r0, =0x84000008\n" + "\tstr r0, [r4, 0x8]\n" + "\tldr r0, [r4, 0x8]\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0x40\n" + "\tbl SetGpuReg\n" + "\tmovs r0, 0x2\n" + "\tmovs r1, 0\n" + "\tbl FillWindowPixelBuffer\n" + "\tmovs r0, 0x3\n" + "\tmovs r1, 0\n" + "\tbl FillWindowPixelBuffer\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0xAA\n" + "\tbl FillWindowPixelBuffer\n" + "\tldr r5, =gUnknown_08617E9B\n" + "\tmovs r0, 0\n" + "\tadds r1, r5, 0\n" + "\tmovs r2, 0\n" + "\tbl GetStringWidth\n" + "\tadds r1, r0, 0\n" + "\tmovs r4, 0x78\n" + "\tsubs r0, r4, r1\n" + "\tlsrs r1, r0, 31\n" + "\tadds r0, r1\n" + "\tasrs r0, 1\n" + "\tlsls r2, r0, 24\n" + "\tlsrs r2, 24\n" + "\tldr r6, =gUnknown_0861815B\n" + "\tstr r6, [sp]\n" + "\tmovs r0, 0x1\n" + "\tnegs r0, r0\n" + "\tmov r8, r0\n" + "\tstr r0, [sp, 0x4]\n" + "\tstr r5, [sp, 0x8]\n" + "\tmovs r0, 0x2\n" + "\tmovs r1, 0\n" + "\tmovs r3, 0x3\n" + "\tbl box_print\n" + "\tldr r5, =gUnknown_08617E8D\n" + "\tmovs r0, 0\n" + "\tadds r1, r5, 0\n" + "\tmovs r2, 0\n" + "\tbl GetStringWidth\n" + "\tadds r1, r0, 0\n" + "\tsubs r4, r1\n" + "\tlsrs r0, r4, 31\n" + "\tadds r4, r0\n" + "\tasrs r4, 1\n" + "\tadds r0, r4, 0\n" + "\tadds r0, 0x78\n" + "\tlsls r2, r0, 24\n" + "\tlsrs r2, 24\n" + "\tstr r6, [sp]\n" + "\tmov r0, r8\n" + "\tstr r0, [sp, 0x4]\n" + "\tstr r5, [sp, 0x8]\n" + "\tmovs r0, 0x2\n" + "\tmovs r1, 0\n" + "\tmovs r3, 0x3\n" + "\tbl box_print\n" + "\tmovs r0, 0\n" + "\tadds r1, r5, 0\n" + "\tmovs r2, 0\n" + "\tbl GetStringWidth\n" + "\tadds r1, r0, 0\n" + "\tmovs r0, 0x70\n" + "\tsubs r0, r1\n" + "\tlsrs r1, r0, 31\n" + "\tadds r0, r1\n" + "\tasrs r0, 1\n" + "\tlsls r2, r0, 24\n" + "\tlsrs r2, 24\n" + "\tstr r6, [sp]\n" + "\tmov r0, r8\n" + "\tstr r0, [sp, 0x4]\n" + "\tstr r5, [sp, 0x8]\n" + "\tmovs r0, 0x3\n" + "\tmovs r1, 0\n" + "\tmovs r3, 0\n" + "\tbl box_print\n" + "\tldr r4, =gUnknown_08617E78\n" + "\tmovs r0, 0x1\n" + "\tadds r1, r4, 0\n" + "\tmovs r2, 0\n" + "\tbl GetStringWidth\n" + "\tadds r1, r0, 0\n" + "\tmovs r0, 0xD0\n" + "\tsubs r0, r1\n" + "\tlsrs r1, r0, 31\n" + "\tadds r0, r1\n" + "\tasrs r0, 1\n" + "\tlsls r2, r0, 24\n" + "\tlsrs r2, 24\n" + "\tldr r0, =gUnknown_08618158\n" + "\tstr r0, [sp]\n" + "\tmov r0, r8\n" + "\tstr r0, [sp, 0x4]\n" + "\tstr r4, [sp, 0x8]\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0x1\n" + "\tmovs r3, 0x2\n" + "\tbl box_print\n" + "\tmovs r0, 0x2\n" + "\tmovs r1, 0x2\n" + "\tbl CopyWindowToVram\n" + "\tmovs r0, 0x3\n" + "\tmovs r1, 0x2\n" + "\tbl CopyWindowToVram\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0x2\n" + "\tbl CopyWindowToVram\n" + "\tadd sp, 0x10\n" + "\tpop {r3}\n" + "\tmov r8, r3\n" + "\tpop {r4-r6}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.pool\n" + ".syntax divided"); +} +#endif + +static int berry_fix_text_update(int checkval) +{ + if (berry_fix_mb_manager->unk1 == checkval) + { + return checkval; + } + if (berry_fix_mb_manager->unk1 == 6) + { + berry_fix_text_print(checkval); + berry_fix_mb_manager->unk1 = checkval; + } + else + { + berry_fix_bg_hide(); + berry_fix_mb_manager->unk1 = 6; + } + return berry_fix_mb_manager->unk1; +} + +static void berry_fix_text_print(int scene) +{ + FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 32, 32); + FillWindowPixelBuffer(1, 0xAA); + box_print(1, 1, 0, 0, gUnknown_08618158, -1, gUnknown_08618160[scene]); + PutWindowTilemap(1); + CopyWindowToVram(1, 2); + switch (scene) + { + case 0: + case 2: + case 3: + case 4: + PutWindowTilemap(2); + break; + case 1: + PutWindowTilemap(3); + break; + case 5: + PutWindowTilemap(0); + break; + } + CopyBgTilemapBufferToVram(0); + LZ77UnCompVram(gUnknown_08618178[scene][0], (void *)BG_CHAR_ADDR(1)); + LZ77UnCompVram(gUnknown_08618178[scene][1], (void *)BG_SCREEN_ADDR(31)); + CpuCopy32(gUnknown_08618178[scene][2], (void *)BG_PLTT, 0x100); + ShowBg(0); + ShowBg(1); +} + +static void berry_fix_bg_hide() +{ + HideBg(0); + HideBg(1); +} diff --git a/src/egg_hatch.c b/src/egg_hatch.c index a84e71856..6d14e92f0 100644 --- a/src/egg_hatch.c +++ b/src/egg_hatch.c @@ -52,8 +52,8 @@ extern const u8 gUnknown_08C004E0[]; extern const u16 gUnknown_08DD7300[]; // palette, gameboy advance extern const u32 gUnknown_08DD7360[]; // tileset gameboy advance extern const u32 gUnknown_08331F60[]; // tilemap gameboy circle -extern const u8 gOtherText_HatchedFromEgg[]; -extern const u8 gOtherText_NickHatchPrompt[]; +extern const u8 gText_HatchedFromEgg[]; +extern const u8 gText_NickHatchPrompt[]; extern u8* GetMonNick(struct Pokemon* mon, u8* dst); extern u8* GetBoxMonNick(struct BoxPokemon* boxMon, u8* dst); @@ -640,7 +640,7 @@ static void CB2_EggHatch_1(void) break; case 5: GetMonNick(&gPlayerParty[sEggHatchData->eggPartyID], gStringVar1); - StringExpandPlaceholders(gStringVar4, gOtherText_HatchedFromEgg); + StringExpandPlaceholders(gStringVar4, gText_HatchedFromEgg); EggHatchPrintMessage(sEggHatchData->windowId, gStringVar4, 0, 3, 0xFF); PlayFanfare(371); sEggHatchData->CB2_state++; @@ -657,7 +657,7 @@ static void CB2_EggHatch_1(void) break; case 8: GetMonNick(&gPlayerParty[sEggHatchData->eggPartyID], gStringVar1); - StringExpandPlaceholders(gStringVar4, gOtherText_NickHatchPrompt); + StringExpandPlaceholders(gStringVar4, gText_NickHatchPrompt); EggHatchPrintMessage(sEggHatchData->windowId, gStringVar4, 0, 2, 1); sEggHatchData->CB2_state++; break; diff --git a/src/field_map_obj.c b/src/field_map_obj.c new file mode 100755 index 000000000..26bc513fb --- /dev/null +++ b/src/field_map_obj.c @@ -0,0 +1,5118 @@ +// Includes + +#include "global.h" +#include "malloc.h" +#include "sprite.h" +#include "rom4.h" +#include "rng.h" +#include "event_scripts.h" +#include "berry.h" +#include "palette.h" +#include "field_player_avatar.h" +#include "fieldmap.h" +#include "event_data.h" +#include "rom_818CFC8.h" +#include "rom_81BE66C.h" +#include "field_ground_effect.h" +#include "map_obj_8097404.h" +#include "mauville_old_man.h" +#include "metatile_behavior.h" +#include "field_effect.h" +#include "field_effect_helpers.h" +#include "field_camera.h" +#include "trainer_see.h" +#include "field_map_obj.h" + +#define NUM_FIELD_MAP_OBJECT_TEMPLATES 0x51 + +#define null_object_step(name, retval) \ +bool8 FieldObjectCB2_##name(struct MapObject *, struct Sprite *);\ +void FieldObjectCB_##name(struct Sprite *sprite)\ +{\ + FieldObjectStep(&gMapObjects[sprite->data0], sprite, FieldObjectCB2_##name);\ +}\ +bool8 FieldObjectCB2_##name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + return (retval);\ +} + +#define field_object_step(name, table) \ +extern bool8 (*const (table)[])(struct MapObject *, struct Sprite *);\ +bool8 FieldObjectCB2_##name(struct MapObject *, struct Sprite *);\ +void FieldObjectCB_##name(struct Sprite *sprite)\ +{\ + FieldObjectStep(&gMapObjects[sprite->data0], sprite, FieldObjectCB2_##name);\ +}\ +bool8 FieldObjectCB2_##name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + return (table)[sprite->data1](mapObject, sprite);\ +} + +#define field_object_path(idx, table, sub, path, catch, coord)\ +field_object_step(GoInDirectionSequence##idx, table)\ +extern const u8 path[4];\ +bool8 sub(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + u8 route[sizeof(path)];\ + memcpy(route, path, sizeof(path));\ + if (mapObject->mapobj_unk_21 == (catch) && mapObject->coords1.coord == mapObject->coords2.coord)\ + {\ + mapObject->mapobj_unk_21 = (catch) + 1;\ + }\ + return MoveFieldObjectInNextDirectionInSequence(mapObject, sprite, route);\ +}\ + +// Static struct declarations + +// Static RAM declarations + +extern u8 gUnknown_020375B4; +extern u16 gUnknown_020375B6; + +// Static ROM declarations + +static void sub_808D450(void); +static u8 GetFieldObjectIdByLocalId(u8); +static u8 GetFieldObjectIdByLocalIdAndMapInternal(u8, u8, u8); +static bool8 GetAvailableFieldObjectSlot(u16, u8, u8, u8 *); +static void FieldObjectHandleDynamicGraphicsId(struct MapObject *); +static void RemoveFieldObjectInternal (struct MapObject *); +/*static*/ u16 GetFieldObjectFlagIdByFieldObjectId(u8); +void sub_8096518(struct MapObject *, struct Sprite *); +static void MakeObjectTemplateFromFieldObjectTemplate(struct MapObjectTemplate *, struct SpriteTemplate *, const struct SubspriteTable **); +/*static*/ void GetFieldObjectMovingCameraOffset(s16 *, s16 *); +/*static*/ struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8, u8, u8); +static void sub_808E894(u16); +static void RemoveFieldObjectIfOutsideView(struct MapObject *); +static void sub_808E1B8(u8, s16, s16); +static void SetPlayerAvatarFieldObjectIdAndObjectId(u8, u8); +/*static*/ void sub_808E38C(struct MapObject *); +static u8 sub_808E8F4(const struct SpritePalette *); +static u8 FindFieldObjectPaletteIndexByTag(u16); +static void sub_808EAB0(u16, u8); +static bool8 FieldObjectDoesZCoordMatch(struct MapObject *, u8); +//static void CameraObject_0(struct Sprite *); +/*static*/ void CameraObject_1(struct Sprite *); +//static void CameraObject_2(struct Sprite *); +/*static*/ struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 localId, struct MapObjectTemplate *templates, u8 count); +void npc_reset(struct MapObject *, struct Sprite *); +void FieldObjectSetRegularAnim(struct MapObject *, struct Sprite *, u8); + +u8 GetFaceDirectionAnimId(u32); +u8 GetGoSpeed0AnimId(u32); +u8 GetGoSpeed1AnimId(u32); +u8 GetGoSpeed3AnimId(u32); +u8 sub_8093438(u32); +u8 sub_80934BC(u32); +u8 sub_8093514(u32); +u8 GetJumpLedgeAnimId(u32); +void sub_8092F88(u32, s16 *, s16 *, s16, s16); + +bool8 FieldObjectExecRegularAnim(struct MapObject *, struct Sprite *); +void SetFieldObjectStepTimer(struct Sprite *, s16); +bool8 RunFieldObjectStepTimer(struct Sprite *); +bool8 npc_block_way__next_tile(struct MapObject *, u8); +static u32 state_to_direction(u8, u32, u32); +/*static*/ void sub_80964E8(struct MapObject *, struct Sprite *); +static void FieldObjectExecSpecialAnim(struct MapObject *, struct Sprite *); +/*static*/ void npc_obj_transfer_image_anim_pause_flag(struct MapObject *, struct Sprite *); + +static bool8 IsCoordOutsideFieldObjectMovementRect(struct MapObject *, s16, s16); +static bool8 IsMetatileDirectionallyImpassable(struct MapObject *, s16, s16, u8); +static bool8 CheckForCollisionBetweenFieldObjects(struct MapObject *, s16, s16); +bool8 sub_809558C(struct MapObject *, struct Sprite *); +bool8 sub_8095B64(struct MapObject *, struct Sprite *); +static void sub_8096530(struct MapObject *, struct Sprite *); +static void npc_update_obj_anim_flag(struct MapObject *, struct Sprite *); + +// ROM data + +extern void (*const gUnknown_08505438[NUM_FIELD_MAP_OBJECT_TEMPLATES])(struct Sprite *); +extern const u8 gUnknown_0850557C[NUM_FIELD_MAP_OBJECT_TEMPLATES]; +extern const u8 gUnknown_085055CD[NUM_FIELD_MAP_OBJECT_TEMPLATES]; +extern const struct MapObjectGraphicsInfo *const gMauvilleOldManGraphicsInfoPointers[7]; +extern const struct MapObjectGraphicsInfo *const gFieldObjectGraphicsInfoPointers[0xEF]; +extern u8 (*const gUnknown_0850D714[11])(s16, s16, s16, s16); + +struct PairedPalettes { + u16 tag; + const u16 *data; +}; + +extern const u8 gUnknown_084975C4[0x10]; +extern const struct SpriteTemplate gUnknown_084975D4; +extern void (*const gUnknown_084975EC[3])(struct Sprite *); +extern const struct SpritePalette gUnknown_0850BBC8[39]; +extern const struct PairedPalettes gUnknown_0850BD00[4]; +extern const struct PairedPalettes gUnknown_0850BD78[14]; +extern const u16 *const gUnknown_0850BE38[2]; +extern const s16 gUnknown_0850D6DC[4]; // {0x20, 0x40, 0x60, 0x80} +extern const s16 gUnknown_0850D6EC[4]; +extern const u8 gUnknown_0850D710[4]; // {DIR_SOUTH, DIR_NORTH, DIR_WEST, DIR_EAST} +extern const u8 gUnknown_0850D770[2]; // {DIR_SOUTH, DIR_NORTH} +extern const u8 gUnknown_0850D790[2]; // {DIR_WEST, DIR_EAST} +extern const u8 gUnknown_0850D7F0[2]; // {DIR_NORTH, DIR_WEST} +extern const u8 gUnknown_0850D808[2]; // {DIR_NORTH, DIR_EAST} +extern const u8 gUnknown_0850D820[2]; // {DIR_SOUTH, DIR_WEST} +extern const u8 gUnknown_0850D838[2]; // {DIR_SOUTH, DIR_EAST} +extern const u8 gUnknown_0850D850[4]; +extern const u8 gUnknown_0850D868[4]; +extern const u8 gUnknown_0850D880[4]; +extern const u8 gUnknown_0850D898[4]; +extern const u8 gUnknown_0850D8AC[5]; +extern const u8 gUnknown_0850D8C4[5]; +extern const u8 gUnknown_0850D8E8[4]; +extern bool8 (*const gUnknown_0850DA64[11])(struct MapObject *, struct Sprite *, u8, bool8(u8)); +extern bool8 (*const gUnknown_0850DB5C[4])(u8); +extern bool8 (*const gUnknown_0850DB6C[4])(u8); +extern const struct Coords16 gUnknown_0850DB7C[4]; +extern const u8 gUnknown_0850DC2F[4][4]; +extern const u8 gUnknown_0850DC3F[4][4]; +extern const u8 gUnknown_0850DBA0[5]; +extern bool8 (*const *const gUnknown_0850DC50[166])(struct MapObject *, struct Sprite *); +extern u8 (*const gUnknown_0850DEE8[5])(u8); +extern const s16 gUnknown_0850DFBC[3]; +extern const s16 gUnknown_0850DFC2[3]; + +// Code + +static void npc_clear_ids_and_state(struct MapObject *mapObject) +{ + *mapObject = (struct MapObject){}; + mapObject->localId = 0xFF; + mapObject->mapNum = -1; + mapObject->mapGroup = -1; + mapObject->mapobj_unk_1C = -1; +} + +static void npcs_clear_ids_and_state(void) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + npc_clear_ids_and_state(&gMapObjects[i]); + } +} + +void sub_808D438(void) +{ + strange_npc_table_clear(); + npcs_clear_ids_and_state(); + ClearPlayerAvatarInfo(); + sub_808D450(); +} + +static void sub_808D450(void) +{ + u8 spriteIdx; + + spriteIdx = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[21], 0, 0, 31); + gSprites[spriteIdx].oam.affineMode = 1; + InitSpriteAffineAnim(&gSprites[spriteIdx]); + StartSpriteAffineAnim(&gSprites[spriteIdx], 0); + gSprites[spriteIdx].invisible = TRUE; + + spriteIdx = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[21], 0, 0, 31); + gSprites[spriteIdx].oam.affineMode = 1; + InitSpriteAffineAnim(&gSprites[spriteIdx]); + StartSpriteAffineAnim(&gSprites[spriteIdx], 1); + gSprites[spriteIdx].invisible = TRUE; +} + +u8 sub_808D4F4(void) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (!gMapObjects[i].active) + { + break; + } + } + return i; +} + +u8 GetFieldObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId) +{ + if (localId < 0xff) + { + return GetFieldObjectIdByLocalIdAndMapInternal(localId, mapId, mapGroupId); + } + return GetFieldObjectIdByLocalId(localId); +} + +bool8 TryGetFieldObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId, u8 *fieldObjectId) +{ + *fieldObjectId = GetFieldObjectIdByLocalIdAndMap(localId, mapId, mapGroupId); + if (*fieldObjectId == NUM_FIELD_OBJECTS) + { + return TRUE; + } + return FALSE; +} + +u8 GetFieldObjectIdByXY(s16 x, s16 y) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active && gMapObjects[i].coords2.x == x && gMapObjects[i].coords2.y == y) + { + break; + } + } + return i; +} + +static u8 GetFieldObjectIdByLocalIdAndMapInternal(u8 localId, u8 mapId, u8 mapGroupId) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active && gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapId && gMapObjects[i].mapGroup == mapGroupId) + { + return i; + } + } + return NUM_FIELD_OBJECTS; +} + +static u8 GetFieldObjectIdByLocalId(u8 localId) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active && gMapObjects[i].localId == localId) + { + return i; + } + } + return NUM_FIELD_OBJECTS; +} + +// This function has the same nonmatching quirk as in Ruby/Sapphire. +#ifdef NONMATCHING +static u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *template, u8 mapNum, u8 mapGroup) +{ + struct MapObject *mapObject; + s16 x; + s16 y; + u8 slot; + + // mapNum and mapGroup are in the wrong registers (r7/r6 instead of r6/r7) + if (GetAvailableFieldObjectSlot(template->localId, mapNum, mapGroup, &slot)) + { + return NUM_FIELD_OBJECTS; + } + mapObject = &gMapObjects[slot]; + npc_clear_ids_and_state(mapObject); + x = template->x + 7; + y = template->y + 7; + mapObject->active = TRUE; + mapObject->mapobj_bit_2 = TRUE; + mapObject->graphicsId = template->graphicsId; + mapObject->animPattern = template->movementType; + mapObject->localId = template->localId; + mapObject->mapNum = mapNum; + mapObject->mapGroup = mapGroup; + mapObject->coords1.x = x; + mapObject->coords1.y = y; + mapObject->coords2.x = x; + mapObject->coords2.y = y; + mapObject->coords3.x = x; + mapObject->coords3.y = y; + mapObject->mapobj_unk_0B_0 = template->elevation; + mapObject->elevation = template->elevation; + // For some reason, 0x0F is placed in r9, to be used later + mapObject->range.as_nybbles.x = template->unkA_0; + mapObject->range.as_nybbles.y = template->unkA_4; + mapObject->trainerType = template->unkC; + mapObject->trainerRange_berryTreeId = template->unkE; + mapObject->mapobj_unk_20 = gUnknown_085055CD[template->movementType]; + FieldObjectSetDirection(mapObject, mapObject->mapobj_unk_20); + FieldObjectHandleDynamicGraphicsId(mapObject); + + if (gUnknown_0850557C[mapObject->animPattern]) + { + if ((mapObject->range.as_nybbles.x) == 0) + { + // r9 is invoked here + mapObject->range.as_nybbles.x ++; + } + if ((mapObject->range.as_nybbles.y) == 0) + { + mapObject->range.as_nybbles.y ++; + } + } + return slot; +} +#else +static __attribute__((naked)) u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *template, u8 mapId, u8 mapGroupId) +{ + asm_unified("\tpush {r4-r7,lr}\n" + "\tmov r7, r9\n" + "\tmov r6, r8\n" + "\tpush {r6,r7}\n" + "\tsub sp, 0x4\n" + "\tadds r5, r0, 0\n" + "\tlsls r1, 24\n" + "\tlsrs r6, r1, 24\n" + "\tlsls r2, 24\n" + "\tlsrs r7, r2, 24\n" + "\tldrb r0, [r5]\n" + "\tadds r1, r6, 0\n" + "\tadds r2, r7, 0\n" + "\tmov r3, sp\n" + "\tbl GetAvailableFieldObjectSlot\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbeq _0808D66E\n" + "\tmovs r0, 0x10\n" + "\tb _0808D762\n" + "_0808D66E:\n" + "\tmov r0, sp\n" + "\tldrb r1, [r0]\n" + "\tlsls r0, r1, 3\n" + "\tadds r0, r1\n" + "\tlsls r0, 2\n" + "\tldr r1, =gMapObjects\n" + "\tadds r4, r0, r1\n" + "\tadds r0, r4, 0\n" + "\tbl npc_clear_ids_and_state\n" + "\tldrh r3, [r5, 0x4]\n" + "\tadds r3, 0x7\n" + "\tlsls r3, 16\n" + "\tlsrs r3, 16\n" + "\tldrh r2, [r5, 0x6]\n" + "\tadds r2, 0x7\n" + "\tlsls r2, 16\n" + "\tlsrs r2, 16\n" + "\tldrb r0, [r4]\n" + "\tmovs r1, 0x1\n" + "\torrs r0, r1\n" + "\tmovs r1, 0x4\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4]\n" + "\tldrb r0, [r5, 0x1]\n" + "\tstrb r0, [r4, 0x5]\n" + "\tldrb r0, [r5, 0x9]\n" + "\tstrb r0, [r4, 0x6]\n" + "\tldrb r0, [r5]\n" + "\tstrb r0, [r4, 0x8]\n" + "\tstrb r6, [r4, 0x9]\n" + "\tstrb r7, [r4, 0xA]\n" + "\tstrh r3, [r4, 0xC]\n" + "\tstrh r2, [r4, 0xE]\n" + "\tstrh r3, [r4, 0x10]\n" + "\tstrh r2, [r4, 0x12]\n" + "\tstrh r3, [r4, 0x14]\n" + "\tstrh r2, [r4, 0x16]\n" + "\tldrb r0, [r5, 0x8]\n" + "\tmovs r7, 0xF\n" + "\tadds r1, r7, 0\n" + "\tands r1, r0\n" + "\tldrb r2, [r4, 0xB]\n" + "\tmovs r0, 0x10\n" + "\tnegs r0, r0\n" + "\tmov r8, r0\n" + "\tands r0, r2\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4, 0xB]\n" + "\tldrb r1, [r5, 0x8]\n" + "\tlsls r1, 4\n" + "\tands r0, r7\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4, 0xB]\n" + "\tldrb r1, [r5, 0xA]\n" + "\tlsls r1, 28\n" + "\tmovs r0, 0xF\n" + "\tmov r9, r0\n" + "\tlsrs r1, 28\n" + "\tldrb r2, [r4, 0x19]\n" + "\tmov r0, r8\n" + "\tands r0, r2\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4, 0x19]\n" + "\tldrb r1, [r5, 0xA]\n" + "\tlsrs r1, 4\n" + "\tlsls r1, 4\n" + "\tands r0, r7\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4, 0x19]\n" + "\tldrh r0, [r5, 0xC]\n" + "\tstrb r0, [r4, 0x7]\n" + "\tldrh r0, [r5, 0xE]\n" + "\tstrb r0, [r4, 0x1D]\n" + "\tldr r1, =gUnknown_085055CD\n" + "\tldrb r0, [r5, 0x9]\n" + "\tadds r0, r1\n" + "\tldrb r1, [r0]\n" + "\tadds r0, r4, 0\n" + "\tadds r0, 0x20\n" + "\tstrb r1, [r0]\n" + "\tldrb r1, [r0]\n" + "\tadds r0, r4, 0\n" + "\tbl FieldObjectSetDirection\n" + "\tadds r0, r4, 0\n" + "\tbl FieldObjectHandleDynamicGraphicsId\n" + "\tldr r1, =gUnknown_0850557C\n" + "\tldrb r0, [r4, 0x6]\n" + "\tadds r0, r1\n" + "\tldrb r0, [r0]\n" + "\tcmp r0, 0\n" + "\tbeq _0808D75E\n" + "\tldrb r2, [r4, 0x19]\n" + "\tadds r0, r7, 0\n" + "\tands r0, r2\n" + "\tcmp r0, 0\n" + "\tbne _0808D746\n" + "\tlsls r0, r2, 28\n" + "\tlsrs r0, 28\n" + "\tadds r0, 0x1\n" + "\tmov r1, r9\n" + "\tands r0, r1\n" + "\tmov r1, r8\n" + "\tands r1, r2\n" + "\torrs r1, r0\n" + "\tstrb r1, [r4, 0x19]\n" + "_0808D746:\n" + "\tldrb r2, [r4, 0x19]\n" + "\tmovs r0, 0xF0\n" + "\tands r0, r2\n" + "\tcmp r0, 0\n" + "\tbne _0808D75E\n" + "\tlsrs r1, r2, 4\n" + "\tadds r1, 0x1\n" + "\tlsls r1, 4\n" + "\tadds r0, r7, 0\n" + "\tands r0, r2\n" + "\torrs r0, r1\n" + "\tstrb r0, [r4, 0x19]\n" + "_0808D75E:\n" + "\tmov r0, sp\n" + "\tldrb r0, [r0]\n" + "_0808D762:\n" + "\tadd sp, 0x4\n" + "\tpop {r3,r4}\n" + "\tmov r8, r3\n" + "\tmov r9, r4\n" + "\tpop {r4-r7}\n" + "\tpop {r1}\n" + "\tbx r1\n" + ".pool"); +} +#endif + +u8 unref_sub_808D77C(u8 localId) +{ + u8 i; + u8 nObjects; + struct MapObjectTemplate *template; + + if (gMapHeader.events != NULL) + { + if (InBattlePyramid()) + { + nObjects = sub_81AAA40(); + } + else if (InTrainerHill()) + { + nObjects = 2; + } + else + { + nObjects = gMapHeader.events->mapObjectCount; + } + for (i = 0; i < nObjects; i ++) + { + template = &gSaveBlock1Ptr->mapObjectTemplates[i]; + if (template->localId == localId && !FlagGet(template->flagId)) + { + return InitFieldObjectStateFromTemplate(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); + } + } + } + return NUM_FIELD_OBJECTS; +} + +static bool8 GetAvailableFieldObjectSlot(u16 localId, u8 mapNum, u8 mapGroup, u8 *result) +// Looks for an empty slot. +// Returns FALSE and the location of the available slot +// in *result. +// If no slots are available, or if the object is already +// loaded, returns TRUE. +{ + u8 i = 0; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (!gMapObjects[i].active) + break; + if (gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapNum && gMapObjects[i].mapGroup == mapGroup) + return TRUE; + } + if (i >= NUM_FIELD_OBJECTS) + return TRUE; + *result = i; + do + { + if (gMapObjects[i].active && gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapNum && gMapObjects[i].mapGroup == mapGroup) + return TRUE; + i ++; + } while (i < NUM_FIELD_OBJECTS); + return FALSE; +} + +static void RemoveFieldObject(struct MapObject *mapObject) +{ + mapObject->active = FALSE; + RemoveFieldObjectInternal(mapObject); +} + +void RemoveFieldObjectByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 index; + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &index)) + { + FlagSet(GetFieldObjectFlagIdByFieldObjectId(index)); + RemoveFieldObject(&gMapObjects[index]); + } +} + +static void RemoveFieldObjectInternal(struct MapObject *mapObject) +{ + struct SpriteFrameImage image; + image.size = GetFieldObjectGraphicsInfo(mapObject->graphicsId)->size; + gSprites[mapObject->spriteId].images = ℑ + DestroySprite(&gSprites[mapObject->spriteId]); +} + +void unref_sub_808D958(void) +{ + u8 i; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (i != gPlayerAvatar.mapObjectId) + { + RemoveFieldObject(&gMapObjects[i]); + } + } +} + +static u8 SpawnFieldObjectInternal(struct MapObjectTemplate *mapObjectTemplate, struct SpriteTemplate *spriteTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) +{ + struct MapObject *mapObject; + const struct MapObjectGraphicsInfo *graphicsInfo; + struct Sprite *sprite; + u8 mapObjectId; + u8 paletteSlot; + u8 spriteId; + + mapObjectId = InitFieldObjectStateFromTemplate(mapObjectTemplate, mapNum, mapGroup); + if (mapObjectId == NUM_FIELD_OBJECTS) + { + return NUM_FIELD_OBJECTS; + } + mapObject = &gMapObjects[mapObjectId]; + graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + paletteSlot = graphicsInfo->paletteSlot; + if (paletteSlot == 0) + { + npc_load_two_palettes__no_record(graphicsInfo->paletteTag1, 0); + } + else if (paletteSlot == 10) + { + npc_load_two_palettes__and_record(graphicsInfo->paletteTag1, 10); + } + else if (paletteSlot >= 16) + { + paletteSlot -= 16; + sub_808EAB0(graphicsInfo->paletteTag1, paletteSlot); + } + if (mapObject->animPattern == 0x4c) + { + mapObject->mapobj_bit_13 = TRUE; + } + *(u16 *)&spriteTemplate->paletteTag = 0xFFFF; + spriteId = CreateSprite(spriteTemplate, 0, 0, 0); + if (spriteId == MAX_SPRITES) + { + gMapObjects[mapObjectId].active = FALSE; + return NUM_FIELD_OBJECTS; + } + sprite = &gSprites[spriteId]; + sub_8092FF0(mapObject->coords2.x + cameraX, mapObject->coords2.y + cameraY, &sprite->pos1.x, &sprite->pos1.y); + sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); + sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); + sprite->pos1.x += 8; + sprite->pos1.y += 16 + sprite->centerToCornerVecY; + sprite->oam.paletteNum = paletteSlot; + sprite->coordOffsetEnabled = TRUE; + sprite->data0 = mapObjectId; + mapObject->spriteId = spriteId; + mapObject->mapobj_bit_12 = graphicsInfo->inanimate; + if (!mapObject->mapobj_bit_12) + { + StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(mapObject->mapobj_unk_18)); + } + SetObjectSubpriorityByZCoord(mapObject->elevation, sprite, 1); + sub_8096518(mapObject, sprite); + return mapObjectId; +} + +static u8 SpawnFieldObject(struct MapObjectTemplate *mapObjectTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) +{ + const struct MapObjectGraphicsInfo *graphicsInfo; + struct SpriteTemplate spriteTemplate; + const struct SubspriteTable *subspriteTables; + struct SpriteFrameImage spriteFrameImage; + u8 mapObjectId; + + subspriteTables = NULL; + graphicsInfo = GetFieldObjectGraphicsInfo(mapObjectTemplate->graphicsId); + MakeObjectTemplateFromFieldObjectTemplate(mapObjectTemplate, &spriteTemplate, &subspriteTables); + spriteFrameImage.size = graphicsInfo->size; + spriteTemplate.images = &spriteFrameImage; + mapObjectId = SpawnFieldObjectInternal(mapObjectTemplate, &spriteTemplate, mapNum, mapGroup, cameraX, cameraY); + if (mapObjectId == NUM_FIELD_OBJECTS) + { + return NUM_FIELD_OBJECTS; + } + gSprites[gMapObjects[mapObjectId].spriteId].images = graphicsInfo->images; + if (subspriteTables != NULL) + { + SetSubspriteTables(&gSprites[gMapObjects[mapObjectId].spriteId], subspriteTables); + } + return mapObjectId; +} + +u8 SpawnSpecialFieldObject(struct MapObjectTemplate *mapObjectTemplate) +{ + s16 cameraX; + s16 cameraY; + + GetFieldObjectMovingCameraOffset(&cameraX, &cameraY); + return SpawnFieldObject(mapObjectTemplate, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); +} + +u8 SpawnSpecialFieldObjectParametrized(u8 graphicsId, u8 movementBehavior, u8 localId, s16 x, s16 y, u8 z) +{ + struct MapObjectTemplate mapObjectTemplate; + + x -= 7; + y -= 7; + mapObjectTemplate.localId = localId; + mapObjectTemplate.graphicsId = graphicsId; + mapObjectTemplate.unk2 = 0; + mapObjectTemplate.x = x; + mapObjectTemplate.y = y; + mapObjectTemplate.elevation = z; + mapObjectTemplate.movementType = movementBehavior; + mapObjectTemplate.unkA_0 = 0; + mapObjectTemplate.unkA_4 = 0; + mapObjectTemplate.unkC = 0; + mapObjectTemplate.unkE = 0; + return SpawnSpecialFieldObject(&mapObjectTemplate); +} + +u8 show_sprite(u8 localId, u8 mapNum, u8 mapGroup) +{ + struct MapObjectTemplate *mapObjectTemplate; + s16 cameraX; + s16 cameraY; + + mapObjectTemplate = GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup); + if (mapObjectTemplate == NULL) + { + return NUM_FIELD_OBJECTS; + } + GetFieldObjectMovingCameraOffset(&cameraX, &cameraY); + return SpawnFieldObject(mapObjectTemplate, mapNum, mapGroup, cameraX, cameraY); +} + +static void MakeObjectTemplateFromFieldObjectGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) +{ + const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(graphicsId); + + sprTemplate->tileTag = gfxInfo->tileTag; + sprTemplate->paletteTag = gfxInfo->paletteTag1; + sprTemplate->oam = gfxInfo->oam; + sprTemplate->anims = gfxInfo->anims; + sprTemplate->images = gfxInfo->images; + sprTemplate->affineAnims = gfxInfo->affineAnims; + sprTemplate->callback = callback; + *subspriteTables = gfxInfo->subspriteTables; +} + +static void MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(u16 graphicsId, u16 callbackIndex, struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) +{ + MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, gUnknown_08505438[callbackIndex], sprTemplate, subspriteTables); +} + +static void MakeObjectTemplateFromFieldObjectTemplate(struct MapObjectTemplate *mapObjectTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) +{ + MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(mapObjectTemplate->graphicsId, mapObjectTemplate->movementType, spriteTemplate, subspriteTables); +} + +u8 AddPseudoFieldObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) +{ + struct SpriteTemplate *spriteTemplate; + const struct SubspriteTable *subspriteTables; + struct Sprite *sprite; + u8 spriteIdx; + + spriteTemplate = malloc(sizeof(struct SpriteTemplate)); + MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, callback, spriteTemplate, &subspriteTables); + if (spriteTemplate->paletteTag != 0xffff) + { + sub_808E894(spriteTemplate->paletteTag); + } + spriteIdx = CreateSprite(spriteTemplate, x, y, subpriority); + free(spriteTemplate); + + if (spriteIdx != MAX_SPRITES && subspriteTables != NULL) + { + sprite = &gSprites[spriteIdx]; + SetSubspriteTables(sprite, subspriteTables); + sprite->subspriteMode = 2; + } + return spriteIdx; +} + +u8 sprite_new(u8 graphicsId, u8 a1, s16 x, s16 y, u8 z, u8 direction) +{ + const struct MapObjectGraphicsInfo *graphicsInfo; + struct SpriteTemplate spriteTemplate; + const struct SubspriteTable *subspriteTables; + u8 spriteId; + struct Sprite *sprite; + + graphicsInfo = GetFieldObjectGraphicsInfo(graphicsId); + MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, sub_8097AC8, &spriteTemplate, &subspriteTables); + *(u16 *)&spriteTemplate.paletteTag = 0xffff; + x += 7; + y += 7; + sub_80930E0(&x, &y, 8, 16); + spriteId = CreateSpriteAtEnd(&spriteTemplate, x, y, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); + sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); + sprite->pos1.y += sprite->centerToCornerVecY; + sprite->oam.paletteNum = graphicsInfo->paletteSlot; + if (sprite->oam.paletteNum >= 16) + { + sprite->oam.paletteNum -= 16; + } + sprite->coordOffsetEnabled = TRUE; + sprite->data0 = a1; + sprite->data1 = z; + if (graphicsInfo->paletteSlot == 10) + { + npc_load_two_palettes__and_record(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot); + } + else if (graphicsInfo->paletteSlot >= 16) + { + sub_808EAB0(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot | 0xf0); + } + if (subspriteTables != NULL) + { + SetSubspriteTables(sprite, subspriteTables); + sprite->subspriteMode = 2; + } + InitObjectPriorityByZCoord(sprite, z); + SetObjectSubpriorityByZCoord(z, sprite, 1); + StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(direction)); + } + return spriteId; +} + +void SpawnFieldObjectsInView(s16 cameraX, s16 cameraY) +{ + u8 i; + s16 left; + s16 right; + s16 top; + s16 bottom; + u8 objectCount; + s16 npcX; + s16 npcY; + + if (gMapHeader.events != NULL) + { + left = gSaveBlock1Ptr->pos.x - 2; + right = gSaveBlock1Ptr->pos.x + 17; + top = gSaveBlock1Ptr->pos.y; + bottom = gSaveBlock1Ptr->pos.y + 16; + + if (InBattlePyramid()) + { + objectCount = sub_81AAA40(); + } + else if (InTrainerHill()) + { + objectCount = 2; + } + else + { + objectCount = gMapHeader.events->mapObjectCount; + } + + for (i = 0; i < objectCount; i++) + { + struct MapObjectTemplate *template = &gSaveBlock1Ptr->mapObjectTemplates[i]; + npcX = template->x + 7; + npcY = template->y + 7; + + if (top <= npcY && bottom >= npcY && left <= npcX && right >= npcX + && !FlagGet(template->flagId)) + SpawnFieldObject(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); + } + } +} + +/*static*/ void RemoveFieldObjectsOutsideView(void) +{ + u8 i; + u8 j; + bool8 isActiveLinkPlayer; + struct MapObject *mapObject; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + for (j = 0, isActiveLinkPlayer = FALSE; j < ARRAY_COUNT(gLinkPlayerMapObjects); j ++) + { + if (gLinkPlayerMapObjects[j].active && i == gLinkPlayerMapObjects[j].mapObjId) + isActiveLinkPlayer = TRUE; + } + if (!isActiveLinkPlayer) + { + mapObject = &gMapObjects[i]; + + if (mapObject->active && !mapObject->mapobj_bit_16) + RemoveFieldObjectIfOutsideView(mapObject); + } + } +} + +static void RemoveFieldObjectIfOutsideView(struct MapObject *mapObject) +{ + s16 left; + s16 right; + s16 top; + s16 bottom; + + left = gSaveBlock1Ptr->pos.x - 2; + right = gSaveBlock1Ptr->pos.x + 17; + top = gSaveBlock1Ptr->pos.y; + bottom = gSaveBlock1Ptr->pos.y + 16; + + if (mapObject->coords2.x >= left && mapObject->coords2.x <= right + && mapObject->coords2.y >= top && mapObject->coords2.y <= bottom) + return; + if (mapObject->coords1.x >= left && mapObject->coords1.x <= right + && mapObject->coords1.y >= top && mapObject->coords1.y <= bottom) + return; + RemoveFieldObject(mapObject); +} + +void sub_808E16C(s16 x, s16 y) +{ + u8 i; + + ClearPlayerAvatarInfo(); + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active) + { + sub_808E1B8(i, x, y); + } + } + sub_808D450(); +} + +static void sub_808E1B8(u8 mapObjectId, s16 x, s16 y) +{ + u8 spriteId; + u8 paletteSlot; + struct MapObject *mapObject; + const struct SubspriteTable *subspriteTables; + const struct MapObjectGraphicsInfo *graphicsInfo; + struct SpriteFrameImage spriteFrameImage; + struct SpriteTemplate spriteTemplate; + struct Sprite *sprite; + +#define i spriteId + for (i = 0; i < ARRAY_COUNT(gLinkPlayerMapObjects); i ++) + { + if (gLinkPlayerMapObjects[i].active && mapObjectId == gLinkPlayerMapObjects[i].mapObjId) + { + return; + } + } +#undef i + + mapObject = &gMapObjects[mapObjectId]; + subspriteTables = NULL; + graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + spriteFrameImage.size = graphicsInfo->size; + MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(mapObject->graphicsId, mapObject->animPattern, &spriteTemplate, &subspriteTables); + spriteTemplate.images = &spriteFrameImage; + *(u16 *)&spriteTemplate.paletteTag = 0xffff; + paletteSlot = graphicsInfo->paletteSlot; + if (paletteSlot == 0) + { + npc_load_two_palettes__no_record(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot); + } + else if (paletteSlot == 10) + { + npc_load_two_palettes__and_record(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot); + } + else if (paletteSlot >= 16) + { + paletteSlot -= 16; + sub_808EAB0(graphicsInfo->paletteTag1, paletteSlot); + } + *(u16 *)&spriteTemplate.paletteTag = 0xffff; + spriteId = CreateSprite(&spriteTemplate, 0, 0, 0); + if (spriteId != MAX_SPRITES) + { + sprite = &gSprites[spriteId]; + sub_8092FF0(x + mapObject->coords2.x, y + mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y); + sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); + sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); + sprite->pos1.x += 8; + sprite->pos1.y += 16 + sprite->centerToCornerVecY; + sprite->images = graphicsInfo->images; + if (mapObject->animPattern == 0x0b) + { + SetPlayerAvatarFieldObjectIdAndObjectId(mapObjectId, spriteId); + mapObject->mapobj_unk_1B = sub_8154228(); + } + if (subspriteTables != NULL) + { + SetSubspriteTables(sprite, subspriteTables); + } + sprite->oam.paletteNum = paletteSlot; + sprite->coordOffsetEnabled = TRUE; + sprite->data0 = mapObjectId; + mapObject->spriteId = spriteId; + if (!mapObject->mapobj_bit_12 && mapObject->animPattern != 0x0b) + { + StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(mapObject->mapobj_unk_18)); + } + sub_808E38C(mapObject); + SetObjectSubpriorityByZCoord(mapObject->elevation, sprite, 1); + } +} + +/*static*/ void sub_808E38C(struct MapObject *mapObject) +{ + mapObject->mapobj_bit_1 = FALSE; + mapObject->mapobj_bit_2 = TRUE; + mapObject->mapobj_bit_22 = FALSE; + mapObject->mapobj_bit_17 = FALSE; + mapObject->mapobj_bit_18 = FALSE; + mapObject->mapobj_bit_19 = FALSE; + mapObject->mapobj_bit_20 = FALSE; + mapObject->mapobj_bit_21 = FALSE; + FieldObjectClearAnim(mapObject); +} + +static void SetPlayerAvatarFieldObjectIdAndObjectId(u8 mapObjectId, u8 spriteId) +{ + gPlayerAvatar.mapObjectId = mapObjectId; + gPlayerAvatar.spriteId = spriteId; + gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gMapObjects[mapObjectId].graphicsId); + SetPlayerAvatarExtraStateTransition(gMapObjects[mapObjectId].graphicsId, 0x20); +} + +void FieldObjectSetGraphicsId(struct MapObject *mapObject, u8 graphicsId) +{ + const struct MapObjectGraphicsInfo *graphicsInfo; + struct Sprite *sprite; + u8 paletteSlot; + + graphicsInfo = GetFieldObjectGraphicsInfo(graphicsId); + sprite = &gSprites[mapObject->spriteId]; + paletteSlot = graphicsInfo->paletteSlot; + if (paletteSlot == 0) + { + pal_patch_for_npc(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot); + } + else if (paletteSlot == 10) + { + npc_load_two_palettes__and_record(graphicsInfo->paletteTag1, graphicsInfo->paletteSlot); + } + else if (paletteSlot >= 16) + { + paletteSlot -= 16; + sub_808EAB0(graphicsInfo->paletteTag1, paletteSlot); + } + sprite->oam.shape = graphicsInfo->oam->shape; + sprite->oam.size = graphicsInfo->oam->size; + sprite->images = graphicsInfo->images; + sprite->anims = graphicsInfo->anims; + sprite->subspriteTables = graphicsInfo->subspriteTables; + sprite->oam.paletteNum = paletteSlot; + mapObject->mapobj_bit_12 = graphicsInfo->inanimate; + mapObject->graphicsId = graphicsId; + sub_8093038(mapObject->coords2.x, mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y); + sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); + sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); + sprite->pos1.x += 8; + sprite->pos1.y += 16 + sprite->centerToCornerVecY; + if (mapObject->mapobj_bit_15) + { + CameraObjectReset1(); + } +} + +void FieldObjectSetGraphicsIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + FieldObjectSetGraphicsId(&gMapObjects[mapObjectId], graphicsId); + } +} + +void FieldObjectTurn(struct MapObject *mapObject, u8 direction) +{ + FieldObjectSetDirection(mapObject, direction); + if (!mapObject->mapobj_bit_12) + { + StartSpriteAnim(&gSprites[mapObject->spriteId], FieldObjectDirectionToImageAnimId(mapObject->mapobj_unk_18)); + SeekSpriteAnim(&gSprites[mapObject->spriteId], 0); + } +} + +void FieldObjectTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + FieldObjectTurn(&gMapObjects[mapObjectId], direction); + } +} + +void PlayerObjectTurn(struct PlayerAvatar *playerAvatar, u8 direction) +{ + FieldObjectTurn(&gMapObjects[playerAvatar->mapObjectId], direction); +} + +/*static*/ void get_berry_tree_graphics(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 berryStage; + u8 berryId; + + mapObject->mapobj_bit_13 = TRUE; + sprite->invisible = TRUE; + berryStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId); + if (berryStage != 0) + { + mapObject->mapobj_bit_13 = FALSE; + sprite->invisible = FALSE; + berryId = GetBerryTypeByBerryTreeId(mapObject->trainerRange_berryTreeId) - 1; + berryStage -= 1; + if (berryId >= NUM_BERRIES) + { + berryId = 0; + } + FieldObjectSetGraphicsId(mapObject, gBerryTreeFieldObjectGraphicsIdTablePointers[berryId][berryStage]); + sprite->images = gBerryTreePicTablePointers[berryId]; + sprite->oam.paletteNum = gBerryTreePaletteSlotTablePointers[berryId][berryStage]; + StartSpriteAnim(sprite, berryStage); + } +} + +const struct MapObjectGraphicsInfo *GetFieldObjectGraphicsInfo(u8 graphicsId) +{ + u8 bard; + + if (graphicsId >= SPRITE_VAR) + { + graphicsId = VarGetFieldObjectGraphicsId(graphicsId - SPRITE_VAR); + } + if (graphicsId == 0x45) + { + bard = sub_81201C8(); + return gMauvilleOldManGraphicsInfoPointers[bard]; + } + if (graphicsId >= NUM_OBJECT_GRAPHICS_INFO) + { + graphicsId = 0x05; // LittleBoy1 + } + return gFieldObjectGraphicsInfoPointers[graphicsId]; +} + +static void FieldObjectHandleDynamicGraphicsId(struct MapObject *mapObject) +{ + if (mapObject->graphicsId >= SPRITE_VAR) + { + mapObject->graphicsId = VarGetFieldObjectGraphicsId(mapObject->graphicsId - SPRITE_VAR); + } +} + +void npc_by_local_id_and_map_set_field_1_bit_x20(u8 localId, u8 mapNum, u8 mapGroup, u8 state) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + gMapObjects[mapObjectId].mapobj_bit_13 = state; + } +} + +void FieldObjectGetLocalIdAndMap(struct MapObject *mapObject, u8 *localId, u8 *mapNum, u8 *mapGroup) +{ + *localId = mapObject->localId; + *mapNum = mapObject->mapNum; + *mapGroup = mapObject->mapGroup; +} + +void sub_808E75C(s16 x, s16 y) +{ + u8 mapObjectId; + struct MapObject *mapObject; + + mapObjectId = GetFieldObjectIdByXY(x, y); + if (mapObjectId != NUM_FIELD_OBJECTS) + { + mapObject = &gMapObjects[mapObjectId]; + mapObject->mapobj_bit_2 = TRUE; + } +} + +void sub_808E78C(u8 localId, u8 mapNum, u8 mapGroup, u8 subpriority) +{ + u8 mapObjectId; + struct MapObject *mapObject; + struct Sprite *sprite; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + mapObject = &gMapObjects[mapObjectId]; + sprite = &gSprites[mapObject->spriteId]; + mapObject->mapobj_bit_26 = TRUE; + sprite->subpriority = subpriority; + } +} + +void sub_808E7E4(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + struct MapObject *mapObject; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + mapObject = &gMapObjects[mapObjectId]; + mapObject->mapobj_bit_26 = FALSE; + mapObject->mapobj_bit_2 = TRUE; + } +} + +void sub_808E82C(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) +{ + u8 mapObjectId; + struct Sprite *sprite; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + sprite = &gSprites[gMapObjects[mapObjectId].spriteId]; + sprite->pos2.x = x; + sprite->pos2.y = y; + } +} + +void gpu_pal_allocator_reset__manage_upper_four(void) +{ + FreeAllSpritePalettes(); + gReservedSpritePaletteCount = 12; +} + +static void sub_808E894(u16 paletteTag) +{ + u16 paletteSlot; + + paletteSlot = FindFieldObjectPaletteIndexByTag(paletteTag); + if (paletteSlot != 0x11ff) // always true + { + sub_808E8F4(&gUnknown_0850BBC8[paletteSlot]); + } +} + +void sub_808E8C0(u16 *paletteTags) +{ + u8 i; + + for (i = 0; paletteTags[i] != 0x11ff; i ++) + { + sub_808E894(paletteTags[i]); + } +} + +static u8 sub_808E8F4(const struct SpritePalette *spritePalette) +{ + if (IndexOfSpritePaletteTag(spritePalette->tag) != 0xff) + { + return 0xff; + } + return LoadSpritePalette(spritePalette); +} + +void pal_patch_for_npc(u16 paletteTag, u8 paletteSlot) +{ + u16 paletteIdx; + + paletteIdx = FindFieldObjectPaletteIndexByTag(paletteTag); + LoadPalette(gUnknown_0850BBC8[paletteIdx].data, 16 * paletteSlot + 256, 0x20); +} + +void pal_patch_for_npc_range(const u16 *paletteTags, u8 minSlot, u8 maxSlot) +{ + while (minSlot < maxSlot) + { + pal_patch_for_npc(*paletteTags, minSlot); + paletteTags ++; + minSlot ++; + } +} + +static u8 FindFieldObjectPaletteIndexByTag(u16 tag) +{ + u8 i; + + for (i = 0; gUnknown_0850BBC8[i].tag != 0x11ff; i ++) + { + if (gUnknown_0850BBC8[i].tag == tag) + { + return i; + } + } + return 0xff; +} + +void npc_load_two_palettes__no_record(u16 tag, u8 slot) +{ + u8 i; + + pal_patch_for_npc(tag, slot); + for (i = 0; gUnknown_0850BD00[i].tag != 0x11ff; i ++) + { + if (gUnknown_0850BD00[i].tag == tag) + { + pal_patch_for_npc(gUnknown_0850BD00[i].data[gUnknown_020375B4], gUnknown_084975C4[slot]); + return; + } + } +} + +void npc_load_two_palettes__and_record(u16 tag, u8 slot) +{ + u8 i; + + gUnknown_020375B6 = tag; + pal_patch_for_npc(tag, slot); + for (i = 0; gUnknown_0850BD78[i].tag != 0x11ff; i ++) + { + if (gUnknown_0850BD78[i].tag == tag) + { + pal_patch_for_npc(gUnknown_0850BD78[i].data[gUnknown_020375B4], gUnknown_084975C4[slot]); + return; + } + } +} + +static void sub_808EAB0(u16 tag, u8 slot) +{ + pal_patch_for_npc(tag, slot); +} + +void unref_sub_808EAC4(struct MapObject *mapObject, s16 x, s16 y) +{ + mapObject->coords3.x = mapObject->coords2.x; + mapObject->coords3.y = mapObject->coords2.y; + mapObject->coords2.x += x; + mapObject->coords2.y += y; +} + +void npc_coords_shift(struct MapObject *mapObject, s16 x, s16 y) +{ + mapObject->coords3.x = mapObject->coords2.x; + mapObject->coords3.y = mapObject->coords2.y; + mapObject->coords2.x = x; + mapObject->coords2.y = y; +} + +/*static*/ void npc_coords_set(struct MapObject *mapObject, s16 x, s16 y) +{ + mapObject->coords3.x = x; + mapObject->coords3.y = y; + mapObject->coords2.x = x; + mapObject->coords2.y = y; +} + +void sub_808EB08(struct MapObject *mapObject, s16 x, s16 y) +{ + struct Sprite *sprite; + const struct MapObjectGraphicsInfo *graphicsInfo; + + sprite = &gSprites[mapObject->spriteId]; + graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + npc_coords_set(mapObject, x, y); + sub_8093038(mapObject->coords2.x, mapObject->coords2.y, &sprite->pos1.x, &sprite->pos1.y); + sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); + sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); + sprite->pos1.x += 8; + sprite->pos1.y += 16 + sprite->centerToCornerVecY; + sub_808E38C(mapObject); + if (mapObject->mapobj_bit_15) + { + CameraObjectReset1(); + } +} + +void sub_808EBA8(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + x += 7; + y += 7; + sub_808EB08(&gMapObjects[mapObjectId], x, y); + } +} + +void npc_coords_shift_still(struct MapObject *mapObject) +{ + npc_coords_shift(mapObject, mapObject->coords2.x, mapObject->coords2.y); +} + +void UpdateFieldObjectCoordsForCameraUpdate(void) +{ + u8 i; + s16 dx; + s16 dy; + + if (gCamera.active) + { + dx = gCamera.x; + dy = gCamera.y; + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active) + { + gMapObjects[i].coords1.x -= dx; + gMapObjects[i].coords1.y -= dy; + gMapObjects[i].coords2.x -= dx; + gMapObjects[i].coords2.y -= dy; + gMapObjects[i].coords3.x -= dx; + gMapObjects[i].coords3.y -= dy; + } + } + } +} + +u8 GetFieldObjectIdByXYZ(u16 x, u16 y, u8 z) +{ + u8 i; + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + if (gMapObjects[i].active) + { + if (gMapObjects[i].coords2.x == x && gMapObjects[i].coords2.y == y && FieldObjectDoesZCoordMatch(&gMapObjects[i], z)) + { + return i; + } + } + } + return NUM_FIELD_OBJECTS; +} + +static bool8 FieldObjectDoesZCoordMatch(struct MapObject *mapObject, u8 z) +{ + if (mapObject->mapobj_unk_0B_0 != 0 && z != 0 && mapObject->mapobj_unk_0B_0 != z) + { + return FALSE; + } + return TRUE; +} + +void UpdateFieldObjectsForCameraUpdate(s16 x, s16 y) +{ + UpdateFieldObjectCoordsForCameraUpdate(); + SpawnFieldObjectsInView(x, y); + RemoveFieldObjectsOutsideView(); +} + +u8 AddCameraObject(u8 linkedSpriteId) +{ + u8 spriteId; + + spriteId = CreateSprite(&gUnknown_084975D4, 0, 0, 4); + gSprites[spriteId].invisible = TRUE; + gSprites[spriteId].data0 = linkedSpriteId; + return spriteId; +} + +void ObjectCB_CameraObject(struct Sprite *sprite) +{ + void (*callbacks[ARRAY_COUNT(gUnknown_084975EC)])(struct Sprite *); + + memcpy(callbacks, gUnknown_084975EC, sizeof gUnknown_084975EC); + callbacks[sprite->data1](sprite); +} + +/*static*/ void CameraObject_0(struct Sprite *sprite) +{ + sprite->pos1.x = gSprites[sprite->data0].pos1.x; + sprite->pos1.y = gSprites[sprite->data0].pos1.y; + sprite->invisible = TRUE; + sprite->data1 = 1; + CameraObject_1(sprite); +} + +/*static*/ void CameraObject_1(struct Sprite *sprite) +{ + s16 x; + s16 y; + + y = gSprites[sprite->data0].pos1.y; + x = gSprites[sprite->data0].pos1.x; + sprite->data2 = x - sprite->pos1.x; + sprite->data3 = y - sprite->pos1.y; + sprite->pos1.x = x; + sprite->pos1.y = y; +} + +/*static*/ void CameraObject_2(struct Sprite *sprite) +{ + sprite->pos1.x = gSprites[sprite->data0].pos1.x; + sprite->pos1.y = gSprites[sprite->data0].pos1.y; + sprite->data2 = 0; + sprite->data3 = 0; +} + +static struct Sprite *FindCameraObject(void) +{ + u8 spriteId; + + for (spriteId = 0; spriteId < MAX_SPRITES; spriteId ++) + { + if (gSprites[spriteId].inUse && gSprites[spriteId].callback == ObjectCB_CameraObject) + { + return &gSprites[spriteId]; + } + } + return NULL; +} + +void CameraObjectReset1(void) +{ + struct Sprite *cameraObject; + + cameraObject = FindCameraObject(); + if (cameraObject != NULL) + { + cameraObject->data1 = 0; + cameraObject->callback(cameraObject); + } +} + +void CameraObjectSetFollowedObjectId(u8 objectId) +{ + struct Sprite *cameraObject; + + cameraObject = FindCameraObject(); + if (cameraObject != NULL) + { + cameraObject->data0 = objectId; + CameraObjectReset1(); + } +} + +u8 CameraObjectGetFollowedObjectId(void) +{ + struct Sprite *cameraObject; + + cameraObject = FindCameraObject(); + if (cameraObject == NULL) + { + return MAX_SPRITES; + } + return cameraObject->data0; +} + +void CameraObjectReset2(void) +{ + FindCameraObject()->data1 = 2; +} + +u8 CopySprite(struct Sprite *sprite, s16 x, s16 y, u8 subpriority) +{ + u8 i; + + for (i = 0; i < MAX_SPRITES; i ++) + { + if (!gSprites[i].inUse) + { + gSprites[i] = *sprite; + gSprites[i].pos1.x = x; + gSprites[i].pos1.y = y; + gSprites[i].subpriority = subpriority; + break; + } + } + return i; +} + +u8 obj_unfreeze(struct Sprite *sprite, s16 x, s16 y, u8 subpriority) +{ + s16 i; + + for (i = MAX_SPRITES - 1; i > -1; i --) + { + if (!gSprites[i].inUse) + { + gSprites[i] = *sprite; + gSprites[i].pos1.x = x; + gSprites[i].pos1.y = y; + gSprites[i].subpriority = subpriority; + return i; + } + } + return MAX_SPRITES; +} + +void FieldObjectSetDirection(struct MapObject *mapObject, u8 direction) +{ + s8 d2; + mapObject->mapobj_unk_20 = mapObject->mapobj_unk_18; + if (!mapObject->mapobj_bit_9) + { + d2 = direction; + mapObject->mapobj_unk_18 = d2; + } + mapObject->placeholder18 = direction; +} + +static const u8 *GetFieldObjectScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +{ + return GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->script; +} + +const u8 *GetFieldObjectScriptPointerByFieldObjectId(u8 mapObjectId) +{ + return GetFieldObjectScriptPointerByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup); +} + +static u16 GetFieldObjectFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +{ + return GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->flagId; +} + +u16 GetFieldObjectFlagIdByFieldObjectId(u8 mapObjectId) +{ + return GetFieldObjectFlagIdByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup); +} + +u8 sub_808F080(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + + if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + return 0xFF; + } + return gMapObjects[mapObjectId].trainerType; +} + +u8 sub_808F0BC(u8 mapObjectId) +{ + return gMapObjects[mapObjectId].trainerType; +} + +u8 sub_808F0D4(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + + if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + return 0xFF; + } + return gMapObjects[mapObjectId].trainerRange_berryTreeId; +} + +u8 FieldObjectGetBerryTreeId(u8 mapObjectId) +{ + return gMapObjects[mapObjectId].trainerRange_berryTreeId; +} + +struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +{ + struct MapObjectTemplate *templates; + const struct MapHeader *mapHeader; + u8 count; + + if (gSaveBlock1Ptr->location.mapNum == mapNum && gSaveBlock1Ptr->location.mapGroup == mapGroup) + { + templates = gSaveBlock1Ptr->mapObjectTemplates; + count = gMapHeader.events->mapObjectCount; + } + else + { + mapHeader = get_mapheader_by_bank_and_number(mapGroup, mapNum); + templates = mapHeader->events->mapObjects; + count = mapHeader->events->mapObjectCount; + } + return FindFieldObjectTemplateInArrayByLocalId(localId, templates, count); +} + +struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 localId, struct MapObjectTemplate *templates, u8 count) +{ + u8 i; + + for (i = 0; i < count; i ++) + { + if (templates[i].localId == localId) + { + return &templates[i]; + } + } + return NULL; +} + +struct MapObjectTemplate *sub_808F1B4(const struct MapObject *mapObject) +{ + int i; + + if (mapObject->mapNum != gSaveBlock1Ptr->location.mapNum || mapObject->mapGroup != gSaveBlock1Ptr->location.mapGroup) + { + return NULL; + } + for (i = 0; i < 64; i ++) // Using ARRAY_COUNT here results in the wrong conditional branch instruction (bls instead of ble) + { + if (mapObject->localId == gSaveBlock1Ptr->mapObjectTemplates[i].localId) + { + return &gSaveBlock1Ptr->mapObjectTemplates[i]; + } + } + return NULL; +} + +void sub_808F208(const struct MapObject *mapObject) +{ + struct MapObjectTemplate *mapObjectTemplate; + + mapObjectTemplate = sub_808F1B4(mapObject); + if (mapObjectTemplate != NULL) + { + mapObjectTemplate->x = mapObject->coords2.x - 7; + mapObjectTemplate->y = mapObject->coords2.y - 7; + } +} + +void sub_808F228(const struct MapObject *mapObject, const u8 *script) +{ + struct MapObjectTemplate *mapObjectTemplate; + + mapObjectTemplate = sub_808F1B4(mapObject); + if (mapObjectTemplate != NULL) + { + mapObjectTemplate->script = script; + } +} + +void sub_808F23C(const struct MapObject *mapObject, u8 movementType) +{ + struct MapObjectTemplate *mapObjectTemplate; + + mapObjectTemplate = sub_808F1B4(mapObject); + if (mapObjectTemplate != NULL) + { + mapObjectTemplate->movementType = movementType; + } +} + +void sub_808F254(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + sub_808F208(&gMapObjects[mapObjectId]); + } +} + +void sub_808F28C(u8 localId, u8 mapNum, u8 mapGroup, u8 action) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + switch (action) + { + case 6: + sub_808F228(&gMapObjects[mapObjectId], gUnknown_082766A2); + break; + case 7: + sub_808F228(&gMapObjects[mapObjectId], gUnknown_082766A6); + break; + } + } +} + +void npc_paltag_set_load(u8 palSlot) +{ + gpu_pal_allocator_reset__manage_upper_four(); + gUnknown_020375B6 = 0x11ff; + gUnknown_020375B4 = palSlot; + if (palSlot == 1) + { + pal_patch_for_npc_range(gUnknown_0850BE38[gUnknown_020375B4], 0, 6); + gReservedSpritePaletteCount = 8; + } + else + { + pal_patch_for_npc_range(gUnknown_0850BE38[gUnknown_020375B4], 0, 10); + } +} + +u16 npc_paltag_by_palslot(u8 palSlot) +{ + u8 i; + + if (palSlot < 10) + { + return gUnknown_0850BE38[gUnknown_020375B4][palSlot]; + } + for (i = 0; gUnknown_0850BD78[i].tag != 0x11ff; i ++) + { + if (gUnknown_0850BD78[i].tag == gUnknown_020375B6) + { + return gUnknown_0850BD78[i].data[gUnknown_020375B4]; + } + } + return 0x11ff; +} + +// Map Object Step Callbacks +// file boundary? + +null_object_step(NoMovement1, FALSE) + +field_object_step(GoRandomDirections, gUnknown_0850D6F4) + +bool8 sub_808F44C(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808F460(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_808F48C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (!FieldObjectExecRegularAnim(mapObject, sprite)) + { + return FALSE; + } + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + sprite->data1 = 3; + return TRUE; +} + +bool8 sub_808F4C8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_808F4E8(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 chosenDirection; + + memcpy(directions, gUnknown_0850D710, sizeof directions); + chosenDirection = directions[Random() & 0x03]; + FieldObjectSetDirection(mapObject, chosenDirection); + sprite->data1 = 5; + if (npc_block_way__next_tile(mapObject, chosenDirection)) + { + sprite->data1 = 1; + } + return TRUE; +} + +bool8 sub_808F534(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18)); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 6; + return TRUE; +} + +bool8 sub_808F564(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +bool8 FieldObjectIsTrainerAndCloseToPlayer(struct MapObject *mapObject) +{ + s16 playerX; + s16 playerY; + s16 objX; + s16 objY; + s16 minX; + s16 maxX; + s16 minY; + s16 maxY; + + if (!TestPlayerAvatarFlags(0x80)) + { + return FALSE; + } + if (mapObject->trainerType != 1 && mapObject->trainerType != 3) + { + return FALSE; + } + PlayerGetDestCoords(&playerX, &playerY); + objX = mapObject->coords2.x; + objY = mapObject->coords2.y; + minX = objX - mapObject->trainerRange_berryTreeId; + minY = objY - mapObject->trainerRange_berryTreeId; + maxX = objX + mapObject->trainerRange_berryTreeId; + maxY = objY + mapObject->trainerRange_berryTreeId; + if (minX > playerX || maxX < playerX || minY > playerY || maxY < playerY) + { + return FALSE; + } + return TRUE; +} + +u8 GetRegularRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + if (absdx > absdy) + { + direction = DIR_EAST; + if (dx < 0) + { + direction = DIR_WEST; + } + } + else + { + direction = DIR_SOUTH; + if (dy < 0) + { + direction = DIR_NORTH; + } + } + return direction; +} + +u8 GetNorthSouthRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = DIR_SOUTH; + if (dy < 0) + { + direction = DIR_NORTH; + } + return direction; +} + +u8 GetEastWestRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = DIR_EAST; + if (dx < 0) + { + direction = DIR_WEST; + } + return direction; +} + +u8 GetNorthEastRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_SOUTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_EAST) + { + direction = DIR_NORTH; + } + } + else if (direction == DIR_EAST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_SOUTH) + { + direction = DIR_NORTH; + } + } + return direction; +} + +u8 GetNorthWestRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_SOUTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_WEST) + { + direction = DIR_NORTH; + } + } + else if (direction == DIR_WEST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_SOUTH) + { + direction = DIR_NORTH; + } + } + return direction; +} + +u8 GetSouthEastRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_NORTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_EAST) + { + direction = DIR_SOUTH; + } + } + else if (direction == DIR_EAST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_NORTH) + { + direction = DIR_SOUTH; + } + } + return direction; +} + +u8 GetSouthWestRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_NORTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_WEST) + { + direction = DIR_SOUTH; + } + } + else if (direction == DIR_WEST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_NORTH) + { + direction = DIR_SOUTH; + } + } + return direction; +} + +u8 GetNonEastRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_EAST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + } + return direction; +} + +u8 GetNonWestRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_WEST) + { + direction = GetNorthSouthRunningPastFacingDirection(dx, dy, absdx, absdy); + } + return direction; +} + +u8 GetNonSouthRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_SOUTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + } + return direction; +} + +u8 GetNonNorthRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) +{ + u8 direction; + + direction = GetRegularRunningPastFacingDirection(dx, dy, absdx, absdy); + if (direction == DIR_NORTH) + { + direction = GetEastWestRunningPastFacingDirection(dx, dy, absdx, absdy); + } + return direction; +} + +u8 GetRunningPastFacingDirection(struct MapObject *mapObject, u8 movementType) +{ + s16 dx; + s16 dy; + s16 absdx; + s16 absdy; + + if (!FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + return 0; + } + PlayerGetDestCoords(&dx, &dy); + dx -= mapObject->coords2.x; + dy -= mapObject->coords2.y; + absdx = dx; + absdy = dy; + if (absdx < 0) + { + absdx = -absdx; + } + if (absdy < 0) + { + absdy = -absdy; + } + return gUnknown_0850D714[movementType](dx, dy, absdx, absdy); +} + +field_object_step(LookRandomDirections, gUnknown_0850D740) + +bool8 sub_808F988(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808F99C(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_808F9C8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_808FA0C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_808FA3C(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 direction; + + memcpy(directions, gUnknown_0850D710, sizeof directions); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + if (direction == 0) + { + direction = directions[Random() & 0x03]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyGoNorthOrSouth, gUnknown_0850D754) + +bool8 sub_808FAC8(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808FADC(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_808FB08(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (!FieldObjectExecRegularAnim(mapObject, sprite)) + { + return FALSE; + } + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + sprite->data1 = 3; + return TRUE; +} + +bool8 sub_808FB44(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_808FB64(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D770, sizeof directions); + direction = directions[Random() & 0x01]; + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 5; + if (npc_block_way__next_tile(mapObject, direction)) + { + sprite->data1 = 1; + } + return TRUE; +} + +bool8 sub_808FBB0(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18)); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 6; + return TRUE; +} + +bool8 sub_808FBE0(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +field_object_step(RandomlyGoEastOrWest, gUnknown_0850D774) + +bool8 sub_808FC4C(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808FC60(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_808FC8C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (!FieldObjectExecRegularAnim(mapObject, sprite)) + { + return FALSE; + } + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + sprite->data1 = 3; + return TRUE; +} + +bool8 sub_808FCC8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_808FCE8(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D790, sizeof directions); + direction = directions[Random() & 0x01]; + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 5; + if (npc_block_way__next_tile(mapObject, direction)) + { + sprite->data1 = 1; + } + return TRUE; +} + +bool8 sub_808FD34(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->placeholder18)); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 6; + return TRUE; +} + +bool8 sub_808FD64(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +field_object_step(FaceFixedDirection, gUnknown_0850D794) + +bool8 sub_808FDD0(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808FDFC(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + sprite->data1 = 2; + return TRUE; + } + return FALSE; +} + +bool8 sub_808FE1C(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_1 = FALSE; + return FALSE; +} + +static bool8 FieldObjectCB2_BerryTree(struct MapObject *mapObject, struct Sprite *sprite); +extern bool8 (*const gUnknown_0850D7A0[])(struct MapObject *mapObject, struct Sprite *sprite); +void FieldObjectCB_BerryTree(struct Sprite *sprite) +{ + struct MapObject *mapObject; + + mapObject = &gMapObjects[sprite->data0]; + if (!(sprite->data7 & 0x0001)) + { + get_berry_tree_graphics(mapObject, sprite); + sprite->data7 |= 0x0001; + } + FieldObjectStep(mapObject, sprite, FieldObjectCB2_BerryTree); +} +static bool8 FieldObjectCB2_BerryTree(struct MapObject *mapObject, struct Sprite *sprite) +{ + return gUnknown_0850D7A0[sprite->data1](mapObject, sprite); +} + +bool8 do_berry_tree_growth_sparkle_1 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 berryStage; + + npc_reset(mapObject, sprite); + mapObject->mapobj_bit_13 = TRUE; + sprite->invisible = TRUE; + berryStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId); + if (berryStage == 0) + { + if (!(sprite->data7 & 0x0004) && sprite->animNum == 4) + { + gFieldEffectSpawnParams[0] = mapObject->coords2.x; + gFieldEffectSpawnParams[1] = mapObject->coords2.y; + gFieldEffectSpawnParams[2] = sprite->subpriority - 1; + gFieldEffectSpawnParams[3] = sprite->oam.priority; + FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); + sprite->animNum = berryStage; + } + return FALSE; + } + mapObject->mapobj_bit_13 = FALSE; + sprite->invisible = FALSE; + berryStage --; + if (sprite->animNum != berryStage) + { + sprite->data1 = 2; + return TRUE; + } + get_berry_tree_graphics(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, 0x39); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_808FF48 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + sprite->data1 = 0; + return TRUE; + } + return FALSE; +} + +bool8 do_berry_tree_growth_sparkle_2 (struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 3; + sprite->data2 = 0; + sprite->data7 |= 0x0002; + gFieldEffectSpawnParams[0] = mapObject->coords2.x; + gFieldEffectSpawnParams[1] = mapObject->coords2.y; + gFieldEffectSpawnParams[2] = sprite->subpriority - 1; + gFieldEffectSpawnParams[3] = sprite->oam.priority; + FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); + return TRUE; +} + +bool8 sub_808FFB4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + sprite->data2 ++; + mapObject->mapobj_bit_13 = (sprite->data2 & 0x02) >> 1; + sprite->animPaused = TRUE; + if (sprite->data2 > 64) + { + get_berry_tree_graphics(mapObject, sprite); + sprite->data1 = 4; + sprite->data2 = 0; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090004 (struct MapObject *mapObject, struct Sprite *sprite) +{ + sprite->data2 ++; + mapObject->mapobj_bit_13 = (sprite->data2 & 0x02) >> 1; + sprite->animPaused = TRUE; + if (sprite->data2 > 64) + { + sprite->data1 = 0; + sprite->data7 &= ~0x0002; + return TRUE; + } + return FALSE; +} + +field_object_step(RandomlyLookNorthOrSouth, gUnknown_0850D7B4) + +bool8 sub_8090094 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_80900A8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_80900D4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090118 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090148 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D770, sizeof gUnknown_0850D770); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookEastOrWest, gUnknown_0850D7C8) + +bool8 sub_80901D4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_80901E8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090214 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6DC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090258 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090288 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D790, sizeof gUnknown_0850D790); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_EAST_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookNorthOrWest, gUnknown_0850D7DC) + +bool8 sub_8090314 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090328 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090354 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090398 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_80903C8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D7F0, sizeof gUnknown_0850D7F0); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookNorthOrEast, gUnknown_0850D7F4) + +bool8 sub_8090454 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090468 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090494 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_80904D8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090508 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D808, sizeof gUnknown_0850D808); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_EAST); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookSouthOrWest, gUnknown_0850D80C) + +bool8 sub_8090594 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_80905A8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_80905D4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090618 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090648 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D820, sizeof gUnknown_0850D820); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookSouthOrEast, gUnknown_0850D824) + +bool8 sub_80906D4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_80906E8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090714 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090758 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090788 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[2]; + u8 direction; + + memcpy(directions, gUnknown_0850D838, sizeof gUnknown_0850D838); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_EAST); + if (direction == 0) + { + direction = directions[Random() & 0x01]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookNorthOrSouthOrWest, gUnknown_0850D83C) + +bool8 sub_8090814 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090828 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090854 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090898 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_80908C8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 direction; + + memcpy(directions, gUnknown_0850D850, sizeof gUnknown_0850D850); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x03]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookNorthOrSouthOrEast, gUnknown_0850D854) + +bool8 sub_8090954 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090968 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090994 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_80909D8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090A08 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 direction; + + memcpy(directions, gUnknown_0850D868, sizeof gUnknown_0850D868); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH_EAST); + if (direction == 0) + { + direction = directions[Random() & 0x03]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookNorthOrEastOrWest, gUnknown_0850D86C) + +bool8 sub_8090A94 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090AA8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090AD4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090B18 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090B48 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 direction; + + memcpy(directions, gUnknown_0850D880, sizeof gUnknown_0850D880); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_EAST_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x03]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(RandomlyLookSouthOrEastOrWest, gUnknown_0850D884) + +bool8 sub_8090BD4 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090BE8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090C14 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, gUnknown_0850D6EC[Random() & 0x03]); + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090C58 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 4; + return TRUE; + } + return FALSE; +} + +bool8 sub_8090C88 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[4]; + u8 direction; + + memcpy(directions, gUnknown_0850D898, sizeof gUnknown_0850D898); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_EAST_WEST); + if (direction == 0) + { + direction = directions[Random() & 0x03]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(LookAroundCounterclockwise, gUnknown_0850D89C) + +bool8 sub_8090D14 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090D40 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, 48); + sprite->data1 = 2; + } + return FALSE; +} + +bool8 sub_8090D64 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090D90 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[5]; + u8 direction; + + memcpy(directions, gUnknown_0850D8AC, sizeof gUnknown_0850D8AC); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + if (direction == 0) + { + direction = directions[mapObject->mapobj_unk_18]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 0; + return TRUE; +} + +field_object_step(LookAroundClockwise, gUnknown_0850D8B4) + +bool8 sub_8090E18 (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090E44 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + SetFieldObjectStepTimer(sprite, 48); + sprite->data1 = 2; + } + return FALSE; +} + +bool8 sub_8090E68 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + { + sprite->data1 = 3; + } + return FALSE; +} + +bool8 sub_8090E94 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 directions[5]; + u8 direction; + + memcpy(directions, gUnknown_0850D8C4, sizeof gUnknown_0850D8C4); + direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + if (direction == 0) + { + direction = directions[mapObject->mapobj_unk_18]; + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 0; + return TRUE; +} + +field_object_step(AlternatelyGoInOppositeDirections, gUnknown_0850D8CC) + +bool8 sub_8090F1C (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8090F30 (struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 direction; + + direction = gUnknown_085055CD[mapObject->animPattern]; + if (mapObject->mapobj_unk_21) + { + direction = GetOppositeDirection(direction); + } + FieldObjectSetDirection(mapObject, direction); + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8090F68 (struct MapObject *mapObject, struct Sprite *sprite) +{ + bool8 blockingWay; + u8 animId; + + if (mapObject->mapobj_unk_21 && mapObject->coords1.x == mapObject->coords2.x && mapObject->coords1.y == mapObject->coords2.y) + { + mapObject->mapobj_unk_21 = 0; + FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->placeholder18)); + } + blockingWay = npc_block_way__next_tile(mapObject, mapObject->placeholder18); + animId = GetGoSpeed0AnimId(mapObject->placeholder18); + if (blockingWay == TRUE) + { + mapObject->mapobj_unk_21 ++; + FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->placeholder18)); + animId = GetGoSpeed0AnimId(mapObject->placeholder18); + blockingWay = npc_block_way__next_tile(mapObject, mapObject->placeholder18); + } + if (blockingWay) + { + animId = GetStepInPlaceDelay16AnimId(mapObject->mapobj_unk_18); + } + FieldObjectSetRegularAnim(mapObject, sprite, animId); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 3; + return TRUE; +} + +bool8 sub_8091020 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +bool8 sub_8091048(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + sprite->data1 = 1; + return TRUE; +} + +bool8 MoveFieldObjectInNextDirectionInSequence(struct MapObject *mapObject, struct Sprite *sprite, u8 *route) +{ + u8 blockingWay; + u8 animId; + + if (mapObject->mapobj_unk_21 == 3 && mapObject->coords1.x == mapObject->coords2.x && mapObject->coords1.y == mapObject->coords2.y) + { + mapObject->mapobj_unk_21 = 0; + } + FieldObjectSetDirection(mapObject, route[mapObject->mapobj_unk_21]); + animId = GetGoSpeed0AnimId(mapObject->placeholder18); + blockingWay = npc_block_way__next_tile(mapObject, mapObject->placeholder18); + if (blockingWay == TRUE) + { + mapObject->mapobj_unk_21 ++; + FieldObjectSetDirection(mapObject, route[mapObject->mapobj_unk_21]); + animId = GetGoSpeed0AnimId(mapObject->placeholder18); + blockingWay = npc_block_way__next_tile(mapObject, mapObject->placeholder18); + } + if (blockingWay) + { + animId = GetStepInPlaceDelay16AnimId(mapObject->mapobj_unk_18); + } + FieldObjectSetRegularAnim(mapObject, sprite, animId); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8091110(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +field_object_path( 1, gUnknown_0850D8DC, sub_809117C, gUnknown_0850D8E8, 2, x) +field_object_path( 2, gUnknown_0850D8EC, sub_8091208, gUnknown_0850D8F8, 1, x) +field_object_path( 3, gUnknown_0850D8FC, sub_8091294, gUnknown_0850D908, 1, y) +field_object_path( 4, gUnknown_0850D90C, sub_8091320, gUnknown_0850D918, 2, y) +field_object_path( 5, gUnknown_0850D91C, sub_80913AC, gUnknown_0850D928, 2, x) +field_object_path( 6, gUnknown_0850D92C, sub_8091438, gUnknown_0850D938, 1, x) +field_object_path( 7, gUnknown_0850D93C, sub_80914C4, gUnknown_0850D710, 1, y) +field_object_path( 8, gUnknown_0850D948, sub_8091550, gUnknown_0850D954, 2, y) +field_object_path( 9, gUnknown_0850D958, sub_80915DC, gUnknown_0850D964, 2, y) +field_object_path(10, gUnknown_0850D968, sub_8091668, gUnknown_0850D974, 1, y) +field_object_path(11, gUnknown_0850D978, sub_80916F4, gUnknown_0850D984, 1, x) +field_object_path(12, gUnknown_0850D988, sub_8091780, gUnknown_0850D994, 2, x) +field_object_path(13, gUnknown_0850D998, sub_809180C, gUnknown_0850D9A4, 2, y) +field_object_path(14, gUnknown_0850D9A8, sub_8091898, gUnknown_0850D9B4, 1, y) +field_object_path(15, gUnknown_0850D9B8, sub_8091924, gUnknown_0850D9C4, 1, x) +field_object_path(16, gUnknown_0850D9C8, sub_80919B0, gUnknown_0850D9D4, 2, x) +field_object_path(17, gUnknown_0850D9D8, sub_8091A3C, gUnknown_0850D9E4, 2, y) +field_object_path(18, gUnknown_0850D9E8, sub_8091AC8, gUnknown_0850D9F4, 2, y) +field_object_path(19, gUnknown_0850D9F8, sub_8091B54, gUnknown_0850DA04, 2, x) +field_object_path(20, gUnknown_0850DA08, sub_8091BE0, gUnknown_0850DA14, 2, x) +field_object_path(21, gUnknown_0850DA18, sub_8091C6C, gUnknown_0850DA24, 2, y) +field_object_path(22, gUnknown_0850DA28, sub_8091CF8, gUnknown_0850DA34, 2, y) +field_object_path(23, gUnknown_0850DA38, sub_8091D84, gUnknown_0850DA44, 2, x) +field_object_path(24, gUnknown_0850DA48, sub_8091E10, gUnknown_0850DA54, 2, x) + +field_object_step(CopyPlayer1, gUnknown_0850DA58) + +bool8 mss_npc_reset_oampriv3_1_unk2_unk3(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + if (mapObject->mapobj_unk_21 == 0) + { + mapObject->mapobj_unk_21 = player_get_direction_lower_nybble(); + } + sprite->data1 = 1; + return TRUE; +} + +bool8 sub_8091EC0(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (gMapObjects[gPlayerAvatar.mapObjectId].mapobj_unk_1C == 0xFF || gPlayerAvatar.running1 == 2) + { + return FALSE; + } + return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), NULL); +} + +bool8 sub_8091F20(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + mapObject->mapobj_bit_1 = FALSE; + sprite->data1 = 1; + } + return FALSE; +} + +bool8 sub_8091F48(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + return FALSE; +} + +bool8 sub_8091F4C(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, playerDirection))); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8091F94(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + if (FieldObjectIsFarawayIslandMew(mapObject)) + { + direction = sub_81D427C(); + if (direction == 0) + { + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; + } + } + else + { + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + } + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_80920A4(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed1AnimId(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_809215C(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed3AnimId(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8092214(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, sub_8093438(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 cph_IM_DIFFERENT(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectSetRegularAnim(mapObject, sprite, sub_80934BC(direction)); + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 sub_8092314(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + FieldObjectMoveDestCoords(mapObject, direction, &x, &y); + FieldObjectSetRegularAnim(mapObject, sprite, sub_8093514(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +bool8 oac_hopping(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +{ + u32 direction; + s16 x; + s16 y; + + direction = playerDirection; + direction = state_to_direction(gUnknown_085055CD[mapObject->animPattern], mapObject->mapobj_unk_21, direction); + x = mapObject->coords2.x; + y = mapObject->coords2.y; + sub_8092F88(direction, &x, &y, 2, 2); + FieldObjectSetRegularAnim(mapObject, sprite, GetJumpLedgeAnimId(direction)); + if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + { + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + } + mapObject->mapobj_bit_1 = TRUE; + sprite->data1 = 2; + return TRUE; +} + +field_object_step(CopyPlayer2, gUnknown_0850DA90) + +bool8 mss_08062EA4(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (gMapObjects[gPlayerAvatar.mapObjectId].mapobj_unk_1C == 0xFF || gPlayerAvatar.running1 == 2) + { + return FALSE; + } + return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), sub_8088E64); +} + +bool8 sub_80925AC(struct MapObject *, struct Sprite *); + +void FieldObjectCB_TreeDisguise(struct Sprite *sprite) +{ + struct MapObject *mapObject; + + mapObject = &gMapObjects[sprite->data0]; + if (mapObject->mapobj_unk_21 == 0 || (mapObject->mapobj_unk_21 == 1 && !sprite->data7)) + { + FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]); + mapObject->mapobj_unk_1A = FieldEffectStart(FLDEFF_TREE_DISGUISE); + mapObject->mapobj_unk_21 = 1; + sprite->data7 ++; + } + FieldObjectStep(&gMapObjects[sprite->data0], sprite, sub_80925AC); +} + +bool8 sub_80925AC(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + return FALSE; +} + +void FieldObjectCB_MountainDisguise(struct Sprite *sprite) +{ + struct MapObject *mapObject; + + mapObject = &gMapObjects[sprite->data0]; + if (mapObject->mapobj_unk_21 == 0 || (mapObject->mapobj_unk_21 == 1 && !sprite->data7)) + { + FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]); + mapObject->mapobj_unk_1A = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE); + mapObject->mapobj_unk_21 = 1; + sprite->data7 ++; + } + FieldObjectStep(&gMapObjects[sprite->data0], sprite, sub_80925AC); +} + +extern bool8 (*const gUnknown_0850DA9C[])(struct MapObject *, struct Sprite *); +bool8 sub_809268C(struct MapObject *, struct Sprite *); + +void FieldObjectCB_Hidden1(struct Sprite *sprite) +{ + if (!sprite->data7) + { + gMapObjects[sprite->data0].mapobj_bit_26 = TRUE; + sprite->subspriteMode = 2; + sprite->oam.priority = 3; + sprite->data7 ++; + } + FieldObjectStep(&gMapObjects[sprite->data0], sprite, sub_809268C); +} + +bool8 sub_809268C(struct MapObject *mapObject, struct Sprite *sprite) +{ + return gUnknown_0850DA9C[sprite->data1](mapObject, sprite); +} + +bool8 sub_80926AC (struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + return FALSE; +} +bool8 sub_80926B8 (struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + sprite->data1 = 0; + } + return FALSE; +} + +field_object_step(WalkInPlace1, gUnknown_0850DAA0) + +bool8 sub_8092718(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay16AnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(WalkInPlace4, gUnknown_0850DAA8) + +bool8 sub_8092788(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay32AnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(WalkInPlace2, gUnknown_0850DAB0) + +bool8 sub_80927F8(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay8AnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(WalkInPlace3, gUnknown_0850DAB8) + +bool8 sub_8092868(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay4AnimId(mapObject->mapobj_unk_18)); + sprite->data1 = 1; + return TRUE; +} + +field_object_step(Hidden2, gUnknown_0850DAC0) + +bool8 sub_80928D8(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_reset(mapObject, sprite); + FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->mapobj_unk_18)); + mapObject->mapobj_bit_13 = TRUE; + sprite->data1 = 1; + return TRUE; +} +bool8 sub_809290C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (FieldObjectExecRegularAnim(mapObject, sprite)) + { + sprite->data1 = 2; + return TRUE; + } + return FALSE; +} + +bool8 sub_809292C(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_1 = FALSE; + return FALSE; +} + +void npc_reset(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_1 = FALSE; + mapObject->mapobj_bit_6 = FALSE; + mapObject->mapobj_bit_7 = FALSE; + mapObject->mapobj_unk_1C = 0xFF; + sprite->data1 = 0; +} + +#define dirn2anim(name, table)\ +extern const u8 table[4];\ +u8 name(u8 direction)\ +{\ + return table[direction];\ +} + +dirn2anim(FieldObjectDirectionToImageAnimId, gUnknown_0850DACC) +dirn2anim(get_go_image_anim_num, gUnknown_0850DAD5) +dirn2anim(get_go_fast_image_anim_num, gUnknown_0850DADE) +dirn2anim(get_go_faster_image_anim_num, gUnknown_0850DAE7) +dirn2anim(get_go_fastest_image_anim_num, gUnknown_0850DAF0) +dirn2anim(sub_80929AC, gUnknown_0850DAF9) +dirn2anim(sub_80929BC, gUnknown_0850DB02) +dirn2anim(sub_80929CC, gUnknown_0850DB0B) +dirn2anim(sub_80929DC, gUnknown_0850DB14) +dirn2anim(sub_80929EC, gUnknown_0850DB1D) +dirn2anim(sub_80929FC, gUnknown_0850DB26) +dirn2anim(sub_8092A0C, gUnknown_0850DB2F) +dirn2anim(sub_8092A1C, gUnknown_0850DB38) +dirn2anim(sub_8092A2C, gUnknown_0850DB41) +dirn2anim(get_run_image_anim_num, gUnknown_0850DB4A) + +// file boundary? + +struct UnkStruct_085094AC { + const union AnimCmd *const *anims; + u8 animPos[4]; +}; + +extern const struct UnkStruct_085094AC gUnknown_085094AC[]; + +static const struct UnkStruct_085094AC *sub_8092A4C(const union AnimCmd *const *anims) +{ + const struct UnkStruct_085094AC *retval; + + for (retval = gUnknown_085094AC; retval->anims != NULL; retval ++) + { + if (retval->anims == anims) + { + return retval; + } + } + return NULL; +} + +void npc_apply_anim_looping(struct MapObject *mapObject, struct Sprite *sprite, u8 animNum) +{ + const struct UnkStruct_085094AC *unk85094AC; + + if (!mapObject->mapobj_bit_12) + { + sprite->animNum = animNum; + unk85094AC = sub_8092A4C(sprite->anims); + if (unk85094AC != NULL) + { + if (sprite->animCmdIndex == unk85094AC->animPos[0]) + { + sprite->animCmdIndex = unk85094AC->animPos[3]; + } + else if (sprite->animCmdIndex == unk85094AC->animPos[1]) + { + sprite->animCmdIndex = unk85094AC->animPos[2]; + } + } + SeekSpriteAnim(sprite, sprite->animCmdIndex); + } +} + +void obj_npc_animation_step(struct MapObject *mapObject, struct Sprite *sprite, u8 animNum) +{ + const struct UnkStruct_085094AC *unk85094AC; + + if (!mapObject->mapobj_bit_12) + { + u8 animPos; + + sprite->animNum = animNum; + unk85094AC = sub_8092A4C(sprite->anims); + if (unk85094AC != NULL) + { + animPos = unk85094AC->animPos[1]; + if (sprite->animCmdIndex <= unk85094AC->animPos[0]) + { + animPos = unk85094AC->animPos[0]; + } + SeekSpriteAnim(sprite, animPos); + } + } +} + +// file boundary? + +u8 sub_8092AF8(s16 x1, s16 y1, s16 x2, s16 y2) +{ + if (x1 > x2) + { + return DIR_WEST; + } + if (x1 < x2) + { + return DIR_EAST; + } + if (y1 > y2) + { + return DIR_NORTH; + } + return DIR_SOUTH; +} + +void npc_set_running_behaviour_etc(struct MapObject *mapObject, u8 animPattern) +{ + mapObject->animPattern = animPattern; + mapObject->mapobj_unk_21 = 0; + mapObject->animId = 0; + gSprites[mapObject->spriteId].callback = gUnknown_08505438[animPattern]; + gSprites[mapObject->spriteId].data1 = 0; +} + +dirn2anim(npc_running_behaviour_by_direction, gUnknown_0850DB53) + +u8 npc_block_way__next_tile(struct MapObject *mapObject, u8 direction) +{ + s16 x; + s16 y; + + x = mapObject->coords2.x; + y = mapObject->coords2.y; + MoveCoords(direction, &x, &y); + return npc_block_way(mapObject, x, y, direction); +} + +u8 npc_block_way(struct MapObject *mapObject, s16 x, s16 y, u32 dirn) +{ + u8 direction; + + direction = dirn; + if (IsCoordOutsideFieldObjectMovementRect(mapObject, x, y)) + { + return 1; + } + if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(mapObject, x, y, direction)) + { + return 2; + } + if (mapObject->mapobj_bit_15 && !CanCameraMoveInDirection(direction)) + { + return 2; + } + if (IsZCoordMismatchAt(mapObject->mapobj_unk_0B_0, x, y)) + { + return 3; + } + if (CheckForCollisionBetweenFieldObjects(mapObject, x, y)) + { + return 4; + } + return 0; +} + +u8 sub_8092C8C(struct MapObject *mapObject, s16 x, s16 y, u8 direction) +{ + u8 retval; + + retval = 0x00; + if (IsCoordOutsideFieldObjectMovementRect(mapObject, x, y)) + { + retval |= 1; + } + if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(mapObject, x, y, direction) || (mapObject->mapobj_bit_15 && !CanCameraMoveInDirection(direction))) + { + retval |= 2; + } + if (IsZCoordMismatchAt(mapObject->mapobj_unk_0B_0, x, y)) + { + retval |= 4; + } + if (CheckForCollisionBetweenFieldObjects(mapObject, x, y)) + { + retval |= 8; + } + return retval; +} + +static bool8 IsCoordOutsideFieldObjectMovementRect(struct MapObject *mapObject, s16 x, s16 y) +{ + s16 left; + s16 right; + s16 top; + s16 bottom; + + if (mapObject->range.as_nybbles.x != 0) + { + left = mapObject->coords1.x - mapObject->range.as_nybbles.x; + right = mapObject->coords1.x + mapObject->range.as_nybbles.x; + if (left > x || right < x) + { + return TRUE; + } + } + if (mapObject->range.as_nybbles.y != 0) + { + top = mapObject->coords1.y - mapObject->range.as_nybbles.y; + bottom = mapObject->coords1.y + mapObject->range.as_nybbles.y; + if (top > y || bottom < y) + { + return TRUE; + } + } + return FALSE; +} + +static bool8 IsMetatileDirectionallyImpassable(struct MapObject *mapObject, s16 x, s16 y, u8 direction) +{ + if (gUnknown_0850DB5C[direction - 1](mapObject->mapobj_unk_1E) || gUnknown_0850DB6C[direction - 1](MapGridGetMetatileBehaviorAt(x, y))) + { + return TRUE; + } + return FALSE; +} + +static bool8 CheckForCollisionBetweenFieldObjects(struct MapObject *mapObject, s16 x, s16 y) +{ + u8 i; + struct MapObject *curObject; + + for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + { + curObject = &gMapObjects[i]; + if (curObject->active && curObject != mapObject) + { + if ((curObject->coords2.x == x && curObject->coords2.y == y) || (curObject->coords3.x == x && curObject->coords3.y == y)) + { + if (AreZCoordsCompatible(mapObject->mapobj_unk_0B_0, curObject->mapobj_unk_0B_0)) + { + return TRUE; + } + } + } + } + return FALSE; +} + +bool8 sub_8092E9C(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId) && gSprites[gMapObjects[mapObjectId].spriteId].data7 & 0x02) + { + return TRUE; + } + return FALSE; +} + +void sub_8092EF0(u8 localId, u8 mapNum, u8 mapGroup) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + { + gSprites[gMapObjects[mapObjectId].spriteId].data7 |= 0x04; + } +} + +void MoveCoords(u8 direction, s16 *x, s16 *y) +{ + *x += gUnknown_0850DB7C[direction].x; + *y += gUnknown_0850DB7C[direction].y; +} + +void sub_8092F60(u8 direction, s16 *x, s16 *y) +{ + *x += gUnknown_0850DB7C[direction].x << 4; + *y += gUnknown_0850DB7C[direction].y << 4; +} + +void sub_8092F88(u32 dirn, s16 *x, s16 *y, s16 dx, s16 dy) +{ + u8 direction; + s16 dx_2; + s16 dy_2; + s16 cur_x; + s16 cur_y; + + direction = dirn; + dx_2 = dx; + dy_2 = dy; + cur_x = gUnknown_0850DB7C[direction].x; + if (cur_x > 0) + { + *x += dx_2; + } + if (cur_x < 0) + { + *x -= dx_2; + } + cur_y = gUnknown_0850DB7C[direction].y; + if (cur_y > 0) + { + *y += dy_2; + } + if (cur_y < 0) + { + *y -= dy_2; + } +} + +void sub_8092FF0(s16 x, s16 y, s16 *dest_x, s16 *dest_y) +{ + *dest_x = (x - gSaveBlock1Ptr->pos.x) << 4; + *dest_y = (y - gSaveBlock1Ptr->pos.y) << 4; + *dest_x -= gUnknown_03005DEC; + *dest_y -= gUnknown_03005DE8; +} + +void sub_8093038(s16 x, s16 y, s16 *dest_x, s16 *dest_y) +{ + s16 dx; + s16 dy; + + dx = -gUnknown_03005DEC - gUnknown_03005DD0.x; + dy = -gUnknown_03005DE8 - gUnknown_03005DD0.y; + if (gUnknown_03005DD0.x > 0) + { + dx += 0x10; + } + if (gUnknown_03005DD0.x < 0) + { + dx -= 0x10; + } + if (gUnknown_03005DD0.y > 0) + { + dy += 0x10; + } + if (gUnknown_03005DD0.y < 0) + { + dy -= 0x10; + } + *dest_x = ((x - gSaveBlock1Ptr->pos.x) << 4) + dx; + *dest_y = ((y - gSaveBlock1Ptr->pos.y) << 4) + dy; +} + +void sub_80930E0(s16 *x, s16 *y, s16 dx, s16 dy) +{ + sub_8093038(*x, *y, x, y); + *x += dx; + *y += dy; +} + +void GetFieldObjectMovingCameraOffset(s16 *x, s16 *y) +{ + *x = 0; + *y = 0; + if (gUnknown_03005DD0.x > 0) + { + (*x) ++; + } + if (gUnknown_03005DD0.x < 0) + { + (*x) --; + } + if (gUnknown_03005DD0.y > 0) + { + (*y) ++; + } + if (gUnknown_03005DD0.y < 0) + { + (*y) --; + } +} + +void FieldObjectMoveDestCoords(struct MapObject *mapObject, u32 dirn, s16 *x, s16 *y) +{ + u8 direction; + + direction = dirn; + *x = mapObject->coords2.x; + *y = mapObject->coords2.y; + MoveCoords(direction, x, y); +} + +// file boundary? + +bool8 FieldObjectIsSpecialAnimOrDirectionSequenceAnimActive(struct MapObject *mapObject) +{ + if (mapObject->mapobj_bit_1 || mapObject->mapobj_bit_6) + { + return TRUE; + } + return FALSE; +} + +bool8 FieldObjectIsSpecialAnimActive(struct MapObject *mapObject) +{ + if (mapObject->mapobj_bit_6 && mapObject->mapobj_unk_1C != 0xFF) + { + return TRUE; + } + return FALSE; +} + +bool8 FieldObjectSetSpecialAnim(struct MapObject *mapObject, u8 specialAnimId) +{ + if (FieldObjectIsSpecialAnimOrDirectionSequenceAnimActive(mapObject)) + { + return TRUE; + } + npc_sync_anim_pause_bits(mapObject); + mapObject->mapobj_unk_1C = specialAnimId; + mapObject->mapobj_bit_6 = TRUE; + mapObject->mapobj_bit_7 = FALSE; + gSprites[mapObject->spriteId].data2 = 0; + return FALSE; +} + +void FieldObjectForceSetSpecialAnim(struct MapObject *mapObject, u8 specialAnimId) +{ + FieldObjectClearAnimIfSpecialAnimActive(mapObject); + FieldObjectSetSpecialAnim(mapObject, specialAnimId); +} + +void FieldObjectClearAnimIfSpecialAnimActive(struct MapObject *mapObject) +{ + if (mapObject->mapobj_bit_6) + { + FieldObjectClearAnim(mapObject); + } +} + +void FieldObjectClearAnim(struct MapObject *mapObject) +{ + mapObject->mapobj_unk_1C = 0xFF; + mapObject->mapobj_bit_6 = FALSE; + mapObject->mapobj_bit_7 = FALSE; + gSprites[mapObject->spriteId].data1 = 0; + gSprites[mapObject->spriteId].data2 = 0; +} + +u8 FieldObjectCheckIfSpecialAnimFinishedOrInactive(struct MapObject *mapObject) +{ + if (mapObject->mapobj_bit_6) + { + return mapObject->mapobj_bit_7; + } + return 0x10; +} + +u8 FieldObjectClearAnimIfSpecialAnimFinished(struct MapObject *mapObject) +{ + u8 specialAnimState; + + specialAnimState = FieldObjectCheckIfSpecialAnimFinishedOrInactive(mapObject); + if (specialAnimState != 0 && specialAnimState != 16) + { + FieldObjectClearAnimIfSpecialAnimActive(mapObject); + } + return specialAnimState; +} + +u8 FieldObjectGetSpecialAnim(struct MapObject *mapObject) +{ + if (mapObject->mapobj_bit_6) + { + return mapObject->mapobj_unk_1C; + } + return 0xFF; +} + +void FieldObjectStep(struct MapObject *mapObject, struct Sprite *sprite, bool8 (*callback)(struct MapObject *, struct Sprite *)) +{ + DoGroundEffects_OnSpawn(mapObject, sprite); + sub_80964E8(mapObject, sprite); + if (FieldObjectIsSpecialAnimActive(mapObject)) + { + FieldObjectExecSpecialAnim(mapObject, sprite); + } + else if (!mapObject->mapobj_bit_8) + { + while (callback(mapObject, sprite)); + } + DoGroundEffects_OnBeginStep(mapObject, sprite); + DoGroundEffects_OnFinishStep(mapObject, sprite); + npc_obj_transfer_image_anim_pause_flag(mapObject, sprite); + sub_8096518(mapObject, sprite); + FieldObjectUpdateSubpriority(mapObject, sprite); +} + +#define dirn2anim_2(name, table) \ +extern const u8 table[5]; \ +u8 name(u32 direction) \ +{ \ + u8 dirn2; \ + u8 animIds[5]; \ + dirn2 = direction; \ + memcpy(animIds, table, 5); \ + if (dirn2 > DIR_EAST) \ + { \ + dirn2 = 0; \ + } \ + return animIds[dirn2]; \ +} + +dirn2anim_2(GetFaceDirectionAnimId, gUnknown_0850DBA0); +dirn2anim_2(GetSimpleGoAnimId, gUnknown_0850DBA5); +dirn2anim_2(GetGoSpeed0AnimId, gUnknown_0850DBAA); +dirn2anim_2(GetGoSpeed1AnimId, gUnknown_0850DBAF); +dirn2anim_2(GetGoSpeed2AnimId, gUnknown_0850DBB4); +dirn2anim_2(GetGoSpeed3AnimId, gUnknown_0850DBB9); +dirn2anim_2(sub_8093438, gUnknown_0850DBBE); +dirn2anim_2(GetRunAnimId, gUnknown_0850DBC3); +dirn2anim_2(GetJumpLedgeAnimId, gUnknown_0850DBC8); +dirn2anim_2(sub_80934BC, gUnknown_0850DBCD); +dirn2anim_2(sub_80934E8, gUnknown_0850DBD2); +dirn2anim_2(sub_8093514, gUnknown_0850DBD7); +dirn2anim_2(sub_8093540, gUnknown_0850DBDC); +dirn2anim_2(GetStepInPlaceDelay32AnimId, gUnknown_0850DBE1); +dirn2anim_2(GetStepInPlaceDelay16AnimId, gUnknown_0850DBE6); +dirn2anim_2(GetStepInPlaceDelay8AnimId, gUnknown_0850DBEB); +dirn2anim_2(GetStepInPlaceDelay4AnimId, gUnknown_0850DBF0); + +bool8 FieldObjectFaceOppositeDirection(struct MapObject *mapObject, u8 direction) +{ + return FieldObjectSetSpecialAnim(mapObject, GetFaceDirectionAnimId(GetOppositeDirection(direction))); +} + +dirn2anim_2(sub_8093648, gUnknown_0850DBF5); +dirn2anim_2(sub_8093674, gUnknown_0850DBFA); +dirn2anim_2(sub_80936A0, gUnknown_0850DBFF); +dirn2anim_2(sub_80936CC, gUnknown_0850DC04); +dirn2anim_2(sub_80936F8, gUnknown_0850DC09); +dirn2anim_2(sub_8093724, gUnknown_0850DC0E); +dirn2anim_2(sub_8093750, gUnknown_0850DC13); +dirn2anim_2(sub_809377C, gUnknown_0850DC18); +dirn2anim_2(sub_80937A8, gUnknown_0850DC1D); +dirn2anim_2(d2s_08064034, gUnknown_0850DC22); + +extern const u8 gUnknown_0850DC27[8]; + +u8 GetOppositeDirection(u8 direction) +{ + u8 directions[sizeof gUnknown_0850DC27]; + + memcpy(directions, gUnknown_0850DC27, sizeof gUnknown_0850DC27); + if (direction < 1 || direction > (sizeof gUnknown_0850DC27)) + { + return direction; + } + return directions[direction - 1]; +} + +static u32 zffu_offset_calc(u8 a0, u8 a1) +{ + return gUnknown_0850DC2F[a0 - 1][a1 - 1]; +} + +static u32 state_to_direction(u8 a0, u32 a1, u32 a2) +{ + u32 zffuOffset; + u8 a1_2; + u8 a2_2; + + a1_2 = a1; + a2_2 = a2; + if (a1_2 == 0 || a2_2 == 0 || a1_2 > DIR_EAST || a2_2 > DIR_EAST) + { + return 0; + } + zffuOffset = zffu_offset_calc(a1_2, a2); + return gUnknown_0850DC3F[a0 - 1][zffuOffset - 1]; +} + +static void FieldObjectExecSpecialAnim(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (gUnknown_0850DC50[mapObject->mapobj_unk_1C][sprite->data2](mapObject, sprite)) + { + mapObject->mapobj_bit_7 = TRUE; + } +} + +bool8 FieldObjectExecRegularAnim(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (gUnknown_0850DC50[mapObject->mapobj_unk_1C][sprite->data2](mapObject, sprite)) + { + mapObject->mapobj_unk_1C = 0xFF; + sprite->data2 = 0; + return TRUE; + } + return FALSE; +} + +void FieldObjectSetRegularAnim(struct MapObject *mapObject, struct Sprite *sprite, u8 animId) +{ + mapObject->mapobj_unk_1C = animId; + sprite->data2 = 0; +} + +// file boundary? + +void an_look_any(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + FieldObjectSetDirection(mapObject, direction); + npc_coords_shift_still(mapObject); + obj_npc_animation_step(mapObject, sprite, get_go_image_anim_num(mapObject->mapobj_unk_18)); + sprite->animPaused = TRUE; + sprite->data2 = 1; +} + +bool8 sub_8093950(struct MapObject *mapObject, struct Sprite *sprite) +{ + an_look_any(mapObject, sprite, DIR_SOUTH); + return TRUE; +} + +bool8 sub_8093960(struct MapObject *mapObject, struct Sprite *sprite) +{ + an_look_any(mapObject, sprite, DIR_NORTH); + return TRUE; +} + +bool8 sub_8093970(struct MapObject *mapObject, struct Sprite *sprite) +{ + an_look_any(mapObject, sprite, DIR_WEST); + return TRUE; +} + +bool8 sub_8093980(struct MapObject *mapObject, struct Sprite *sprite) +{ + an_look_any(mapObject, sprite, DIR_EAST); + return TRUE; +} + +void npc_apply_direction(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +{ + s16 x; + s16 y; + + x = mapObject->coords2.x; + y = mapObject->coords2.y; + FieldObjectSetDirection(mapObject, direction); + MoveCoords(direction, &x, &y); + npc_coords_shift(mapObject, x, y); + oamt_npc_ministep_reset(sprite, direction, speed); + sprite->animPaused = FALSE; + if (gUnknown_020375B8 != NULL && sub_8097F78(mapObject) != 0x10) + { + sprite->animPaused = TRUE; + } + mapObject->mapobj_bit_2 = TRUE; + sprite->data2 = 1; +} + +void do_go_anim(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +{ + u8 (*functions[ARRAY_COUNT(gUnknown_0850DEE8)])(u8); + + memcpy(functions, gUnknown_0850DEE8, sizeof gUnknown_0850DEE8); + npc_apply_direction(mapObject, sprite, direction, speed); + npc_apply_anim_looping(mapObject, sprite, functions[speed](mapObject->mapobj_unk_18)); +} + +void do_run_anim(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + npc_apply_direction(mapObject, sprite, direction, 1); + npc_apply_anim_looping(mapObject, sprite, get_run_image_anim_num(mapObject->mapobj_unk_18)); +} + +bool8 npc_obj_ministep_stop_on_arrival(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (obj_npc_ministep(sprite)) + { + npc_coords_shift_still(mapObject); + mapObject->mapobj_bit_3 = TRUE; + sprite->animPaused = TRUE; + return TRUE; + } + return FALSE; +} + +void sub_8093AF0(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + s16 x; + s16 y; + + x = mapObject->coords2.x; + y = mapObject->coords2.y; + FieldObjectSetDirection(mapObject, direction); + MoveCoords(direction, &x, &y); + npc_coords_shift(mapObject, x, y); + sub_80976DC(sprite, direction); + sprite->animPaused = FALSE; + mapObject->mapobj_bit_2 = TRUE; + sprite->data2 = 1; +} + +void sub_8093B60(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + sub_8093AF0(mapObject, sprite, direction); + npc_apply_anim_looping(mapObject, sprite, get_go_image_anim_num(mapObject->mapobj_unk_18)); +} + +bool8 an_walk_any_2(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_80976EC(sprite)) + { + npc_coords_shift_still(mapObject); + mapObject->mapobj_bit_3 = TRUE; + sprite->animPaused = TRUE; + return TRUE; + } + return FALSE; +} + +#define an_walk_any_2_macro(name, fn1, fn2, ...) \ +bool8 name##_2(struct MapObject *, struct Sprite *);\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + fn1(mapObject, sprite, __VA_ARGS__);\ + return name##_2(mapObject, sprite);\ +}\ +bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + if (fn2(mapObject, sprite))\ + {\ + sprite->data2 = 2;\ + return TRUE;\ + }\ + return FALSE;\ +} + +an_walk_any_2_macro(sub_8093BC4, sub_8093B60, an_walk_any_2, 7) +an_walk_any_2_macro(sub_8093C04, sub_8093B60, an_walk_any_2, 8) +an_walk_any_2_macro(sub_8093C44, sub_8093B60, an_walk_any_2, 5) +an_walk_any_2_macro(sub_8093C84, sub_8093B60, an_walk_any_2, 6) +an_walk_any_2_macro(sub_8093CC4, sub_8093B60, an_walk_any_2, 1) +an_walk_any_2_macro(sub_8093D04, sub_8093B60, an_walk_any_2, 2) +an_walk_any_2_macro(sub_8093D44, sub_8093B60, an_walk_any_2, 3) +an_walk_any_2_macro(sub_8093D84, sub_8093B60, an_walk_any_2, 4) +an_walk_any_2_macro(sub_8093DC4, do_go_anim, npc_obj_ministep_stop_on_arrival, 7, 0) +an_walk_any_2_macro(sub_8093E04, do_go_anim, npc_obj_ministep_stop_on_arrival, 8, 0) +an_walk_any_2_macro(sub_8093E44, do_go_anim, npc_obj_ministep_stop_on_arrival, 5, 0) +an_walk_any_2_macro(sub_8093E84, do_go_anim, npc_obj_ministep_stop_on_arrival, 6, 0) +an_walk_any_2_macro(sub_8093EC4, do_go_anim, npc_obj_ministep_stop_on_arrival, 1, 0) +an_walk_any_2_macro(sub_8093F04, do_go_anim, npc_obj_ministep_stop_on_arrival, 2, 0) +an_walk_any_2_macro(sub_8093F44, do_go_anim, npc_obj_ministep_stop_on_arrival, 3, 0) +an_walk_any_2_macro(sub_8093F84, do_go_anim, npc_obj_ministep_stop_on_arrival, 4, 0) + +void sub_8093FC4(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a5) +{ + s16 displacements[ARRAY_COUNT(gUnknown_0850DFBC)]; + s16 x; + s16 y; + + memcpy(displacements, gUnknown_0850DFBC, sizeof gUnknown_0850DFBC); + x = 0; + y = 0; + FieldObjectSetDirection(mapObject, direction); + sub_8092F88(direction, &x, &y, displacements[speed], displacements[speed]); + npc_coords_shift(mapObject, mapObject->coords2.x + x, mapObject->coords2.y + y); + sub_809783C(sprite, direction, speed, a5); + sprite->data2 = 1; + sprite->animPaused = 0; + mapObject->mapobj_bit_2 = 1; + mapObject->mapobj_bit_4 = 1; +} + +void maybe_shadow_1(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) +{ + sub_8093FC4(mapObject, sprite, direction, speed, a4); + npc_apply_anim_looping(mapObject, sprite, get_go_image_anim_num(mapObject->mapobj_unk_18)); + DoShadowFieldEffect(mapObject); +} + +u8 sub_80940C4(struct MapObject *mapObject, struct Sprite *sprite, u8 callback(struct Sprite *)) +{ + s16 displacements[ARRAY_COUNT(gUnknown_0850DFC2)]; + s16 x; + s16 y; + u8 result; + + memcpy(displacements, gUnknown_0850DFC2, sizeof gUnknown_0850DFC2); + result = callback(sprite); + if (result == 1 && displacements[sprite->data4] != 0) + { + x = 0; + y = 0; + sub_8092F88(mapObject->placeholder18, &x, &y, displacements[sprite->data4], displacements[sprite->data4]); + npc_coords_shift(mapObject, mapObject->coords2.x + x, mapObject->coords2.y + y); + mapObject->mapobj_bit_2 = TRUE; + mapObject->mapobj_bit_4 = TRUE; + } + else if (result == 0xFF) + { + npc_coords_shift_still(mapObject); + mapObject->mapobj_bit_3 = TRUE; + mapObject->mapobj_bit_5 = TRUE; + sprite->animPaused = TRUE; + } + return result; +} + +u8 sub_8094188(struct MapObject *mapObject, struct Sprite *sprite) +{ + return sub_80940C4(mapObject, sprite, sub_809785C); +} + +u8 sub_809419C(struct MapObject *mapObject, struct Sprite *sprite) +{ + return sub_80940C4(mapObject, sprite, sub_80978E4); +} + +bool8 sub_80941B0(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_8094188(mapObject, sprite) == 0xFF) + { + return TRUE; + } + return FALSE; +} + +bool8 sub_80941C8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_809419C(mapObject, sprite) == 0xFF) + { + return TRUE; + } + return FALSE; +} + +bool8 sub_80941E0(struct MapObject *mapObject, struct Sprite *sprite) +{ + switch (sub_8094188(mapObject, sprite)) + { + case 255: + return TRUE; + case 1: + FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->placeholder18)); + obj_npc_animation_step(mapObject, sprite, get_go_image_anim_num(mapObject->mapobj_unk_18)); + default: + return FALSE; + } +} + +#define maybe_shadow_1_macro(name, fn1, fn2, ...) \ +bool8 name##_2(struct MapObject *, struct Sprite *);\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + fn1(mapObject, sprite, __VA_ARGS__);\ + return name##_2(mapObject, sprite);\ +}\ +bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + if (fn2(mapObject, sprite))\ + {\ + mapObject->mapobj_bit_22 = FALSE;\ + sprite->data2 = 2;\ + return TRUE;\ + }\ + return FALSE;\ +} + +maybe_shadow_1_macro(sub_8094230, maybe_shadow_1, sub_80941B0, DIR_SOUTH, 2, 0) +maybe_shadow_1_macro(sub_8094288, maybe_shadow_1, sub_80941B0, DIR_NORTH, 2, 0) +maybe_shadow_1_macro(sub_80942E0, maybe_shadow_1, sub_80941B0, DIR_WEST, 2, 0) +maybe_shadow_1_macro(sub_8094338, maybe_shadow_1, sub_80941B0, DIR_EAST, 2, 0) + +void sub_8094390(struct Sprite *sprite, u16 duration) +{ + sprite->data2 = 1; + sprite->data3 = duration; +} + +bool8 sub_8094398(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (-- sprite->data3 == 0) + { + sprite->data2 = 2; + return TRUE; + } + return FALSE; +} + +#define special_anim_with_timer(name, duration)\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + sub_8094390(sprite, duration);\ + return sub_8094398(mapObject, sprite);\ +} + +special_anim_with_timer(sub_80943B4, 1) +special_anim_with_timer(sub_80943D4, 2) +special_anim_with_timer(sub_80943F4, 4) +special_anim_with_timer(sub_8094414, 8) +special_anim_with_timer(sub_8094434, 16) + +an_walk_any_2_macro(sub_8094454, do_go_anim, npc_obj_ministep_stop_on_arrival, 1, 1) +an_walk_any_2_macro(sub_8094494, do_go_anim, npc_obj_ministep_stop_on_arrival, 2, 1) +an_walk_any_2_macro(sub_80944D4, do_go_anim, npc_obj_ministep_stop_on_arrival, 3, 1) +an_walk_any_2_macro(sub_8094514, do_go_anim, npc_obj_ministep_stop_on_arrival, 4, 1) + +void sub_8094554(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 animNum, u16 duration) +{ + FieldObjectSetDirection(mapObject, direction); + npc_apply_anim_looping(mapObject, sprite, animNum); + sprite->animPaused = FALSE; + sprite->data2 = 1; + sprite->data3 = duration; +} + +bool8 sub_809459C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (-- sprite->data3 == 0) + { + sprite->data2 = 2; + sprite->animPaused = TRUE; + return TRUE; + } + return FALSE; +} + +bool8 sub_80945C4(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sprite->data3 & 1) + { + sprite->animDelayCounter ++; + } + return sub_809459C(mapObject, sprite); +} + +#define special_anim_with_timer_2(name, direction, images, duration, timer) \ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + u8 animId;\ + animId = images(DIR_##direction);\ + sub_8094554(mapObject, sprite, DIR_##direction, animId, duration);\ + return timer(mapObject, sprite);\ +} + +special_anim_with_timer_2(sub_8094600, SOUTH, get_go_image_anim_num, 32, sub_80945C4) +special_anim_with_timer_2(sub_8094638, NORTH, get_go_image_anim_num, 32, sub_80945C4) +special_anim_with_timer_2(sub_8094670, WEST, get_go_image_anim_num, 32, sub_80945C4) +special_anim_with_timer_2(sub_80946A8, EAST, get_go_image_anim_num, 32, sub_80945C4) +special_anim_with_timer_2(sub_80946E0, SOUTH, get_go_image_anim_num, 16, sub_809459C) +special_anim_with_timer_2(sub_8094718, NORTH, get_go_image_anim_num, 16, sub_809459C) +special_anim_with_timer_2(sub_8094750, WEST, get_go_image_anim_num, 16, sub_809459C) +special_anim_with_timer_2(sub_8094788, EAST, get_go_image_anim_num, 16, sub_809459C) +special_anim_with_timer_2(sub_80947C0, SOUTH, get_go_fast_image_anim_num, 8, sub_809459C) +special_anim_with_timer_2(sub_80947F8, NORTH, get_go_fast_image_anim_num, 8, sub_809459C) +special_anim_with_timer_2(sub_8094830, WEST, get_go_fast_image_anim_num, 8, sub_809459C) +special_anim_with_timer_2(sub_8094868, EAST, get_go_fast_image_anim_num, 8, sub_809459C) +special_anim_with_timer_2(sub_80948A0, SOUTH, get_go_faster_image_anim_num, 4, sub_809459C) +special_anim_with_timer_2(sub_80948D8, NORTH, get_go_faster_image_anim_num, 4, sub_809459C) +special_anim_with_timer_2(sub_8094910, WEST, get_go_faster_image_anim_num, 4, sub_809459C) +special_anim_with_timer_2(sub_8094948, EAST, get_go_faster_image_anim_num, 4, sub_809459C) + +an_walk_any_2_macro(sub_8094980, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 2) +an_walk_any_2_macro(sub_80949C0, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 2) +an_walk_any_2_macro(sub_8094A00, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_WEST, 2) +an_walk_any_2_macro(sub_8094A40, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_EAST, 2) +an_walk_any_2_macro(sub_8094A80, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 3) +an_walk_any_2_macro(sub_8094AC0, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 3) +an_walk_any_2_macro(sub_8094B00, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_WEST, 3) +an_walk_any_2_macro(sub_8094B40, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_EAST, 3) +an_walk_any_2_macro(sub_8094B80, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 4) +an_walk_any_2_macro(sub_8094BC0, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 4) +an_walk_any_2_macro(sub_8094C00, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_WEST, 4) +an_walk_any_2_macro(sub_8094C40, do_go_anim, npc_obj_ministep_stop_on_arrival, DIR_EAST, 4) +an_walk_any_2_macro(sub_8094C80, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_SOUTH) +an_walk_any_2_macro(sub_8094CC0, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_NORTH) +an_walk_any_2_macro(sub_8094D00, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_WEST) +an_walk_any_2_macro(sub_8094D40, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_EAST) + +void npc_set_direction_and_anim__an_proceed(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 animNum) +{ + obj_anim_image_set_and_seek(sprite, animNum, 0); + FieldObjectSetDirection(mapObject, direction); + sprite->data2 = 1; +} + +bool8 sub_8094DAC(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_set_direction_and_anim__an_proceed(mapObject, sprite, mapObject->placeholder18, sprite->animNum); + return FALSE; +} + +bool8 sub_8094DC4(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_80979BC(sprite)) + { + sprite->data2 = 2; + return TRUE; + } + return FALSE; +} + +void sub_8094DE4(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + sub_8093FC4(mapObject, sprite, direction, 1, 0); + StartSpriteAnim(sprite, sub_80929AC(direction)); +} + +#define unk_macro_8094E18(name, direction)\ +bool8 name##_2(struct MapObject *, struct Sprite *);\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + sub_8094DE4(mapObject, sprite, direction);\ + return name##_2(mapObject, sprite);\ +}\ +bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + if (sub_80941C8(mapObject, sprite))\ + {\ + sprite->data2 = 2;\ + mapObject->mapobj_bit_5 = FALSE;\ + return TRUE;\ + }\ + return FALSE;\ +} + +unk_macro_8094E18(sub_8094E18, DIR_SOUTH) +unk_macro_8094E18(sub_8094E60, DIR_NORTH) +unk_macro_8094E18(sub_8094EB8, DIR_WEST) +unk_macro_8094E18(sub_8094710, DIR_EAST) + +bool8 sub_8094F38(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(0xFF, 0, 0, &mapObjectId)) + { + an_look_any(mapObject, sprite, sub_8092AF8(mapObject->coords2.x, mapObject->coords2.y, gMapObjects[mapObjectId].coords2.x, gMapObjects[mapObjectId].coords2.y)); + } + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8094F94(struct MapObject *mapObject, struct Sprite *sprite) +{ + u8 mapObjectId; + + if (!TryGetFieldObjectIdByLocalIdAndMap(0xFF, 0, 0, &mapObjectId)) + { + an_look_any(mapObject, sprite, GetOppositeDirection(sub_8092AF8(mapObject->coords2.x, mapObject->coords2.y, gMapObjects[mapObjectId].coords2.x, gMapObjects[mapObjectId].coords2.y))); + } + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8094FF8(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_9 = TRUE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8095008(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_9 = FALSE; + sprite->data2 = 1; + return TRUE; +} + +maybe_shadow_1_macro(sub_8095018, maybe_shadow_1, sub_80941B0, DIR_SOUTH, 1, 2) +maybe_shadow_1_macro(sub_8095070, maybe_shadow_1, sub_80941B0, DIR_NORTH, 1, 2) +maybe_shadow_1_macro(sub_80950C8, maybe_shadow_1, sub_80941B0, DIR_WEST, 1, 2) +maybe_shadow_1_macro(sub_8095120, maybe_shadow_1, sub_80941B0, DIR_EAST, 1, 2) +maybe_shadow_1_macro(sub_8095178, maybe_shadow_1, sub_80941B0, DIR_SOUTH, 0, 0) +maybe_shadow_1_macro(sub_80951D0, maybe_shadow_1, sub_80941B0, DIR_NORTH, 0, 0) +maybe_shadow_1_macro(sub_8095228, maybe_shadow_1, sub_80941B0, DIR_WEST, 0, 0) +maybe_shadow_1_macro(sub_8095280, maybe_shadow_1, sub_80941B0, DIR_EAST, 0, 0) +maybe_shadow_1_macro(sub_80952D8, maybe_shadow_1, sub_80941E0, DIR_SOUTH, 0, 2) +maybe_shadow_1_macro(sub_8095330, maybe_shadow_1, sub_80941E0, DIR_NORTH, 0, 2) +maybe_shadow_1_macro(sub_8095388, maybe_shadow_1, sub_80941E0, DIR_WEST, 0, 2) +maybe_shadow_1_macro(sub_80953E0, maybe_shadow_1, sub_80941E0, DIR_EAST, 0, 2) + +bool8 sub_8095438(struct MapObject *mapObject, struct Sprite *sprite) +{ + an_look_any(mapObject, sprite, gUnknown_085055CD[mapObject->animPattern]); + return TRUE; +} + +bool8 sub_8095450(struct MapObject *mapObject, struct Sprite *sprite) +{ + npc_set_direction_and_anim__an_proceed(mapObject, sprite, DIR_SOUTH, 0x14); + return FALSE; +} + +bool8 sub_8095460(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_25 = FALSE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8095470(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_25 = TRUE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8095480(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_12 = TRUE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8095490(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_12 = GetFieldObjectGraphicsInfo(mapObject->graphicsId)->inanimate; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_80954BC(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_13 = TRUE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_80954CC(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_13 = FALSE; + sprite->data2 = 1; + return TRUE; +} + +bool8 do_exclamation_mark_bubble_1(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]); + FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_1); + sprite->data2 = 1; + return TRUE; +} + +bool8 do_exclamation_mark_bubble_2(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]); + FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_2); + sprite->data2 = 1; + return TRUE; +} + +bool8 do_heart_bubble(struct MapObject *mapObject, struct Sprite *sprite) +{ + FieldObjectGetLocalIdAndMap(mapObject, (u8 *)&gFieldEffectSpawnParams[0], (u8 *)&gFieldEffectSpawnParams[1], (u8 *)&gFieldEffectSpawnParams[2]); + FieldEffectStart(FLDEFF_HEART_ICON); + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8095548(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (mapObject->animPattern == 0x3F) + { + sub_80B4578(mapObject); + return FALSE; + } + if (mapObject->animPattern != 0x39 && mapObject->animPattern != 0x3A) + { + sprite->data2 = 2; + return TRUE; + } + sub_8155D78(mapObject); + sprite->data2 = 1; + return sub_809558C(mapObject, sprite); +} + +bool8 sub_809558C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_8155DA0(mapObject)) + { + sprite->data2 = 2; + return TRUE; + } + return FALSE; +} + +bool8 sub_80955AC(struct MapObject *mapObject, struct Sprite *sprite) +{ + obj_anim_image_set_and_seek(sprite, 1, 0); + sprite->data2 = 1; + return FALSE; +} + +bool8 sub_80955C8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_80979BC(sprite)) + { + SetFieldObjectStepTimer(sprite, 32); + sprite->data2 = 2; + } + return FALSE; +} + +bool8 sub_80955EC(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_13 ^= TRUE; + if (RunFieldObjectStepTimer(sprite)) + { + mapObject->mapobj_bit_13 = TRUE; + sprite->data2 = 3; + } + return FALSE; +} + +bool8 sub_8095628(struct MapObject *mapObject, struct Sprite *sprite) +{ + obj_anim_image_set_and_seek(sprite, 1, 0); + sprite->data2 = 1; + return FALSE; +} + +bool8 sub_8095644(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_80979BC(sprite)) + { + SetFieldObjectStepTimer(sprite, 32); + sprite->data2 = 2; + } + return FALSE; +} + +bool8 sub_8095668(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_13 ^= TRUE; + if (RunFieldObjectStepTimer(sprite)) + { + mapObject->mapobj_bit_13 = TRUE; + sprite->data2 = 3; + } + return FALSE; +} + +bool8 sub_80956A4(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_26 = TRUE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_80956B4(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_26 = FALSE; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_80956C4(struct MapObject *mapObject, struct Sprite *sprite) +{ + sprite->oam.affineMode = 3; + InitSpriteAffineAnim(sprite); + sprite->affineAnimPaused = TRUE; + sprite->subspriteMode = 0; + return TRUE; +} + +bool8 sub_80956F4(struct MapObject *mapObject, struct Sprite *sprite) +{ + FreeOamMatrix(sprite->oam.matrixNum); + sprite->oam.affineMode = 0; + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode); + return TRUE; +} + +bool8 sub_8095724(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_27 = TRUE; + return TRUE; +} + +bool8 sub_8095730(struct MapObject *mapObject, struct Sprite *sprite) +{ + mapObject->mapobj_bit_27 = FALSE; + return TRUE; +} + +#define affine_an_walk_any_2_macro(name, fn, fn2, action, anim, ...)\ +bool8 name##_2(struct MapObject *, struct Sprite *);\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + fn(mapObject, sprite, __VA_ARGS__);\ + sprite->affineAnimPaused = FALSE;\ + action(sprite, anim);\ + return name##_2(mapObject, sprite);\ +}\ +bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + if (fn2(mapObject, sprite))\ + {\ + sprite->affineAnimPaused = TRUE;\ + sprite->data2 = 2;\ + return TRUE;\ + }\ + return FALSE;\ +}\ + +affine_an_walk_any_2_macro(sub_8095740, sub_8093B60, an_walk_any_2, StartSpriteAffineAnimIfDifferent, 0, DIR_SOUTH) +affine_an_walk_any_2_macro(sub_80957A0, sub_8093B60, an_walk_any_2, ChangeSpriteAffineAnimIfDifferent, 1, DIR_SOUTH) +affine_an_walk_any_2_macro(sub_8095800, do_go_anim, npc_obj_ministep_stop_on_arrival, ChangeSpriteAffineAnimIfDifferent, 2, DIR_WEST, 1) +affine_an_walk_any_2_macro(sub_8095860, do_go_anim, npc_obj_ministep_stop_on_arrival, ChangeSpriteAffineAnimIfDifferent, 3, DIR_EAST, 1) + +static void sub_80958C0(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +{ + FieldObjectSetDirection(mapObject, direction); + npc_coords_shift_still(mapObject); + obj_npc_animation_step(mapObject, sprite, sub_80929FC(direction)); + sprite->animPaused = TRUE; + sprite->data2 = 1; +} + +bool8 sub_8095900(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_80958C0(mapObject, sprite, DIR_SOUTH); + return TRUE; +} + +bool8 sub_8095910(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_80958C0(mapObject, sprite, DIR_NORTH); + return TRUE; +} + +bool8 sub_8095920(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_80958C0(mapObject, sprite, DIR_WEST); + return TRUE; +} + +bool8 sub_8095930(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_80958C0(mapObject, sprite, DIR_EAST); + return TRUE; +} + +#define set_dirn_and_anim__an_proceed(name, direction, anims)\ +bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +{\ + npc_set_direction_and_anim__an_proceed(mapObject, sprite, direction, anims(direction));\ + return FALSE;\ +} + +set_dirn_and_anim__an_proceed(sub_8095940, DIR_SOUTH, sub_80929BC) +set_dirn_and_anim__an_proceed(sub_8095964, DIR_NORTH, sub_80929BC) +set_dirn_and_anim__an_proceed(sub_8095988, DIR_WEST, sub_80929BC) +set_dirn_and_anim__an_proceed(sub_80959AC, DIR_EAST, sub_80929BC) +set_dirn_and_anim__an_proceed(sub_80959D0, DIR_SOUTH, sub_80929DC) +set_dirn_and_anim__an_proceed(sub_80959F4, DIR_NORTH, sub_80929DC) +set_dirn_and_anim__an_proceed(sub_8095A18, DIR_WEST, sub_80929DC) +set_dirn_and_anim__an_proceed(sub_8095A3C, DIR_EAST, sub_80929DC) +set_dirn_and_anim__an_proceed(sub_8095A60, DIR_SOUTH, sub_80929EC) +set_dirn_and_anim__an_proceed(sub_8095A84, DIR_NORTH, sub_80929EC) +set_dirn_and_anim__an_proceed(sub_8095AA8, DIR_WEST, sub_80929EC) +set_dirn_and_anim__an_proceed(sub_8095ACC, DIR_EAST, sub_80929EC) + +void sub_8095AF0(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_8097750(sprite); + sprite->animPaused = FALSE; +} + +bool8 sub_8095B0C(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_8097758(sprite)) + { + npc_coords_shift_still(mapObject); + mapObject->mapobj_bit_3 = TRUE; + sprite->animPaused = TRUE; + return TRUE; + } + return FALSE; +} + +bool8 sub_8095B44(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_8095AF0(mapObject, sprite); + sprite->data2 = 1; + return sub_8095B64(mapObject, sprite); +} + +bool8 sub_8095B64(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sub_8095B0C(mapObject, sprite)) + { + sprite->data2 = 2; + return TRUE; + } + return FALSE; +} + +void sub_8095B84(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) +{ + sub_8093FC4(mapObject, sprite, direction, speed, a4); + StartSpriteAnimIfDifferent(sprite, sub_80929BC(direction)); + DoShadowFieldEffect(mapObject); +} + +maybe_shadow_1_macro(sub_8095BC8, sub_8095B84, sub_80941B0, DIR_SOUTH, 0, 1) +maybe_shadow_1_macro(sub_8095C20, sub_8095B84, sub_80941B0, DIR_NORTH, 0, 1) +maybe_shadow_1_macro(sub_8095C78, sub_8095B84, sub_80941B0, DIR_WEST, 0, 1) +maybe_shadow_1_macro(sub_8095CD0, sub_8095B84, sub_80941B0, DIR_EAST, 0, 1) +maybe_shadow_1_macro(sub_8095D28, sub_8095B84, sub_80941B0, DIR_SOUTH, 1, 1) +maybe_shadow_1_macro(sub_8095D80, sub_8095B84, sub_80941B0, DIR_NORTH, 1, 1) +maybe_shadow_1_macro(sub_8095DD8, sub_8095B84, sub_80941B0, DIR_WEST, 1, 1) +maybe_shadow_1_macro(sub_8095E30, sub_8095B84, sub_80941B0, DIR_EAST, 1, 1) +maybe_shadow_1_macro(sub_8095E88, sub_8095B84, sub_80941B0, DIR_SOUTH, 2, 0) +maybe_shadow_1_macro(sub_8095EE0, sub_8095B84, sub_80941B0, DIR_NORTH, 2, 0) +maybe_shadow_1_macro(sub_8095F38, sub_8095B84, sub_80941B0, DIR_WEST, 2, 0) +maybe_shadow_1_macro(sub_8095F90, sub_8095B84, sub_80941B0, DIR_EAST, 2, 0) + +special_anim_with_timer_2(sub_8095FE8, SOUTH, sub_80929FC, 8, sub_809459C) +special_anim_with_timer_2(sub_8096020, NORTH, sub_80929FC, 8, sub_809459C) +special_anim_with_timer_2(sub_8096058, WEST, sub_80929FC, 8, sub_809459C) +special_anim_with_timer_2(sub_8096090, EAST, sub_80929FC, 8, sub_809459C) + +void sub_80960C8(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +{ + npc_apply_direction(mapObject, sprite, direction, speed); + StartSpriteAnim(sprite, sub_80929BC(mapObject->mapobj_unk_18)); + SeekSpriteAnim(sprite, 0); +} + +an_walk_any_2_macro(sub_8096100, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 1) +an_walk_any_2_macro(sub_8096140, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 1) +an_walk_any_2_macro(sub_8096180, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) +an_walk_any_2_macro(sub_80961C0, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) + +void sub_8096200(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +{ + npc_apply_direction(mapObject, sprite, direction, speed); + npc_apply_anim_looping(mapObject, sprite, sub_80929FC(mapObject->mapobj_unk_18)); +} + +an_walk_any_2_macro(sub_8096230, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 1) +an_walk_any_2_macro(sub_8096270, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 1) +an_walk_any_2_macro(sub_80962B0, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) +an_walk_any_2_macro(sub_80962F0, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) + +void sub_8096330(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +{ + npc_apply_direction(mapObject, sprite, direction, speed); + StartSpriteAnim(sprite, sub_80929DC(mapObject->mapobj_unk_18)); + SeekSpriteAnim(sprite, 0); +} +an_walk_any_2_macro(sub_8096368, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 1) +an_walk_any_2_macro(sub_80963A8, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_NORTH, 1) +an_walk_any_2_macro(sub_80963E8, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) +an_walk_any_2_macro(sub_8096428, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) + +bool8 sub_8096468(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_8097FA4(mapObject); + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_809647C(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_8098044(mapObject->mapobj_unk_1B); + sprite->pos2.y = 0; + sprite->data2 = 1; + return TRUE; +} + +bool8 sub_8096494(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (sprite->pos2.y == 0) + { + sub_8098044(mapObject->mapobj_unk_1B); + sprite->data2 = 1; + return TRUE; + } + return FALSE; +} + +bool8 sub_80964B8(struct MapObject *mapObject, struct Sprite *sprite) +{ + return TRUE; +} + +bool8 sub_80964BC(struct MapObject *mapObject, struct Sprite *sprite) +{ + sprite->animPaused = TRUE; + return TRUE; +} + +void npc_obj_transfer_image_anim_pause_flag(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (mapObject->mapobj_bit_10) + { + sprite->animPaused = TRUE; + } +} + +void sub_80964E8(struct MapObject *mapObject, struct Sprite *sprite) +{ + if (mapObject->mapobj_bit_11) + { + sprite->animPaused = FALSE; + mapObject->mapobj_bit_10 = FALSE; + mapObject->mapobj_bit_11 = FALSE; + } +} + +void sub_8096518(struct MapObject *mapObject, struct Sprite *sprite) +{ + sub_8096530(mapObject, sprite); + npc_update_obj_anim_flag(mapObject, sprite); +} + +static void sub_8096530(struct MapObject *mapObject, struct Sprite *sprite) +{ + u16 x; + u16 y; + u16 x2; + u16 y2; + const struct MapObjectGraphicsInfo *graphicsInfo; + + mapObject->mapobj_bit_14 = FALSE; + graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + if (sprite->coordOffsetEnabled) + { + x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX; + y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY; + } + else + { + x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX; + y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY; + } + x2 = graphicsInfo->width; + x2 += x; + y2 = y; + y2 += graphicsInfo->height; + if ((s16)x >= 0x100 || (s16)x2 < -0x10) + { + mapObject->mapobj_bit_14 = TRUE; + } + if ((s16)y >= 0xB0 || (s16)y2 < -0x10) + { + mapObject->mapobj_bit_14 = TRUE; + } +} + +static void npc_update_obj_anim_flag(struct MapObject *mapObject, struct Sprite *sprite) +{ + sprite->invisible = FALSE; + if (mapObject->mapobj_bit_13 || mapObject->mapobj_bit_14) + { + sprite->invisible = TRUE; + } +} diff --git a/src/item.c b/src/item.c index c85e2fe1f..0114676b6 100644 --- a/src/item.c +++ b/src/item.c @@ -8,9 +8,9 @@ extern void ApplyNewEncyprtionKeyToHword(u16* hword, u32 newKey); extern bool8 InBattlePyramid(void); -extern const u8 gOtherText_PokeBalls[]; -extern const u8 gOtherText_Berries[]; -extern const u8 gOtherText_Berry[]; +extern const u8 gText_PokeBalls[]; +extern const u8 gText_Berries[]; +extern const u8 gText_Berry[]; extern const u8 gUnknown_085897E4[][28]; // not sure what this one is bool8 CheckPyramidBagHasItem(u16 itemId, u16 count); @@ -92,7 +92,7 @@ void CopyItemNameHandlePlural(u16 itemId, u8 *string, u32 quantity) if (quantity < 2) StringCopy(string, ItemId_GetItem(ITEM_POKE_BALL)->name); else - StringCopy(string, gOtherText_PokeBalls); + StringCopy(string, gText_PokeBalls); } else { @@ -109,9 +109,9 @@ void GetBerryCountString(u8* dst, const u8* berryName, u32 quantity) u8* txtPtr; if (quantity < 2) - berryString = gOtherText_Berry; + berryString = gText_Berry; else - berryString = gOtherText_Berries; + berryString = gText_Berries; txtPtr = StringCopy(dst, berryName); *txtPtr = CHAR_SPACE; StringCopy(txtPtr + 1, berryString); diff --git a/src/lilycove_lady.c b/src/lilycove_lady.c new file mode 100644 index 000000000..9f38824f9 --- /dev/null +++ b/src/lilycove_lady.c @@ -0,0 +1,1101 @@ +// +// Created by Scott Norton on 9/19/17. +// + +#include "global.h" +#include "main.h" +#include "rom4.h" +#include "rom6.h" +#include "event_data.h" +#include "script.h" +#include "rng.h" +#include "string_util.h" +#include "item.h" +#include "items.h" +#include "item_menu.h" +#include "text.h" +#include "easy_chat.h" +#include "lilycove_lady.h" + +static void SetLilycoveQuizLady(void); +static void SetLilycoveFavourLady(void); +static void SetLilycoveContestLady(void); +static void sub_818E004(void); +static void sub_818DBC4(void); +static void sub_818E674(void); +static u8 sub_818E13C(void); +static bool8 sub_818E1F4(void); +static u8 sub_818E258(const u8 *); + +extern const u8 gText_Lady2[]; + +static const u16 gUnknown_0860B074[] = { + 0x62, 0xcb, 0xdc, 0xcc, 0xd1 +}; +static const u16 gUnknown_0860B07E[] = { + 0x1a, 0x14, 0x0a +}; + +static const u16 Unknown_0860B084[] = { + 0x101b, 0x1623, 0x1812, 0x102c, 0x020e, 0x0c03, 0x1a0b, 0x0210, 0x020d +}; + +static const u16 Unknown_0860B096[] = { + 0x101b, 0x1013, 0x1020, 0x1a0f, 0x020c, 0x0c03, 0x0211, 0x0203, 0x0400 +}; + +static const u16 Unknown_0860B0A8[] = { + 0x0e0f, 0x1018, 0x020e, 0x0204, 0x0c03, 0xffff, 0x0212, 0x0451, 0x0463 +}; + +static const u16 Unknown_0860B0BA[] = { + 0x101b, 0x100b, 0x0e0d, 0x141a, 0x181d, 0x0c03, 0x141e, 0x1a26, 0x1823 +}; + +static const u16 Unknown_0860B0CC[] = { + 0x101b, 0x181d, 0x1018, 0x0a02, 0x2014, 0x0c03, 0x0208, 0x1824, 0x181c +}; + +static const u16 Unknown_0860B0DE[] = { + 0x101b, 0x1000, 0x1c19, 0x265d, 0x0c03, 0xffff, 0x0447, 0x045d, 0x042c +}; + +static const u16 Unknown_0860B0F0[] = { + 0x101b, 0x1034, 0x1e11, 0x100b, 0x1a08, 0x0c03, 0x044b, 0x0446, 0x040a +}; + +static const u16 Unknown_0860B102[] = { + 0x101b, 0x1000, 0x274f, 0x0626, 0x0c03, 0xffff, 0x0442, 0x0411, 0x0450 +}; + +static const u16 Unknown_0860B114[] = { + 0x101b, 0x1000, 0x1c19, 0x043c, 0x0c03, 0xffff, 0x0421, 0x0464, 0x0435 +}; + +static const u16 Unknown_0860B126[] = { + 0x101b, 0x1203, 0x1030, 0x0207, 0x0c03, 0xffff, 0x0210, 0x020e, 0x020d +}; + +static const u16 Unknown_0860B138[] = { + 0x101b, 0x1623, 0x0a05, 0x020e, 0x0c03, 0xffff, 0x1a25, 0x181a, 0x181b +}; + +static const u16 Unknown_0860B14A[] = { + 0x101b, 0x1823, 0x1603, 0x0a02, 0x1812, 0x0c03, 0x1a15, 0x1a23, 0x181b +}; + +static const u16 Unknown_0860B15C[] = { + 0x1020, 0x020e, 0x1010, 0x1043, 0x1e0f, 0x0c03, 0x181c, 0x1a24, 0x1816 +}; + +static const u16 Unknown_0860B16E[] = { + 0x0446, 0x100b, 0x0620, 0x061c, 0x101b, 0x0c03, 0x0420, 0x0426, 0xffff +}; + +static const u16 Unknown_0860B180[] = { + 0x0400, 0x100b, 0x0639, 0x061c, 0x101b, 0x0c03, 0x040e, 0x0410, 0xffff +}; + +static const u16 Unknown_0860B192[] = { + 0x041f, 0x100b, 0x0639, 0x061c, 0x101b, 0x0c03, 0x0445, 0x0400, 0xffff +}; + +static const u16 *const gUnknown_0860B1A4[] = { + Unknown_0860B084, + Unknown_0860B096, + Unknown_0860B0A8, + Unknown_0860B0BA, + Unknown_0860B0CC, + Unknown_0860B0DE, + Unknown_0860B0F0, + Unknown_0860B102, + Unknown_0860B114, + Unknown_0860B126, + Unknown_0860B138, + Unknown_0860B14A, + Unknown_0860B15C, + Unknown_0860B16E, + Unknown_0860B180, + Unknown_0860B192 +}; + +static const u16 gUnknown_0860B1E4[] = { + 0x0210, 0x0400, 0x0212, 0x1a26, 0x0208, 0x045d, 0x040a, 0x0411, 0x0464, 0x020e, 0x1a25, 0x181b, 0x1a24, 0x0420, 0x0410, 0x0400 +}; + +static const u16 gUnknown_0860B204[] = { + 0x007b, 0x007f, 0x0081, 0x0023, 0x0023, 0x0023, 0x00a5, 0x00a7, 0x00a6, 0x000b, 0x012f, 0x006b, 0x006d, 0x0044, 0x0044, 0x000c +}; + +extern const u8 gUnknown_085EEB83[]; +extern const u8 gUnknown_085EEB8C[]; +extern const u8 gUnknown_085EEB95[]; +extern const u8 gUnknown_085EEB9E[]; +extern const u8 gUnknown_085EEBA4[]; +extern const u8 gUnknown_085EEBAB[]; + +static const u8 *const gUnknown_0860B224[] = { + gUnknown_085EEB83, + gUnknown_085EEB8C, + gUnknown_085EEB95, + gUnknown_085EEB9E, + gUnknown_085EEBA4, + gUnknown_085EEBAB +}; + +static const u16 Unknown_0860B23C[] = { + 0x0056, 0x0053, 0x0054, 0x000e, 0x0012, 0x000f, 0x00a7, 0x0011, 0x0010, 0x0018, 0x0019, 0x001e, 0x0000 +}; + +static const u16 Unknown_0860B256[] = { + 0x0051, 0x006a, 0x006b, 0x00cc, 0x00c2, 0x002f, 0x0067, 0x0068, 0x0087, 0x0089, 0x008b, 0x009d, 0x00a0, 0x00a5, 0x0004, 0x0002, 0x0000 +}; + +static const u16 Unknown_0860B278[] = { + 0x0021, 0x000d, 0x001a, 0x001b, 0x001c, 0x00cc, 0x00ca, 0x0026, 0x0086, 0x0096, 0x0097, 0x009a, 0x00a2, 0x00a6, 0x0000 +}; + +static const u16 Unknown_0860B296[] = { + 0x0020, 0x004d, 0x004b, 0x004c, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x006e, 0x005d, 0x006c, 0x006d, 0x006a, 0x006b, 0x00d6, 0x00bc, 0x00b3, 0x000b, 0x000c, 0x0000 +}; + +static const u16 Unknown_0860B2C0[] = { + 0x001f, 0x0013, 0x0014, 0x004a, 0x004e, 0x0049, 0x00a5, 0x00c8, 0x0067, 0x006f, 0x0000 +}; + +static const u16 Unknown_0860B2D6[] = { + 0x00b7, 0x00d3, 0x00d2, 0x00d8, 0x009e, 0x00a6, 0x00ab, 0x00aa, 0x006c, 0x006d, 0x0000 +}; + +static const u16 *const gUnknown_0860B2EC[] = { + Unknown_0860B23C, + Unknown_0860B256, + Unknown_0860B278, + Unknown_0860B296, + Unknown_0860B2C0, + Unknown_0860B2D6 +}; + +static const u16 gUnknown_0860B304[] = { + 0x0b, 0x6e, 0x40, 0x6f, 0x44, 0x47 +}; + +extern const u8 gUnknown_085EEB2B[]; +extern const u8 gUnknown_085EEB34[]; +extern const u8 gUnknown_085EEB3A[]; +extern const u8 gUnknown_085EEB41[]; +extern const u8 gUnknown_085EEB4A[]; +extern const u8 gUnknown_085EEB51[]; +extern const u8 gUnknown_085EEB5A[]; +extern const u8 gUnknown_085EEB61[]; +extern const u8 gUnknown_085EEB6A[]; +extern const u8 gUnknown_085EEB74[]; +extern const u8 gUnknown_085EADA4[]; +extern const u8 gUnknown_085EADB5[]; +extern const u8 gUnknown_085EADC4[]; +extern const u8 gUnknown_085EADD5[]; +extern const u8 gUnknown_085EADE7[]; + +static const u8 *const gUnknown_0860B310[] = { + gUnknown_085EEB2B, + gUnknown_085EEB34, + gUnknown_085EEB3A, + gUnknown_085EEB41, + gUnknown_085EEB4A +}; +static const u8 *const gUnknown_0860B324[] = { + gUnknown_085EEB51, + gUnknown_085EEB5A, + gUnknown_085EEB61, + gUnknown_085EEB6A, + gUnknown_085EEB74 +}; +static const u8 *const gUnknown_0860B338[] = { + gUnknown_085EADA4, + gUnknown_085EADB5, + gUnknown_085EADC4, + gUnknown_085EADD5, + gUnknown_085EADE7 +}; + +static const u16 gUnknown_0860B34C[] = { + 0x0120, 0x013b, 0x011e, 0x013d, 0x0019 +}; + +static EWRAM_DATA struct LilycoveLadyFavour *gUnknown_0203CD64 = NULL; +static EWRAM_DATA struct LilycoveLadyQuiz *gUnknown_0203CD68 = NULL; +static EWRAM_DATA struct LilycoveLadyContest *gUnknown_0203CD6C = NULL; + +extern EWRAM_DATA u16 gScriptItemId; + +u8 GetLilycoveLadyId(void) +{ + return gSaveBlock1Ptr->lilycoveLady.id; +} + +void sub_818D9C0(void) +{ + LilycoveLady *lilycoveLady; + + VarSet(VAR_0x4010, gUnknown_0860B07E[GetLilycoveLadyId()]); + if (GetLilycoveLadyId() == LILYCOVE_LADY_CONTEST) + { + lilycoveLady = &gSaveBlock1Ptr->lilycoveLady; + VarSet(VAR_0x4011, gUnknown_0860B074[lilycoveLady->contest.category]); + gScriptResult = TRUE; + } + else + { + gScriptResult = FALSE; + } +} + +void SetLilycoveLady(void) +{ + u16 id; + + id = ((gSaveBlock2Ptr->playerTrainerId[1] << 8) | gSaveBlock2Ptr->playerTrainerId[0]); + id %= 6; + id >>= 1; + switch (id) + { + case LILYCOVE_LADY_QUIZ: + SetLilycoveQuizLady(); + break; + case LILYCOVE_LADY_FAVOUR: + SetLilycoveFavourLady(); + break; + case LILYCOVE_LADY_CONTEST: + SetLilycoveContestLady(); + break; + } +} + +void sub_818DA78(void) +{ + switch (GetLilycoveLadyId()) + { + case LILYCOVE_LADY_QUIZ: + sub_818E004(); + break; + case LILYCOVE_LADY_FAVOUR: + sub_818DBC4(); + break; + case LILYCOVE_LADY_CONTEST: + sub_818E674(); + break; + } +} + +void SetLilycoveLadyRandomly(void) +{ + u8 id; + + id = Random() % 3; + switch (id) + { + case LILYCOVE_LADY_QUIZ: + SetLilycoveQuizLady(); + break; + case LILYCOVE_LADY_FAVOUR: + SetLilycoveFavourLady(); + break; + case LILYCOVE_LADY_CONTEST: + SetLilycoveContestLady(); + break; + } +} + +void sub_818DAEC(void) +{ + gScriptResult = GetLilycoveLadyId(); +} + +static u8 sub_818DB04(const u16 *data) +{ + u8 len; + + for (len = 0; *data != 0; len ++, data ++); + return len; +} + +static void sub_818DB20(void) +{ + u8 size; + u8 idx; + + gUnknown_0203CD64->unk_00c = Random() % 6; + size = sub_818DB04(gUnknown_0860B2EC[gUnknown_0203CD64->unk_00c]); + idx = Random() % size; + gUnknown_0203CD64->unk_010 = gUnknown_0860B2EC[gUnknown_0203CD64->unk_00c][idx]; +} + +static void SetLilycoveFavourLady(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + gUnknown_0203CD64->id = LILYCOVE_LADY_FAVOUR; + gUnknown_0203CD64->phase = 0; + gUnknown_0203CD64->playerName[0] = EOS; + gUnknown_0203CD64->unk_002 = 0; + gUnknown_0203CD64->unk_003= 0; + gUnknown_0203CD64->itemId = ITEM_NONE; + gUnknown_0203CD64->language = gGameLanguage; + sub_818DB20(); +} + +static void sub_818DBC4(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + gUnknown_0203CD64->id = LILYCOVE_LADY_FAVOUR; + gUnknown_0203CD64->phase = 0; +} + +u8 sub_818DBE8(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + if (gUnknown_0203CD64->phase == 2) + { + return 2; + } + else if (gUnknown_0203CD64->phase == 1) + { + return 1; + } + else + { + return 0; + } +} + +static const u8 *sub_818DC1C(u8 idx) +{ + return gUnknown_0860B224[idx]; +} + +void sub_818DC2C(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + StringCopy(gStringVar1, sub_818DC1C(gUnknown_0203CD64->unk_00c)); +} + +bool8 sub_818DC60(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + if (gUnknown_0203CD64->playerName[0] != EOS) + { + StringCopy7(gStringVar3, gUnknown_0203CD64->playerName); + ConvertInternationalString(gStringVar3, gUnknown_0203CD64->language); + return TRUE; + } + return FALSE; +} + +static void sub_818DCAC(u8 *dest, u16 itemId) +{ + StringCopy(dest, ItemId_GetItem(itemId)->name); +} + +void sub_818DCC8(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + sub_818DCAC(gStringVar2, gUnknown_0203CD64->itemId); +} + +static void sub_818DCF4(const u8 *src, u8 *dest) +{ + memset(dest, 0xFF, 8); + StringCopy7(dest, src); +} + +void sub_818DD14(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + sub_818DCF4(gUnknown_0203CD64->playerName, gStringVar3); + ConvertInternationalString(gStringVar3, gUnknown_0203CD64->language); +} + +bool8 sub_818DD54(void) +{ + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + return gUnknown_0203CD64->unk_002 ? TRUE : FALSE; +} + +void sub_818DD78(void) +{ + sub_81AAC50(); +} + +static bool8 sub_818DD84(u16 itemId) +{ + u8 len; + u8 i; + bool8 response; + + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + len = sub_818DB04(gUnknown_0860B2EC[gUnknown_0203CD64->unk_00c]); + gUnknown_0203CD64->phase = 1; + sub_818DCAC(gStringVar2, itemId); + gUnknown_0203CD64->itemId = itemId; + sub_818DCF4(gSaveBlock2Ptr->playerName, gUnknown_0203CD64->playerName); + gUnknown_0203CD64->language = gGameLanguage; + response = FALSE; + for (i = 0; i < len; i ++) + { + if (gUnknown_0860B2EC[gUnknown_0203CD64->unk_00c][i] == itemId) + { + response = TRUE; + gUnknown_0203CD64->unk_003 ++; + gUnknown_0203CD64->unk_002 = 1; + if (gUnknown_0203CD64->unk_010 == itemId) + { + gUnknown_0203CD64->unk_003 = 5; + } + break; + } + gUnknown_0203CD64->unk_002 = 0; + } + return response; +} + +bool8 sub_818DE44(void) +{ + return sub_818DD84(gScriptItemId); +} + +bool8 sub_818DE5C(void) +{ + u8 checkval; + + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + checkval = gUnknown_0203CD64->unk_003; + return checkval < 5 ? FALSE : TRUE; +} + +static void sub_818DE88(u16 itemId) +{ + sub_818DCAC(gStringVar2, itemId); +} + +u16 sub_818DEA0(void) +{ + u16 itemId; + + gUnknown_0203CD64 = &gSaveBlock1Ptr->lilycoveLady.favour; + itemId = gUnknown_0860B304[gUnknown_0203CD64->unk_00c]; + sub_818DE88(itemId); + gUnknown_0203CD64->phase = 2; + return itemId; +} + +void sub_818DEDC(void) +{ + SetLilycoveFavourLady(); + gUnknown_0203CD64->phase = 1; +} + +void sub_818DEF4(void) +{ + EnableBothScriptContexts(); +} + +static void sub_818DF00(void) +{ + u8 v0; + u8 i; + + v0 = Random() % 16; + for (i = 0; i < 9; i ++) + { + gUnknown_0203CD68->unk_002[i] = gUnknown_0860B1A4[v0][i]; + } + gUnknown_0203CD68->unk_014 = gUnknown_0860B1E4[v0]; + gUnknown_0203CD68->itemId = gUnknown_0860B204[v0]; + gUnknown_0203CD68->unk_02b = v0; + gUnknown_0203CD68->playerName[0] = EOS; +} + +static void SetLilycoveQuizLady(void) +{ + u8 i; + + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->id = LILYCOVE_LADY_QUIZ; + gUnknown_0203CD68->phase = 0; + for (i = 0; i < 9; i ++) + { + gUnknown_0203CD68->unk_002[i] = -1; + } + gUnknown_0203CD68->unk_014 = -1; + gUnknown_0203CD68->unk_016 = -1; + for (i = 0; i < 4; i ++) + { + gUnknown_0203CD68->playerTrainerId[i] = 0; + } + gUnknown_0203CD68->itemId = ITEM_NONE; + gUnknown_0203CD68->unk_02a = 0; + gUnknown_0203CD68->unk_02c = 0x10; + gUnknown_0203CD68->language = gGameLanguage; + sub_818DF00(); +} + +static void sub_818E004(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->id = LILYCOVE_LADY_QUIZ; + gUnknown_0203CD68->phase = 0; + gUnknown_0203CD68->unk_02a = 0; + gUnknown_0203CD68->unk_016 = -1; +} + +u8 sub_818E038(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (gUnknown_0203CD68->phase == 2) + { + return 2; + } + else if (gUnknown_0203CD68->phase == 1) + { + return 1; + } + else + { + return 0; + } +} + +u8 sub_818E06C(void) +{ + int i; + int j; + u8 rv; + struct LilycoveLadyQuiz *quiz; + + quiz = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (sub_811F8D8(quiz->unk_014) == 0) + { + i = quiz->unk_02b; + do + { + if (++ i >= 16) + { + i = 0; + } + } while (sub_811F8D8(gUnknown_0860B1E4[i]) == 0); + for (j = 0; j < 9; j ++) + { + quiz->unk_002[j] = gUnknown_0860B1A4[i][j]; + } + quiz->unk_014 = gUnknown_0860B1E4[i]; + quiz->itemId = gUnknown_0860B204[i]; + quiz->unk_02b = i; + quiz->playerName[0] = EOS; + } + rv = sub_818E13C(); + if (rv == 0) + { + return 2; + } + else if (rv == 2 || sub_818E1F4()) + { + return 1; + } + else + { + return 0; + } +} + +#ifdef NONMATCHING +static u8 sub_818E13C(void) +{ + u8 retval; + u8 len; + u8 i; + + retval = 1; + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (gUnknown_0203CD68->playerName[0] == EOS) + { + StringCopy7(gStringVar1, gText_Lady2); + retval = 0; + } + else + { + StringCopy7(gStringVar1, gUnknown_0203CD68->playerName); + ConvertInternationalString(gStringVar1, gUnknown_0203CD68->language); + len = sub_818E258(gUnknown_0203CD68->playerName); + if (len == sub_818E258(gSaveBlock2Ptr->playerName)) + { + for (i = 0; i < len; i ++) + { + if (gUnknown_0203CD68->playerName[i] != gSaveBlock2Ptr->playerName[i]) + { + retval = 2; + break; + } + } + } + + } + return retval; +} +#else +__attribute__((naked)) static u8 sub_818E13C(void) +{ + asm_unified("\tpush {r4-r7,lr}\n" + "\tmovs r7, 0x1\n" + "\tldr r5, =gUnknown_0203CD68\n" + "\tldr r0, =gSaveBlock1Ptr\n" + "\tldr r1, [r0]\n" + "\tldr r2, =0x00003b58\n" + "\tadds r0, r1, r2\n" + "\tstr r0, [r5]\n" + "\tldrb r0, [r0, 0x18]\n" + "\tcmp r0, 0xFF\n" + "\tbne _0818E174\n" + "\tldr r0, =gStringVar1\n" + "\tldr r1, =gText_Lady2\n" + "\tbl StringCopy7\n" + "\tmovs r7, 0\n" + "\tb _0818E1DC\n" + "\t.pool\n" + "_0818E174:\n" + "\tldr r4, =gStringVar1\n" + "\tldr r0, =0x00003b70\n" + "\tadds r1, r0\n" + "\tadds r0, r4, 0\n" + "\tbl StringCopy7\n" + "\tldr r0, [r5]\n" + "\tadds r0, 0x2D\n" + "\tldrb r1, [r0]\n" + "\tadds r0, r4, 0\n" + "\tbl ConvertInternationalString\n" + "\tldr r0, [r5]\n" + "\tadds r0, 0x18\n" + "\tbl sub_818E258\n" + "\tlsls r0, 24\n" + "\tlsrs r4, r0, 24\n" + "\tldr r6, =gSaveBlock2Ptr\n" + "\tldr r0, [r6]\n" + "\tbl sub_818E258\n" + "\tlsls r0, 24\n" + "\tlsrs r0, 24\n" + "\tcmp r4, r0\n" + "\tbne _0818E1DC\n" + "\tldr r0, [r5]\n" + "\tmovs r2, 0\n" + "\tcmp r2, r4\n" + "\tbcs _0818E1DC\n" + "\tldr r1, [r6]\n" + "\tldrb r0, [r0, 0x18]\n" + "\tldrb r1, [r1]\n" + "\tcmp r0, r1\n" + "\tbne _0818E1DA\n" + "_0818E1BA:\n" + "\tadds r0, r2, 0x1\n" + "\tlsls r0, 24\n" + "\tlsrs r2, r0, 24\n" + "\tcmp r2, r4\n" + "\tbcs _0818E1DC\n" + "\tldr r0, =gUnknown_0203CD68\n" + "\tldr r1, [r0]\n" + "\tadds r1, 0x18\n" + "\tadds r1, r2\n" + "\tldr r0, =gSaveBlock2Ptr\n" + "\tldr r0, [r0]\n" + "\tadds r0, r2\n" + "\tldrb r1, [r1]\n" + "\tldrb r0, [r0]\n" + "\tcmp r1, r0\n" + "\tbeq _0818E1BA\n" + "_0818E1DA:\n" + "\tmovs r7, 0x2\n" + "_0818E1DC:\n" + "\tadds r0, r7, 0\n" + "\tpop {r4-r7}\n" + "\tpop {r1}\n" + "\tbx r1\n" + "\t.pool"); +} +#endif + +static u8 sub_818E1F4(void) +{ + bool8 response; + u8 i; + + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + response = FALSE; + for (i = 0; i < 4; i ++) + { + if (gUnknown_0203CD68->playerTrainerId[i] != gSaveBlock2Ptr->playerTrainerId[i]) + { + response = TRUE; + break; + } + } + return response; +} + +static u8 sub_818E258(const u8 *str) +{ + u8 len; + const u8 *ptr; + + for (len = 0, ptr = str; *ptr != EOS; len ++, ptr ++); + return len; +} + +void sub_818E274(void) +{ + StringCopy(gStringVar1, ItemId_GetItem(gUnknown_0203CD68->itemId)->name); +} + +bool8 sub_818E298(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (!sub_818E13C()) + { + gUnknown_0203CD68->language = gGameLanguage; + return TRUE; + } + return FALSE; +} + +u8 sub_818E2D8(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + return gUnknown_0203CD68->unk_02a; +} + +void sub_818E2FC(void) +{ + easy_chat_input_maybe(); +} + +bool8 sub_818E308(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + CopyEasyChatWord(gStringVar1, gUnknown_0203CD68->unk_014); + CopyEasyChatWord(gStringVar2, gUnknown_0203CD68->unk_016); + return StringCompare(gStringVar1, gStringVar2) ? FALSE : TRUE; +} + +void sub_818E358(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gSpecialVar_0x8005 = gUnknown_0203CD68->itemId; +} + +void sub_818E37C(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->phase = 1; +} + +void sub_818E39C(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->phase = 2; +} + +void sub_818E3BC(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->unk_016 = -1; +} + +void sub_818E3E0(void) +{ + sub_81AAC70(); +} + +void sub_818E3EC(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (sub_818E298()) + { + gUnknown_0203CD68->unk_02c = gUnknown_0203CD68->unk_02b; + } + else + { + gUnknown_0203CD68->unk_02c = 0x10; + } + sub_818DF00(); +} + +void sub_818E430(void) +{ + u8 i; + + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + for (i = 0; i < 9; i ++) + { + gUnknown_0203CD68->unk_002[i] = -1; + } + gUnknown_0203CD68->unk_014 = -1; +} + +void sub_818E47C(void) +{ + gSpecialVar_0x8004 = 0x11; + easy_chat_input_maybe(); +} + +void sub_818E490(void) +{ + RemoveBagItem(gScriptItemId, 1); +} + +void sub_818E4A4(void) +{ + u8 i; + + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->itemId = gScriptItemId; + for (i = 0; i < 4; i ++) + { + gUnknown_0203CD68->playerTrainerId[i] = gSaveBlock2Ptr->playerTrainerId[i]; + } + StringCopy7(gUnknown_0203CD68->playerName, gSaveBlock2Ptr->playerName); + gUnknown_0203CD68->language = gGameLanguage; +} + +void sub_818E510(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + gUnknown_0203CD68->unk_02a = 1; +} + +void sub_818E538(void) +{ + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + CopyEasyChatWord(gStringVar3, gUnknown_0203CD68->unk_014); +} + +void sub_818E564(void) +{ + EnableBothScriptContexts(); +} + +void sub_818E570(const struct LilycoveLadyQuiz *quiz) +{ + u8 i; + + gUnknown_0203CD68 = &gSaveBlock1Ptr->lilycoveLady.quiz; + if (quiz->unk_02c < 16 && gUnknown_0203CD68->id == LILYCOVE_LADY_QUIZ) + { + for (i = 0; i < 4; i ++) + { + if (quiz->unk_02c != gUnknown_0203CD68->unk_02b) + { + break; + } + gUnknown_0203CD68->unk_02b = Random() % 16; + } + if (quiz->unk_02c == gUnknown_0203CD68->unk_02b) + { + gUnknown_0203CD68->unk_02b = (gUnknown_0203CD68->unk_02b + 1) % 16; + } + gUnknown_0203CD68->unk_02c = quiz->unk_02c; + } +} + +static void sub_818E604(void) +{ + gUnknown_0203CD6C->playerName[0] = EOS; + gUnknown_0203CD6C->fave_pkblk = 0; + gUnknown_0203CD6C->other_pkblk = 0; + gUnknown_0203CD6C->max_sheen = 0; + gUnknown_0203CD6C->category = Random() % 5; +} + +static void SetLilycoveContestLady(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + gUnknown_0203CD6C->id = LILYCOVE_LADY_CONTEST; + gUnknown_0203CD6C->phase = 0; + sub_818E604(); + gUnknown_0203CD6C->language = gGameLanguage; +} + +static void sub_818E674(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + gUnknown_0203CD6C->id = LILYCOVE_LADY_CONTEST; + gUnknown_0203CD6C->phase = 0; + if (gUnknown_0203CD6C->fave_pkblk == 5 || gUnknown_0203CD6C->other_pkblk == 5) + { + sub_818E604(); + } +} + +static void sub_818E6B0(u8 sheen) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + if (gUnknown_0203CD6C->max_sheen <= sheen) + { + gUnknown_0203CD6C->max_sheen = sheen; + memset(gUnknown_0203CD6C->playerName, EOS, sizeof(gUnknown_0203CD6C->playerName)); + memcpy(gUnknown_0203CD6C->playerName, gSaveBlock2Ptr->playerName, sizeof(gUnknown_0203CD6C->playerName)); + gUnknown_0203CD6C->language = gGameLanguage; + } +} + +bool8 sub_818E704(struct Pokeblock *pokeblock) +{ + u8 sheen; + bool8 response; + + sheen = 0; + response = FALSE; + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + switch (gUnknown_0203CD6C->category) + { + case 0: + if (pokeblock->spicy != 0) + { + sheen = pokeblock->spicy; + response = TRUE; + } + break; + case 1: + if (pokeblock->dry != 0) + { + sheen = pokeblock->dry; + response = TRUE; + } + break; + case 2: + if (pokeblock->sweet != 0) + { + sheen = pokeblock->sweet; + response = TRUE; + } + break; + case 3: + if (pokeblock->bitter != 0) + { + sheen = pokeblock->bitter; + response = TRUE; + } + break; + case 4: + if (pokeblock->sour != 0) + { + sheen = pokeblock->sour; + response = TRUE; + } + break; + } + if (response == TRUE) + { + sub_818E6B0(sheen); + gUnknown_0203CD6C->fave_pkblk ++; + } + else + { + gUnknown_0203CD6C->other_pkblk ++; + } + return response; +} + +static void sub_818E794(u8 *dest1, u8 *dest2) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + StringCopy(dest1, gUnknown_0860B324[gUnknown_0203CD6C->category]); + StringCopy10(dest2, gUnknown_0860B310[gUnknown_0203CD6C->category]); +} + +void sub_818E7E0(u8 *dest1, u8 *dest2) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + *dest1 = gUnknown_0203CD6C->category; + StringCopy(dest2, gUnknown_0860B310[gUnknown_0203CD6C->category]); +} + +void sub_818E81C(u8 *dest) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + StringCopy(dest, gUnknown_0203CD6C->playerName); +} + +void sub_818E848(u8 *dest) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + *dest = gUnknown_0203CD6C->language; +} + +void sub_818E868(u8 *dest, u8 category) +{ + StringCopy(dest, gUnknown_0860B338[category]); +} + +u8 sub_818E880(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + if (gUnknown_0203CD6C->fave_pkblk >= 5) + { + return 1; + } + else if (gUnknown_0203CD6C->fave_pkblk == 0) + { + return 2; + } + else + { + return 0; + } +} + +bool8 sub_818E8B4(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + if (gUnknown_0203CD6C->phase == 1) + { + return TRUE; + } + return FALSE; +} + +bool8 sub_818E8E0(void) +{ + bool8 response; + + response = FALSE; + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + if (gUnknown_0203CD6C->fave_pkblk >= 5 || gUnknown_0203CD6C->other_pkblk >= 5) + { + response = TRUE; + } + return response; +} + +void sub_818E914(void) +{ + sub_818E794(gStringVar2, gStringVar1); +} + +void sub_818E92C(void) +{ + sub_81357FC(3, c2_exit_to_overworld_2_switch); +} + +void sub_818E940(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + gUnknown_0203CD6C->phase = 1; +} + +void sub_818E960(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + gSpecialVar_0x8005 = gUnknown_0860B34C[gUnknown_0203CD6C->category]; +} + +u8 sub_818E990(void) +{ + gUnknown_0203CD6C = &gSaveBlock1Ptr->lilycoveLady.contest; + return gUnknown_0203CD6C->category; +} diff --git a/src/load_save.c b/src/load_save.c index 588387186..68d978e3d 100644 --- a/src/load_save.c +++ b/src/load_save.c @@ -6,15 +6,11 @@ #include "rng.h" #include "malloc.h" -extern u8 gPlayerPartyCount; -extern struct PokemonStorage* gPokemonStoragePtr; extern void* gUnknown_0203CF5C; -extern u8 gHeap[0x1C000]; extern bool16 IdentifyFlash(void); extern void SetBagItemsPointers(void); extern void SetDecorationInventoriesPointers(void); -extern void InitHeap(void *heapStart, u32 heapSize); void ApplyNewEncyprtionKeyToAllEncryptedData(u32 encryptionKey); diff --git a/src/malloc.c b/src/malloc.c index 3901c5a35..ccb2f7d20 100644 --- a/src/malloc.c +++ b/src/malloc.c @@ -38,7 +38,7 @@ void PutMemBlockHeader(void *block, struct MemBlock *prev, struct MemBlock *next void PutFirstMemBlockHeader(void *block, u32 size) { - PutMemBlockHeader(block, (struct MemBlock *)block, (struct MemBlock *)block, size - 16); + PutMemBlockHeader(block, (struct MemBlock *)block, (struct MemBlock *)block, size - sizeof(struct MemBlock)); } void *AllocInternal(void *heapStart, u32 size) @@ -48,6 +48,7 @@ void *AllocInternal(void *heapStart, u32 size) struct MemBlock *splitBlock; u32 foundBlockSize; + // Alignment if (size & 3) size = 4 * ((size / 4) + 1); @@ -58,7 +59,7 @@ void *AllocInternal(void *heapStart, u32 size) foundBlockSize = pos->size; if (foundBlockSize >= size) { - if (foundBlockSize - size <= 31) { + if (foundBlockSize - size < 2 * sizeof(struct MemBlock)) { // The block isn't much bigger than the requested size, // so just use it. pos->flag = TRUE; diff --git a/src/multiboot.c b/src/multiboot.c index 80291ff46..7fd6df2d0 100644 --- a/src/multiboot.c +++ b/src/multiboot.c @@ -316,7 +316,7 @@ void MultiBootStartProbe(struct MultiBootParam *mp) mp->probe_count = 1; } -void MultiBootStartMaster(struct MultiBootParam *mp, u8 *srcp, int length, u8 palette_color, s8 palette_speed) +void MultiBootStartMaster(struct MultiBootParam *mp, const u8 *srcp, int length, u8 palette_color, s8 palette_speed) { int i = 0; diff --git a/src/pokemon_2.c b/src/pokemon_2.c index 30e788874..cf073570d 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -31,7 +31,7 @@ extern const union AnimCmd* gUnknown_082FF70C[]; extern const union AnimCmd* const * const gUnknown_08309AAC[]; extern const union AnimCmd* const * const gUnknown_08305D0C[]; extern const union AnimCmd* const * const gUnknown_0830536C[]; -extern const u8 gBadEggNickname[]; +extern const u8 gText_BadEgg[]; extern const u8 gText_EggNickname[]; extern u8 GetBankSide(u8 bank); @@ -409,8 +409,8 @@ u32 GetBoxMonData(struct BoxPokemon *boxMon, s32 field, u8 *data) if (boxMon->isBadEgg) { for (retVal = 0; - retVal < POKEMON_NAME_LENGTH && gBadEggNickname[retVal] != EOS; - data[retVal] = gBadEggNickname[retVal], retVal++) {} + retVal < POKEMON_NAME_LENGTH && gText_BadEgg[retVal] != EOS; + data[retVal] = gText_BadEgg[retVal], retVal++) {} data[retVal] = EOS; } diff --git a/src/pokemon_3.c b/src/pokemon_3.c index a2282539e..603732a34 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -46,16 +46,16 @@ extern const struct SpindaSpot gSpindaSpotGraphics[]; extern const u8* const gStatNamesTable[]; extern const u8 gSpeciesNames[][11]; extern const u8 gUnknown_08329EC8[]; -extern const u8 gUnknown_085CB38A[]; -extern const u8 gUnknown_085CB3AA[]; -extern const u8 gUnknown_085CA459[]; -extern const u8 gUnknown_085CA424[]; +extern const u8 gText_StatRose[]; +extern const u8 gText_PkmnsStatChanged2[]; +extern const u8 gText_PkmnGettingPumped[]; +extern const u8 gText_PkmnShroudedInMist[]; extern const s8 gNatureStatTable[][5]; extern const s8 gUnknown_08329ECE[][3]; extern const u32 gBitTable[]; extern const u32 gTMHMLearnsets[][2]; -extern const u8 BattleText_Wally[]; -extern const u8 BattleText_PreventedSwitch[]; +extern const u8 gText_BattleWallyName[]; +extern const u8 gText_PkmnsXPreventsSwitching[]; extern const struct CompressedSpritePalette gMonPaletteTable[]; extern const struct CompressedSpritePalette gMonShinyPaletteTable[]; extern const u16 gHMMoves[]; @@ -215,8 +215,8 @@ void sub_806CF24(s32 stat) { gBankTarget = gBankInMenu; StringCopy(gBattleTextBuff1, gStatNamesTable[gUnknown_08329EC8[stat]]); - StringCopy(gBattleTextBuff2, gUnknown_085CB38A); - StrCpyDecodeToDisplayedStringBattle(gUnknown_085CB3AA); + StringCopy(gBattleTextBuff2, gText_StatRose); + StrCpyDecodeToDisplayedStringBattle(gText_PkmnsStatChanged2); } u8 *sub_806CF78(u16 itemId) @@ -251,7 +251,7 @@ u8 *sub_806CF78(u16 itemId) else { gBankAttacker = gBankInMenu; - StrCpyDecodeToDisplayedStringBattle(gUnknown_085CA459); + StrCpyDecodeToDisplayedStringBattle(gText_PkmnGettingPumped); } } } @@ -259,7 +259,7 @@ u8 *sub_806CF78(u16 itemId) if (itemEffect[3] & 0x80) { gBankAttacker = gBankInMenu; - StrCpyDecodeToDisplayedStringBattle(gUnknown_085CA424); + StrCpyDecodeToDisplayedStringBattle(gText_PkmnShroudedInMist); } return gDisplayedStringBattle; @@ -1177,7 +1177,7 @@ u16 GetBattleBGM(void) case CLASS_PKMN_TRAINER_RIVAL: if (gBattleTypeFlags & BATTLE_TYPE_FRONTIER) return 0x1E1; - if (!StringCompare(gTrainers[gTrainerBattleOpponent_A].trainerName, BattleText_Wally)) + if (!StringCompare(gTrainers[gTrainerBattleOpponent_A].trainerName, gText_BattleWallyName)) return 0x1DC; return 0x1E1; case CLASS_ELITE_FOUR: @@ -1374,7 +1374,7 @@ void sub_806E994(void) gBattleTextBuff2[2] = gBankInMenu; gBattleTextBuff2[3] = pokemon_order_func(gBattlePartyID[gBankInMenu]); gBattleTextBuff2[4] = EOS; - StrCpyDecodeBattle(BattleText_PreventedSwitch, gStringVar4); + StrCpyDecodeBattle(gText_PkmnsXPreventsSwitching, gStringVar4); } struct PokeItem diff --git a/src/pokemon_size_record.c b/src/pokemon_size_record.c index 804dbda74..12d98bfd8 100644 --- a/src/pokemon_size_record.c +++ b/src/pokemon_size_record.c @@ -45,8 +45,8 @@ static const u8 sGiftRibbonsMonDataIds[] = MON_DATA_GIFT_RIBBON_7 }; -extern const u8 gOtherText_DecimalPoint[]; -extern const u8 gOtherText_Marco[]; +extern const u8 gText_DecimalPoint[]; +extern const u8 gText_Marco[]; extern const u8 gSpeciesNames[][POKEMON_NAME_LENGTH + 1]; #define CM_PER_INCH 2.54 @@ -103,7 +103,7 @@ static void FormatMonSizeRecord(u8 *string, u32 size) #endif string = ConvertIntToDecimalStringN(string, size / 10, 0, 8); - string = StringAppend(string, gOtherText_DecimalPoint); + string = StringAppend(string, gText_DecimalPoint); ConvertIntToDecimalStringN(string, size % 10, 0, 1); } @@ -152,7 +152,7 @@ static void GetMonSizeRecordInfo(u16 species, u16 *sizeRecord) FormatMonSizeRecord(gStringVar3, size); StringCopy(gStringVar1, gSpeciesNames[species]); if (*sizeRecord == DEFAULT_MAX_SIZE) - StringCopy(gStringVar2, gOtherText_Marco); + StringCopy(gStringVar2, gText_Marco); else StringCopy(gStringVar2, gSaveBlock2Ptr->playerName); } diff --git a/src/reset_save_heap.c b/src/reset_save_heap.c new file mode 100644 index 000000000..b786ff9f8 --- /dev/null +++ b/src/reset_save_heap.c @@ -0,0 +1,32 @@ +#include "global.h" +#include "main.h" +#include "gpu_regs.h" +#include "m4a.h" +#include "load_save.h" +#include "save.h" +#include "new_game.h" +#include "rom4.h" +#include "malloc.h" + +void sub_81700F8(void) +{ + u16 imeBackup; + + imeBackup = REG_IME; + REG_IME = 0; + RegisterRamReset(0x00000001); + ClearGpuRegBits(REG_OFFSET_DISPCNT, 0x80); + REG_IME = imeBackup; + gMain.inBattle = FALSE; + SetSaveBlocksPointers(sub_815355C()); + sub_808447C(); + ResetSaveCounters(); + sub_81534D0(0); + if (gSaveFileStatus == 0 || gSaveFileStatus == 2) + { + Sav2_ClearSetDefault(); + } + SetPokemonCryStereo(gSaveBlock2Ptr->optionsSound); + InitHeap(gHeap, 0x1c000); + SetMainCallback2(sub_8086230); +} diff --git a/src/start_menu.c b/src/start_menu.c index ffcab5220..ac393ce2e 100644 --- a/src/start_menu.c +++ b/src/start_menu.c @@ -151,7 +151,7 @@ static void BuildStartMenuActions_MultiBattleRoom(void) extern const struct WindowTemplate gSafariBallsWindowTemplate; extern const struct WindowTemplate gPyramidFloorWindowTemplate_1; extern const struct WindowTemplate gPyramidFloorWindowTemplate_2; -extern const u8 gOtherText_SafariStock[]; +extern const u8 gText_SafariBallStock[]; void DisplaySafariBallsWindow(void) { @@ -159,13 +159,13 @@ void DisplaySafariBallsWindow(void) PutWindowTilemap(sSafariBallsWindowId); sub_81973FC(sSafariBallsWindowId, 0); ConvertIntToDecimalStringN(gStringVar1, gNumSafariBalls, STR_CONV_MODE_RIGHT_ALIGN, 2); - StringExpandPlaceholders(gStringVar4, gOtherText_SafariStock); + StringExpandPlaceholders(gStringVar4, gText_SafariBallStock); PrintTextOnWindow(sSafariBallsWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL); CopyWindowToVram(sSafariBallsWindowId, 2); } extern const u8* const gUnknown_08510510[]; -extern const u8 gOtherText_BattlePyramid_X[]; +extern const u8 gText_BattlePyramidFloor[]; void DisplayPyramidFloorWindow(void) { @@ -177,7 +177,7 @@ void DisplayPyramidFloorWindow(void) PutWindowTilemap(sBattlePyramidFloorWindowId); sub_81973FC(sBattlePyramidFloorWindowId, 0); StringCopy(gStringVar1, gUnknown_08510510[*(u16*)(&gSaveBlock2Ptr->field_CAA[8])]); - StringExpandPlaceholders(gStringVar4, gOtherText_BattlePyramid_X); + StringExpandPlaceholders(gStringVar4, gText_BattlePyramidFloor); PrintTextOnWindow(sBattlePyramidFloorWindowId, 1, gStringVar4, 0, 1, 0xFF, NULL); CopyWindowToVram(sBattlePyramidFloorWindowId, 2); } diff --git a/src/text.c b/src/text.c index 4b963d1a6..0081a8244 100644 --- a/src/text.c +++ b/src/text.c @@ -2778,7 +2778,7 @@ _08005D6E:\n\ bx r1"); } -u32 GetStringWidthFixedWidthFont(u8 *str, u8 fontId, u8 letterSpacing) +u32 GetStringWidthFixedWidthFont(const u8 *str, u8 fontId, u8 letterSpacing) { int i; u8 width; @@ -2787,7 +2787,7 @@ u32 GetStringWidthFixedWidthFont(u8 *str, u8 fontId, u8 letterSpacing) u8 line; int strPos; u8 lineWidths[8]; - u8 *strLocal; + const u8 *strLocal; for (i = 0; i < 8; i++) { @@ -2882,7 +2882,7 @@ u32 (*GetFontWidthFunc(u8 glyphId))(u16, bool32) return 0; } -s32 GetStringWidth(u8 fontId, u8 *str, s16 letterSpacing) +u32 GetStringWidth(u8 fontId, const u8 *str, s16 letterSpacing) { bool8 isJapanese; int minGlyphWidth; diff --git a/src/trig.c b/src/trig.c index 93cf06893..c2bca3059 100644 --- a/src/trig.c +++ b/src/trig.c @@ -1,9 +1,6 @@ #include "global.h" #include "trig.h" -// Converts a number to Q4.12 fixed-point format -#define Q_4_12(n) ((s16)((n) * 4096)) - // Values of sin(x*(π/128)) as Q8.8 fixed-point numbers from x = 0 to x = 319 const s16 gSineTable[] = { |